nixamp 0.7.4 → 0.7.6

package/dist/server.js

@@ -39,7 +39,7 @@ import { Durable } from "./durable.js";
 import { notifyAll, resendEmail, webPush } from "./notify.js";
 import { confirm, DEFAULT_DIRECTORY, Publisher } from "./publish.js";
 import { applyRemoteConfig, createPaywall, FREE_LISTENERS, paywallFromEnv, } from "./paywall.js";
-import { isRemote, playsInBrowser } from "./sources.js";
+import { isRemote, playsInBrowser, sourceLabel } from "./sources.js";
 import { codecsOf, videoArgs } from "./audio.js";
 import { allowedForListening, elevate, firewallInUse, keyCookie, keyFrom, lookupPublicIp, newKey, portCommands, reachableAddresses, scopeOf, shareLink, audioLink, } from "./share.js";
 import { extname, join, normalize, resolve, sep } from "node:path";
@@ -292,7 +292,11 @@ 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 } : {}),
     }));
 }
 /** Video containers, as opposed to the songs that are most of a library. */
@@ -301,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
@@ -501,15 +523,89 @@ export class PlayerEngine {
         this.state.note = "";
         this.push(true);
     }
+    /**
+     * Load something as well as what is already here.
+     *
+     * Adding a folder used to be `replace`, so pointing a server at an album on
+     * the web threw away the music on its disk: the playlist you were looking at
+     * turned into somebody else's twenty-eight tracks, and clicking your own
+     * files played theirs. Nothing about playback changes here -- whatever was
+     * playing keeps playing, at the same index, because the new tracks go on the
+     * end.
+     *
+     * Paths already loaded are skipped, so adding the same album twice is not
+     * two copies of it.
+     */
+    add(tracks, from) {
+        const group = sourceLabel(from);
+        const known = new Set(this.tracks.map((track) => track.path));
+        const fresh = tracks.filter((track) => !known.has(track.path)).map((track) => ({ ...track, group }));
+        if (fresh.length === 0)
+            return 0;
+        this.tracks = [...this.tracks, ...fresh];
+        // The list itself changed, so it has to ride this frame; a count nobody
+        // can index into is worse than no news at all.
+        this.push(true);
+        return fresh.length;
+    }
+    /**
+     * Take an added source back out.
+     *
+     * The track that is playing is followed rather than an index: removing an
+     * album from above the current track would otherwise slide the playlist out
+     * from under a listener mid-song. If the playing track is itself in what is
+     * being removed, playback stops -- there is nothing to keep playing.
+     */
+    drop(group) {
+        if (group === "")
+            return 0;
+        const playingPath = this.tracks[this.state.index]?.path;
+        const kept = this.tracks.filter((track) => track.group !== group);
+        const removed = this.tracks.length - kept.length;
+        if (removed === 0)
+            return 0;
+        this.tracks = kept;
+        const stillThere = kept.findIndex((track) => track.path === playingPath);
+        if (stillThere === -1) {
+            this.halt();
+            this.state.index = this.clamp(this.state.index);
+        }
+        else {
+            this.state.index = stillThere;
+        }
+        this.push(true);
+        return removed;
+    }
+    groups() {
+        const seen = [];
+        for (const track of this.tracks) {
+            if (track.group && !seen.includes(track.group))
+                seen.push(track.group);
+        }
+        return seen;
+    }
     retag(tracks, root) {
-        // Dropped rather than applied if the library moved underneath: somebody
-        // re-streamed while the tagging was still running, and these tags describe
-        // something nobody is playing any more.
-        if (root !== this.root || tracks.length !== this.tracks.length)
-            return;
-        if (tracks.some((track, at) => track.path !== this.tracks[at]?.path))
+        // 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
+        // album while a library's tags are still being read, and an exact-shape
+        // check would throw away every tag for it. Tags that describe tracks which
+        // are no longer here simply match nothing, which is the same protection
+        // the shape check was giving.
+        void root;
+        const byPath = new Map(tracks.map((track) => [track.path, track]));
+        let changed = false;
+        const merged = this.tracks.map((track) => {
+            const tagged = byPath.get(track.path);
+            if (!tagged || tagged === track)
+                return track;
+            changed = true;
+            // The group is ours, not the tagger's: it knows what a track is called,
+            // not which pile it is in.
+            return { ...tagged, ...(track.group ? { group: track.group } : {}) };
+        });
+        if (!changed)
             return;
-        this.tracks = tracks;
+        this.tracks = merged;
         // No stop, no index reset: the only thing that changes is what the titles
         // say, and every remote finds out because a snapshot goes out -- carrying
         // the list, since the titles are the whole point of this one.
@@ -534,6 +630,15 @@ export class EmptyEngine {
         return undefined;
     }
     replace() { }
+    add() {
+        return 0;
+    }
+    drop() {
+        return 0;
+    }
+    groups() {
+        return [];
+    }
     retag() { }
     stop() { }
 }
@@ -546,6 +651,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)$/;
 /**
@@ -845,7 +958,18 @@ export function createHandler(engine, options) {
             path !== "/api/health" &&
             path !== "/api/directory" &&
             !isSignInPath(path)) {
-            const scope = scopeOf(keyFrom(request, url), key, listenKey);
+            let scope = scopeOf(keyFrom(request, url), key, listenKey);
+            // A key is how somebody who was invited proves it. It is not the only way
+            // to be allowed in: the person who owns this server is allowed in whether
+            // or not they still have the link, and their nixamp.com session says who
+            // they are. Without this, signing in as yourself and opening your own
+            // server was refused, and the address of a machine you administer was
+            // useless without a link you had to go and find.
+            if (scope === null && options.owner) {
+                const check = await options.owner.check(false, tokenFrom(request.headers));
+                if (check.allowed)
+                    scope = "control";
+            }
             if (scope === null) {
                 // Counted, not because a 128-bit key falls to guessing, but because
                 // somebody hammering one should stop costing this server anything.
@@ -856,7 +980,9 @@ export function createHandler(engine, options) {
                     response.end(JSON.stringify({ error: "too many attempts; wait a moment" }));
                     return;
                 }
-                json(response, 401, { error: "this nixamp needs the key from its share link" });
+                json(response, 401, {
+                    error: "this nixamp needs the key from its share link, or sign in as its owner",
+                });
                 return;
             }
             if (scope === "listen" && !allowedForListening(path)) {
@@ -1719,16 +1845,50 @@ export function createHandler(engine, options) {
             json(response, 200, engine.snapshot());
             return;
         }
-        // Re-stream: hand the running server a different source. The listeners
-        // stay connected; what they are listening to changes under them.
+        // Take an added source back out of the playlist. The library it was added
+        // to is untouched -- there is no group name that names it.
+        if (path === "/api/source/remove") {
+            if (request.method !== "POST") {
+                json(response, 405, { error: "POST only" });
+                return;
+            }
+            let group = "";
+            try {
+                group = String(JSON.parse(await readBody(request)).group ?? "");
+            }
+            catch {
+                json(response, 400, { error: "bad JSON" });
+                return;
+            }
+            if (!group) {
+                json(response, 400, { error: "no group given" });
+                return;
+            }
+            const removed = engine.drop(group);
+            if (removed === 0) {
+                json(response, 404, { error: `nothing here came from ${group}` });
+                return;
+            }
+            json(response, 200, { ...engine.snapshot(), removed, groups: engine.groups() });
+            return;
+        }
+        // Hand the running server another source. The listeners stay connected;
+        // by default they get more to listen to, and only an explicit `replace`
+        // swaps what this server is for something else.
         if (path === "/api/source") {
             if (request.method !== "POST") {
                 json(response, 405, { error: "POST only" });
                 return;
             }
             let source = "";
+            let replacing = false;
             try {
-                source = String(JSON.parse(await readBody(request)).source ?? "");
+                const body = JSON.parse(await readBody(request));
+                source = String(body.source ?? "");
+                // Adding is what somebody means by putting a folder in a box, so it is
+                // the default. Replacing is the much larger claim that this server now
+                // serves that instead, so it is the one you have to ask for.
+                replacing = body.replace === true;
             }
             catch {
                 json(response, 400, { error: "bad JSON" });
@@ -1739,13 +1899,38 @@ 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;
                 }
-                engine.replace(tracks, source);
-                // Names now, tags later, here as much as at startup: re-streaming a
+                // 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);
+                }
+                else {
+                    added = engine.add(tracks, source);
+                    if (added === 0) {
+                        // Everything there was already here. Not an error -- the playlist
+                        // is exactly what the caller asked for -- but worth saying, so a
+                        // client can tell that apart from having added an album.
+                        json(response, 200, { ...engine.snapshot(), added: 0, groups: engine.groups() });
+                        return;
+                    }
+                }
+                // Names now, tags later, here as much as at startup: loading a
                 // directory of five thousand files used to read every tag before it
                 // answered, with the event loop held the whole time.
                 if (options.tag) {
@@ -1754,7 +1939,7 @@ export function createHandler(engine, options) {
                         .then((tagged) => engine.retag(tagged, source))
                         .catch(() => { });
                 }
-                json(response, 200, engine.snapshot());
+                json(response, 200, { ...engine.snapshot(), added, replaced: replacing, groups: engine.groups() });
             }
             catch (error) {
                 json(response, 422, { error: error.message.replace(/^nixamp: /, "") });
@@ -1784,17 +1969,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:

package/dist/share.js

@@ -180,7 +180,12 @@ export function scopeOf(offered, control, listen) {
 }
 /** Paths a listen key may have. Everything else needs the control key. */
 export function allowedForListening(path) {
-    if (path === "/api/command" || path === "/api/source")
+    if (path === "/api/command")
+        return false;
+    // Prefix, not equality: everything under this changes what the server plays,
+    // and an exact check let a listen key reach /api/source/remove and delete an
+    // album out of somebody else's playlist.
+    if (path === "/api/source" || path.startsWith("/api/source/"))
         return false;
     return true;
 }

package/dist/sources.d.ts

@@ -33,5 +33,14 @@ export declare function parseM3u(text: string, base: string): Entry[];
 /** A .pls, which Shoutcast and Icecast hand out as often as an .m3u. */
 export declare function parsePls(text: string, base: string): Entry[];
 /** The last useful part of a path or URL, for when nothing named the track. */
+/**
+ * What to call a whole source, as a heading over the tracks it brought.
+ *
+ * `nameOf` answers for a file; this answers for the thing a person added --
+ * usually the last segment either way, but a URL that is only a host has no
+ * segment to take, and "the album at that address" reads better as the host
+ * than as the whole URL repeated over every row.
+ */
+export declare function sourceLabel(source: string): string;
 export declare function nameOf(source: string): string;
 export declare function playsInBrowser(source: string): boolean;

package/dist/sources.js

@@ -94,6 +94,30 @@ export function parsePls(text, base) {
     });
 }
 /** The last useful part of a path or URL, for when nothing named the track. */
+/**
+ * What to call a whole source, as a heading over the tracks it brought.
+ *
+ * `nameOf` answers for a file; this answers for the thing a person added --
+ * usually the last segment either way, but a URL that is only a host has no
+ * segment to take, and "the album at that address" reads better as the host
+ * than as the whole URL repeated over every row.
+ */
+export function sourceLabel(source) {
+    const trimmed = source.replace(/\/+$/, "");
+    if (trimmed === "")
+        return source;
+    const named = nameOf(trimmed);
+    if (named !== trimmed && named !== "")
+        return named;
+    if (!isRemote(trimmed))
+        return trimmed;
+    try {
+        return new URL(trimmed).host;
+    }
+    catch {
+        return trimmed;
+    }
+}
 export function nameOf(source) {
     const remote = isRemote(source);
     const path = remote ? new URL(source).pathname : source;

package/package.json

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

package/src/admin.ts

@@ -146,6 +146,9 @@ export async function admin(argv: string[]): Promise<void> {
   let snapshot: Snapshot | null = null;
   let error = "";
   let restreaming = "";
+  // Which of the two things typing a source means. Adding is the ordinary one
+  // and has its own key; replacing throws the library away, so it has another.
+  let replacing = false;
   let typing = false;
 
   const app = await createApp({ theme: themes.matrix, title: "nixamp admin", quitKeys: ["ctrl+c"] });
@@ -164,24 +167,27 @@ export async function admin(argv: string[]): Promise<void> {
   app.on("key", (event: KeyEvent) => {
     const key = event.key;
     if (typing) {
-      if (key === "escape") { typing = false; restreaming = ""; }
+      if (key === "escape") { typing = false; restreaming = ""; replacing = false; }
       else if (key === "enter") {
         const url = restreaming.trim();
+        const asReplacement = replacing;
         typing = false;
         restreaming = "";
-        if (url) void restream(target, headers, url).then(() => refresh());
+        replacing = false;
+        if (url) void restream(target, headers, url, asReplacement).then(() => refresh());
       } else if (key === "backspace") restreaming = restreaming.slice(0, -1);
       else restreaming += typed(key);
       app.invalidate();
       return;
     }
     if (key === "q") { app.quit(); return; }
-    if (key === "r") { typing = true; app.invalidate(); }
+    if (key === "a") { typing = true; replacing = false; app.invalidate(); }
+    if (key === "r") { typing = true; replacing = true; app.invalidate(); }
   });
 
   app.on("exit", () => clearInterval(timer));
   app.render(({ ui, theme }) => draw(ui, theme, {
-    url: target.url, report, snapshot, error, typing, restreaming,
+    url: target.url, report, snapshot, error, typing, restreaming, replacing,
     links: target.links, key: target.key, source: target.source,
   }));
 
@@ -189,13 +195,24 @@ export async function admin(argv: string[]): Promise<void> {
   clearInterval(timer);
 }
 
-/** Ask the server to play something else, which is what re-streaming is. */
-async function restream(target: AdminOptions, headers: Record<string, string>, url: string): Promise<void> {
+/**
+ * Hand the server something else to play.
+ *
+ * Two different asks down one route: adding puts an album on the end of the
+ * playlist, replacing points the server somewhere else entirely. The server
+ * adds unless told otherwise, so only the second one says anything.
+ */
+async function restream(
+  target: AdminOptions,
+  headers: Record<string, string>,
+  url: string,
+  replacing = false,
+): Promise<void> {
   try {
     await fetch(`${target.url}/api/source`, {
       method: "POST",
       headers: { ...headers, "content-type": "application/json" },
-      body: JSON.stringify({ source: url }),
+      body: JSON.stringify({ source: url, ...(replacing ? { replace: true } : {}) }),
     });
   } catch {
     // The next refresh reports the server being unreachable; this is not the
@@ -210,6 +227,8 @@ export interface View {
   error: string;
   typing: boolean;
   restreaming: string;
+  /** Whether what is being typed replaces the playlist rather than joining it. */
+  replacing?: boolean;
   /** Labelled addresses, and the key that makes them work. */
   links: { label: string; url: string }[];
   key: string | null;
@@ -296,15 +315,21 @@ export function draw(ui: Container, theme: Theme, view: View): void {
   });
 
   if (view.typing) {
-    ui.panel({ title: "Re-stream a URL or a path", size: 4 }, (p) => {
+    ui.panel({
+      title: view.replacing ? "Replace the playlist with a URL or a path" : "Add a URL or a path",
+      size: 4,
+    }, (p) => {
       p.text(`${view.restreaming}_`, { fg: theme.accent });
-      p.label("Enter plays it here. Escape forgets it.");
+      p.label(view.replacing
+        ? "Enter drops this library and serves that instead. Escape forgets it."
+        : "Enter adds it to the playlist. Escape forgets it.");
     });
   }
 
   ui.statusBar({
     items: [
-      { key: "r", label: "Re-stream" },
+      { key: "a", label: "Add" },
+      { key: "r", label: "Replace" },
       { key: "q", label: "Quit" },
     ],
     right: [{ key: "", label: report ? `${report.connections.length} seen` : "connecting" }],

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,