nixamp 0.7.5 → 0.7.7

package/dist/server.js

@@ -292,7 +292,8 @@ export function toRemoteTracks(tracks) {
         // Said out loud, because a remote cannot see the path and had been sending
         // every track to the audio element -- a film's soundtrack over a blank
         // panel, which is exactly what it looked like.
-        ...(hasPicture(t.path) ? { video: true } : {}),
+        // The name when it says something, what ffprobe found when it does not.
+        ...(t.picture ?? hasPicture(t.path) ? { video: true } : {}),
         // Only for what was added; the library's own tracks say nothing, which is
         // how a client knows they are the library.
         ...(t.group ? { group: t.group } : {}),
@@ -304,6 +305,24 @@ export function hasPicture(path) {
     const dot = path.lastIndexOf(".");
     return dot > 0 && PICTURE.has(path.slice(dot).toLowerCase());
 }
+/**
+ * Whether the name of a source tells us anything about what is inside it.
+ *
+ * A remote address with no extension -- an IPTV channel, a stream key, a
+ * redirect -- is the case where it does not, and the only way to find out is
+ * to look.
+ */
+export function nameSaysNothing(path) {
+    if (!isRemote(path))
+        return false;
+    try {
+        const last = new URL(path).pathname.split("/").pop() ?? "";
+        return !last.includes(".");
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * The headless player: the terminal app's engine without the terminal.
  * One ffmpeg decodes, ffplay makes the sound, and every sample is measured on
@@ -565,6 +584,30 @@ export class PlayerEngine {
         }
         return seen;
     }
+    /**
+     * The library, arriving after the server was already listening.
+     *
+     * Walking a directory is the slow part of starting -- eighty thousand files
+     * under a home directory takes far longer than the fifteen seconds
+     * `nixamp daemon start` waits for the server to say it is up, so starting a
+     * daemon with no source given looked exactly like hanging and then failed
+     * about a server that was working. The port opens first now and this puts
+     * the library in behind it.
+     *
+     * Unlike `replace` it stops nothing and clears no listeners: whoever
+     * connected in the first second is still connected, and simply sees the
+     * playlist appear.
+     */
+    fill(tracks, root) {
+        // Something is already loaded, so this is a scan that finished after
+        // somebody pointed the server elsewhere. Theirs wins.
+        if (this.tracks.length > 0)
+            return;
+        this.tracks = tracks;
+        this.root = root;
+        this.state.note = tracks.length === 0 ? `No audio files under ${root}.` : "";
+        this.push(true);
+    }
     retag(tracks, root) {
         // Matched by path rather than by position, because the list is no longer
         // required to be the one that was sent for tagging: somebody can add an
@@ -611,6 +654,7 @@ export class EmptyEngine {
         return undefined;
     }
     replace() { }
+    fill() { }
     add() {
         return 0;
     }
@@ -632,6 +676,14 @@ const CORS = {
     "access-control-allow-headers": "content-type",
     "access-control-max-age": "86400",
 };
+/**
+ * How many nameless addresses are worth an ffprobe when a source is added.
+ *
+ * One is the ordinary case -- somebody pasting a channel -- and a directory
+ * listing of thousands must not turn into thousands of probes for an answer
+ * that only changes which element a browser uses.
+ */
+const PROBE_BY_HAND = 8;
 /** /api/v1/<provider>/oauth/start and .../callback, the house callback shape. */
 const OAUTH_ROUTE = /^\/api\/v1\/([a-z0-9-]+)\/oauth\/(start|callback)$/;
 /**
@@ -1768,6 +1820,9 @@ export function createHandler(engine, options) {
                 active: tracker.active,
                 startedAt: started,
                 now: Date.now(),
+                // Where to point OBS. Printed at startup since RTMP was added, which
+                // is no use at all to somebody looking at the admin panel a day later.
+                publish: options.publishUrls?.() ?? [],
             });
             return;
         }
@@ -1872,11 +1927,23 @@ export function createHandler(engine, options) {
                 return;
             }
             try {
-                const tracks = await options.load(source);
+                let tracks = await options.load(source);
                 if (tracks.length === 0) {
                     json(response, 422, { error: `nothing to play at ${source}` });
                     return;
                 }
+                // A handful of addresses whose names say nothing get asked what they
+                // are, so a live channel arrives as a picture rather than as its own
+                // soundtrack. Capped, because a playlist of five thousand of them is
+                // five thousand ffprobes and the answer only matters for the few a
+                // person adds by hand.
+                const looked = await Promise.all(tracks.map(async (track, at) => {
+                    if (at >= PROBE_BY_HAND || !nameSaysNothing(track.path))
+                        return track;
+                    const codecs = await codecsOf({ ffmpeg: [], ffprobe: options.ffprobe ?? ["ffprobe"], play: null }, track.path);
+                    return codecs.video === "" ? track : { ...track, picture: true };
+                }));
+                tracks = looked;
                 let added = tracks.length;
                 if (replacing) {
                     engine.replace(tracks, source);
@@ -1930,17 +1997,21 @@ export function createHandler(engine, options) {
             const capKbps = Number.isFinite(asked) && asked > 0 ? Math.min(20_000, Math.max(200, asked)) : 0;
             if (playsInBrowser(file) && capKbps === 0) {
                 sendFile(request, response, file);
+                return;
             }
-            else if (hasPicture(file)) {
-                // A film. It used to arrive as MP3 with `-vn`, which is to say as a
-                // soundtrack over a blank panel; what ffprobe finds inside decides how
-                // little work it takes to keep the picture.
+            // A film, or something whose name refuses to say. A live channel at
+            // .../301 used to fall through to the audio branch and arrive as MP3
+            // with `-vn` -- a match you could only listen to.
+            if (hasPicture(file) || nameSaysNothing(file)) {
+                // What ffprobe finds inside decides how little work it takes to keep
+                // the picture, and whether there is a picture to keep at all.
                 const codecs = await codecsOf({ ffmpeg: [], ffprobe: options.ffprobe ?? ["ffprobe"], play: null }, file);
-                pipeFfmpeg(request, response, file, options.ffmpeg ?? ["ffmpeg"], videoArgs(codecs, capKbps), "video/mp4");
-            }
-            else {
-                transcode(request, response, file, options.ffmpeg ?? ["ffmpeg"]);
+                if (codecs.video !== "") {
+                    pipeFfmpeg(request, response, file, options.ffmpeg ?? ["ffmpeg"], videoArgs(codecs, capKbps), "video/mp4");
+                    return;
+                }
             }
+            transcode(request, response, file, options.ffmpeg ?? ["ffmpeg"]);
             return;
         }
         // Whatever the source is, this comes back as MP3 a browser will play:
@@ -2298,10 +2369,9 @@ export async function serve(argv, version = "0.1.0") {
     //
     // So the filenames are enough to start: the server is up and answering in the
     // time it takes to walk the directory, and the titles fill in behind it.
-    const tracks = await loadSource(tools, root, false);
-    const engine = tracks.length > 0
-        ? new PlayerEngine(tracks, root, tools)
-        : new EmptyEngine(`No audio files under ${root}.`);
+    // Empty on purpose. The walk happens below, once the port is open: it is
+    // the slowest part of starting and nothing about it needs to happen first.
+    const engine = new PlayerEngine([], root, tools);
     const web = options.web !== null ? resolve(options.web) : defaultWebDir();
     const key = options.key ? newKey() : null;
     // Minted whether or not it is published, so `nixamp admin` and the operator
@@ -2500,11 +2570,16 @@ export async function serve(argv, version = "0.1.0") {
             }
         })()
         : undefined;
+    // Filled in below, when the RTMP listeners are opened. Read through a
+    // function so the handler sees the list rather than the empty array it was
+    // built with.
+    let publishUrls = [];
     const server = createServer(engine, {
         web,
         media: options.media,
         owner,
         channels,
+        publishUrls: () => publishUrls,
         ...(ingest ? { ingest } : {}),
         broadcaster,
         broadcast: () => ({ destinations, settings: DEFAULT_ENCODER }),
@@ -2608,19 +2683,30 @@ export async function serve(argv, version = "0.1.0") {
             guessedPublic: guessedPublic !== "",
         }));
     }
-    // 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
-    // awaited: nothing downstream needs it, and a library that takes a minute to
-    // read should cost nobody a minute of silence.
-    if (tracks.length > 0 && !isRemote(root)) {
-        void loadTagged(tools, root)
+    // Names now, tags later, and both after the door is open. Not awaited:
+    // nothing below needs the library, and a directory that takes a minute to
+    // walk should cost nobody a minute of not being able to connect.
+    void loadSource(tools, root, false)
+        .then((found) => {
+        engine.fill(found, root);
+        if (found.length === 0) {
+            console.log(`nixamp serve — no audio files under ${root}`);
+            return;
+        }
+        console.log(`nixamp serve — ${found.length} tracks under ${root}`);
+        if (isRemote(root))
+            return;
+        return loadTagged(tools, root)
             .then((tagged) => engine.retag(tagged, root))
             .catch(() => {
-            // Filenames are a working player. A failure here is worth nothing but
-            // titles that stay as they are.
+            // Filenames are a working player. A failure here is worth nothing
+            // but titles that stay as they are.
         });
-    }
-    console.log(`nixamp serve — ${tracks.length} tracks under ${root}`);
+    })
+        .catch((error) => {
+        console.log(`nixamp: could not read ${root}: ${error.message}`);
+    });
+    console.log(`nixamp serve — reading ${root}`);
     console.log("");
     const width = Math.max(...addresses.map((a) => a.label.length));
     for (const { label, url } of addresses) {
@@ -2673,9 +2759,13 @@ export async function serve(argv, version = "0.1.0") {
         }));
         rtmp = new RtmpListeners(channels, tools.ffmpeg, listenKey ?? "live");
         rtmp.listen(slots);
+        publishUrls = slots.map((slot) => ({
+            id: slot.id,
+            url: `rtmp://${host}:${slot.port}/live/${listenKey ?? "live"}`,
+        }));
         console.log("  Or publish from OBS, Larix or ffmpeg, one per URL:");
-        for (const slot of slots) {
-            console.log(`    rtmp://${host}:${slot.port}/live/${listenKey ?? "live"}   -> "${slot.id}"`);
+        for (const entry of publishUrls) {
+            console.log(`    ${entry.url}   -> "${entry.id}"`);
         }
     }
     if (destinations.length > 0) {
@@ -2739,7 +2829,9 @@ export async function serve(argv, version = "0.1.0") {
                 name: options.name || hostname(),
                 url: listen,
                 audio,
-                tracks: tracks.length,
+                // Asked of the engine rather than a variable, because the library is
+                // now read after the port opens and may still be arriving.
+                tracks: engine.snapshot(false).trackCount,
                 // From `nixamp login`. The directory will not list a stream it cannot
                 // attribute to somebody, because a listing is now a phone code that
                 // costs money to answer.

package/dist/session.js

@@ -512,7 +512,9 @@ export async function servers(argv, fetcher = fetch) {
                 const daemon = await import("./daemon.js");
                 const state = daemon.readState();
                 if (state === null) {
-                    console.error("nixamp: no daemon is running here. Start one, or pass a URL.");
+                    console.error("nixamp: no daemon is running here.\n" +
+                        "  Start one:  nixamp daemon start ~/Music\n" +
+                        "  Or give the share link of the one you mean: https://host:4321/s/KEY");
                     return 1;
                 }
                 // The address worth remembering is the one somebody else can open.

package/dist/share.d.ts

@@ -45,6 +45,16 @@ export declare function lookupPublicIp(send?: typeof fetch, timeoutMs?: number):
  * somewhere else can open. It is labelled for what it is, because the key in
  * the link is then the only thing between a stranger and the library.
  */
+/**
+ * Whether a browser could ever verify a certificate for this address.
+ *
+ * A certificate is issued for a name. Handed an https link to a bare IP, a
+ * browser has nothing to match it against and refuses the connection before it
+ * asks anything -- and from the page it looks identical to a machine that is
+ * switched off. Offering such a link is offering one that cannot work, so the
+ * links are labelled and the ones that can work go first.
+ */
+export declare function certifiable(url: string): boolean;
 export declare function reachableAddresses(host: string, port: number, publicUrl?: string, scheme?: "http" | "https"): {
     label: string;
     url: string;

package/dist/share.js

@@ -115,6 +115,25 @@ export async function lookupPublicIp(send = fetch, timeoutMs = 2500) {
  * somewhere else can open. It is labelled for what it is, because the key in
  * the link is then the only thing between a stranger and the library.
  */
+/**
+ * Whether a browser could ever verify a certificate for this address.
+ *
+ * A certificate is issued for a name. Handed an https link to a bare IP, a
+ * browser has nothing to match it against and refuses the connection before it
+ * asks anything -- and from the page it looks identical to a machine that is
+ * switched off. Offering such a link is offering one that cannot work, so the
+ * links are labelled and the ones that can work go first.
+ */
+export function certifiable(url) {
+    if (!url.startsWith("https://"))
+        return true;
+    try {
+        return !isIpAddress(new URL(url).hostname.replace(/^\[|\]$/g, ""));
+    }
+    catch {
+        return true;
+    }
+}
 export function reachableAddresses(host, port, publicUrl = "", scheme = "http") {
     const link = (address) => {
         // A bare IPv6 address needs brackets before it is a URL.
@@ -143,11 +162,22 @@ export function reachableAddresses(host, port, publicUrl = "", scheme = "http")
     }
     const order = { private: 0, cgnat: 1, public: 2 };
     found.sort((x, y) => order[x.kind] - order[y.kind]);
-    return [
+    const all = [
         ...told,
         { label: "here", url: `${scheme}://localhost:${port}` },
         ...found.map(({ label, url }) => ({ label, url })),
     ];
+    // Serving https, an address that is a bare IP cannot be verified by anyone,
+    // so it is said last and said differently rather than handed out as though
+    // it were a link somebody could use.
+    if (scheme !== "https")
+        return all;
+    return [
+        ...all.filter((entry) => certifiable(entry.url)),
+        ...all
+            .filter((entry) => !certifiable(entry.url))
+            .map((entry) => ({ label: `${entry.label} (no certificate for an IP)`, url: entry.url })),
+    ];
 }
 /** The full link, key and all. */
 export function shareLink(base, key) {

package/package.json

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

package/src/admin.ts

@@ -57,7 +57,17 @@ export function resolveTarget(argv: string[]): AdminOptions {
 
   const state = readState();
   if (state === null) {
-    throw new Error("nixamp: no daemon is running. Start one with `nixamp daemon start`, or pass --url.");
+    // Named, with an example. "or pass --url" is only an instruction if you
+    // already know what belongs after it, and the whole point of this message
+    // is that you are looking at a machine you have no handle on.
+    throw new Error(
+      "nixamp: no daemon is running on this machine.\n" +
+        "  Start one:        nixamp daemon start ~/Music\n" +
+        "  Or administer another machine, with its share link:\n" +
+        "                    nixamp admin --url https://server1.you.nixamp.com:4321 --key KEY\n" +
+        "  The URL and key are the two halves of the link that server printed:\n" +
+        "  https://host:4321/s/KEY",
+    );
   }
   const url_ = daemonUrl(state);
   // Talking to our own daemon, whose certificate names somewhere else. Nothing

package/src/audio.ts

@@ -314,6 +314,17 @@ export interface Codecs {
   video: string;
   /** e.g. "aac", "ac3", "dts". Empty when there is no audio stream. */
   audio: string;
+  /**
+   * What is wrapped around them: "mpegts", "matroska,webm", "mov,mp4,...".
+   *
+   * It matters for one reason. A transport stream -- which is what every IPTV
+   * channel is -- frames its AAC as ADTS, and copying that into MP4 needs a
+   * bitstream filter or ffmpeg refuses the whole muxing and writes nothing.
+   * They also tend to carry several audio tracks, so the one ffmpeg picks can
+   * be AC-3 on the same URL that offered AAC a minute earlier, and AC-3 in MP4
+   * is a track no browser will play.
+   */
+  container: string;
 }
 
 /**
@@ -325,7 +336,7 @@ export interface Codecs {
  */
 export async function codecsOf(tools: Tools, path: string): Promise<Codecs> {
   const [cmd, ...rest] = tools.ffprobe;
-  const empty: Codecs = { video: "", audio: "" };
+  const empty: Codecs = { video: "", audio: "", container: "" };
   if (!cmd) return empty;
 
   return new Promise<Codecs>((done) => {
@@ -335,7 +346,7 @@ export async function codecsOf(tools: Tools, path: string): Promise<Codecs> {
         ...rest,
         "-v", "quiet",
         "-print_format", "json",
-        "-show_entries", "stream=codec_type,codec_name",
+        "-show_entries", "format=format_name:stream=codec_type,codec_name",
         path,
       ],
       { stdio: ["ignore", "pipe", "ignore"] },
@@ -347,11 +358,15 @@ export async function codecsOf(tools: Tools, path: string): Promise<Codecs> {
     child.on("error", () => done(empty));
     child.on("close", () => {
       try {
-        const parsed = JSON.parse(out) as { streams?: { codec_type?: string; codec_name?: string }[] };
+        const parsed = JSON.parse(out) as {
+          streams?: { codec_type?: string; codec_name?: string }[];
+          format?: { format_name?: string };
+        };
         const streams = parsed.streams ?? [];
         return done({
           video: streams.find((s) => s.codec_type === "video")?.codec_name ?? "",
           audio: streams.find((s) => s.codec_type === "audio")?.codec_name ?? "",
+          container: parsed.format?.format_name ?? "",
         });
       } catch {
         return done(empty);
@@ -376,7 +391,13 @@ export function videoArgs(codecs: Codecs, capKbps = 0): string[] {
 
   // What a browser can play inside MP4 without help.
   const keepVideo = codecs.video === "h264";
-  const keepAudio = codecs.audio === "aac" || codecs.audio === "mp3";
+  // A transport stream's audio is never copied. Its AAC is ADTS-framed, which
+  // MP4 refuses without a bitstream filter -- ffmpeg writes nothing at all and
+  // says "Malformed AAC bitstream detected" -- and the track ffmpeg picks off
+  // a channel with several of them can be AC-3, which that filter rejects and
+  // no browser plays. Re-encoding audio is cheap; this failing is total.
+  const transportStream = codecs.container.includes("mpegts");
+  const keepAudio = !transportStream && (codecs.audio === "aac" || codecs.audio === "mp3");
   return [
     "-c:v", keepVideo ? "copy" : "libx264",
     ...(keepVideo ? [] : ["-preset", "veryfast", "-crf", "23", "-pix_fmt", "yuv420p"]),

package/src/daemon.ts

@@ -38,6 +38,15 @@ export interface DaemonState {
    * interface, so it names the router and not this port.
    */
   guessedPublic?: boolean;
+  /**
+   * What it was started with, so it can be started that way again.
+   *
+   * A daemon serving TLS on a public name is six flags, and restarting it
+   * meant finding them again -- from shell history, or from `ps`, or not at
+   * all. Absent on a state file written by an older nixamp, which is why
+   * `restart` says so rather than starting something different.
+   */
+  argv?: string[];
 }
 
 /** XDG, with the usual fallback. One daemon per user, which is one too few for nobody. */
@@ -234,11 +243,37 @@ export async function start(argv: string[], entry: string): Promise<DaemonState>
     throw new Error(`nixamp: the daemon did not start. See ${log}`);
   }
 
-  const state: DaemonState = { ...announced, pid: child.pid, startedAt: Date.now(), log };
+  const state: DaemonState = { ...announced, pid: child.pid, startedAt: Date.now(), log, argv };
   writeState(state);
   return state;
 }
 
+/**
+ * Stop it and start it again, the way it was started.
+ *
+ * The flags are replayed from the state file rather than retyped, because the
+ * interesting daemons are the ones with the most flags: a certificate, a key,
+ * a public URL. Given arguments of its own it uses those instead, which is how
+ * you change one thing without stopping and starting by hand.
+ */
+export async function restart(
+  argv: string[],
+  entry: string,
+  /** Injected so a test can see which arguments would be replayed. */
+  starter: typeof start = start,
+): Promise<DaemonState> {
+  const { state } = status();
+  const before = state?.argv;
+  if (argv.length === 0 && before === undefined && state !== null) {
+    throw new Error(
+      "nixamp: this daemon was started by an older nixamp, which did not record its flags. " +
+        "Stop it and start it again with the flags you want.",
+    );
+  }
+  await stop();
+  return starter(argv.length > 0 ? argv : (before ?? []), entry);
+}
+
 /** Poll the log for the announce line. */
 async function waitForAnnounce(
   log: string,

package/src/invite.ts

@@ -2,9 +2,11 @@
  * Asking somebody to watch, when that somebody is not technical.
  *
  * A share link is a URL with a key in it, which is fine for the person who
- * runs the server and useless as a thing to text your mother. An invite is the
- * three ways in, written as a sentence: a link that opens a player, a phone
- * number, and the code to key once it answers.
+ * runs the server and useless as a thing to text your mother. An invite is two
+ * things written as a sentence: a link that opens a player, and a phone number
+ * with a code, which is the line where everyone watching talks to each other.
+ * The phone is not another way to hear the stream -- it is the 800 number
+ * beside a podcast. The show is on the screen; the call is the company.
  *
  * The sender is signed in, because sending is an action with a cost: a text
  * message is money and somebody's phone. The recipient signs in too, but only
@@ -22,7 +24,7 @@ export interface Invite {
   link: string;
   /** The phone number, when this stream is one the line knows about. */
   phone: string;
-  /** The six digits that reach this stream, when it has been published. */
+  /** The six digits that reach this stream's room, once it has been published. */
   code: string;
 }
 
@@ -47,7 +49,10 @@ export function isEmail(value: string): boolean {
 export function inviteText(invite: Invite): string {
   const lines = [`${invite.name} is streaming.`, "", `Watch: ${invite.link}`];
   if (invite.phone && invite.code) {
-    lines.push("", `Or call ${invite.phone} and key ${invite.code} to listen.`);
+    // "to talk about it", not "to listen": the line is a room full of the
+    // other people watching, and telling somebody they will hear the stream
+    // down the phone is telling them something that is not true.
+    lines.push("", `To talk about it: call ${invite.phone} and key ${invite.code}.`);
   }
   return lines.join("\n");
 }

package/src/main.ts

@@ -69,7 +69,7 @@ const HELP = `nixamp — it really whips the terminal's ass.
 
   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 daemon start|restart|stop|status  serve in the background, and let go of it
   nixamp attach                  put the player back in front of the daemon
   nixamp admin [--url U] [--key K] who is connected, and re-stream to them
   nixamp login [--with github]  sign in to nixamp.com, in a browser or here
@@ -188,9 +188,13 @@ Signing out does not touch it: that is what it is for.
   daemon: `nixamp daemon — a nixamp that outlives the terminal that started it.
 
   nixamp daemon start [source] [serve options]   start it, detached
+  nixamp daemon restart [source] [serve options] stop it and start it again
   nixamp daemon status                           where it is, and how long
   nixamp daemon stop                             stop it
 
+Restart with no arguments replays the ones it was started with, certificate
+and public URL included, so picking up a new version costs one command.
+
 It is \`nixamp serve\` with nobody holding its terminal, so it keeps playing and
 keeps serving its browser remote. One per user.
 
@@ -257,6 +261,17 @@ async function runDaemon(argv: string[]): Promise<number> {
     return 0;
   }
 
+  if (action === "restart") {
+    try {
+      const state = await d.restart(rest, entry);
+      for (const line of d.daemonLines(state)) console.log(line);
+      return 0;
+    } catch (error) {
+      console.error((error as Error).message);
+      return 1;
+    }
+  }
+
   if (action === "status") {
     const { running, state } = d.status();
     if (!state) {
@@ -283,7 +298,7 @@ async function runDaemon(argv: string[]): Promise<number> {
     return attach(rest);
   }
 
-  console.error(`nixamp daemon: unknown action ${action}. Try start, stop, status or attach.`);
+  console.error(`nixamp daemon: unknown action ${action}. Try start, restart, stop, status or attach.`);
   return 64;
 }
 
@@ -619,7 +634,11 @@ export function view(
 
 if (import.meta.main) {
   main().catch((error) => {
-    console.error(error);
+    // The same rule the installed launcher uses: a message we wrote is one the
+    // reader can act on, and printing a stack over it buries the sentence that
+    // says what to do.
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(message.startsWith("nixamp:") ? message : error);
     process.exit(1);
   });
 }