nixamp 0.10.1 → 0.10.3

package/src/directory.ts

@@ -105,6 +105,12 @@ export interface Ended {
   startedAt: number;
   /** The last heartbeat we saw, which is as close to "ended" as we can know. */
   endedAt: number;
+  /**
+   * The codes its channels had, so a server that stops and comes back -- an
+   * update restarts the daemon, and the daemon withdraws its listing on the
+   * way down -- puts each channel back under the code people were given.
+   */
+  channelCodes?: Record<string, string>;
 }
 
 /** How long an ended stream is still worth telling a caller about. */
@@ -237,7 +243,14 @@ export class Directory {
    */
   seedEnded(items: readonly Ended[]): void {
     for (const item of items) {
-      if (!this.ended.has(item.id) && !this.items.has(item.id)) this.ended.set(item.id, item);
+      if (!this.ended.has(item.id) && !this.items.has(item.id)) {
+        this.ended.set(item.id, item);
+        // Its channels' codes are reserved too, so a server coming back after
+        // the directory restarted still finds them its own.
+        if (item.channelCodes && Object.keys(item.channelCodes).length > 0) {
+          this.channelHistory.set(item.id, { ...(this.channelHistory.get(item.id) ?? {}), ...item.channelCodes });
+        }
+      }
     }
   }
 
@@ -297,7 +310,11 @@ export class Directory {
         // channel that was gone for a heartbeat -- a server restarting puts
         // its channels back a moment after it announces -- comes back to the
         // code people were given, not a new one.
-        { ...(this.channelHistory.get(id) ?? {}), ...(existing?.channelCodes ?? {}) },
+        {
+          ...(previously && "channelCodes" in previously ? previously.channelCodes ?? {} : {}),
+          ...(this.channelHistory.get(id) ?? {}),
+          ...(existing?.channelCodes ?? {}),
+        },
         id,
       ),
       updatedAt: this.now(),
@@ -316,7 +333,7 @@ export class Directory {
     const item = this.items.get(id);
     if (item !== undefined) this.remember(item);
     this.items.delete(id);
-    this.channelHistory.delete(id);
+    // The channel history stays with the ended record, and goes when it goes.
   }
 
   list(): Listing[] {
@@ -435,6 +452,9 @@ export class Directory {
       nowPlaying: item.nowPlaying,
       startedAt: item.startedAt,
       endedAt: item.updatedAt,
+      // Every code its channels have had, not only the ones on at the end:
+      // a restart announces before its channels are back.
+      channelCodes: { ...(this.channelHistory.get(item.id) ?? {}), ...item.channelCodes },
     };
     this.ended.set(item.id, record);
     this.mirror?.save(record);
@@ -457,13 +477,13 @@ export class Directory {
       if (item.updatedAt < cutoff) {
         this.remember(item);
         this.items.delete(id);
-        this.channelHistory.delete(id);
       }
     }
     const forget = this.now() - ENDED_TTL_MS;
     for (const [id, item] of this.ended) {
       if (item.endedAt < forget) {
         this.ended.delete(id);
+        this.channelHistory.delete(id);
         this.mirror?.drop(id);
       }
     }

package/src/durable.ts

@@ -35,6 +35,8 @@ export interface StoredEnded {
   nowPlaying: string;
   startedAt: number;
   endedAt: number;
+  /** Each channel's phone code, by name, so a server coming back keeps them. */
+  channelCodes?: Record<string, string>;
 }
 
 const SCHEMA = `
@@ -48,6 +50,7 @@ const SCHEMA = `
     started_at   BIGINT NOT NULL,
     ended_at     BIGINT NOT NULL
   );
+  ALTER TABLE ended_streams ADD COLUMN IF NOT EXISTS channel_codes JSONB NOT NULL DEFAULT '{}'::jsonb;
   CREATE INDEX IF NOT EXISTS ended_streams_code ON ended_streams (code);
 
   CREATE TABLE IF NOT EXISTS stream_reminders (
@@ -58,6 +61,24 @@ const SCHEMA = `
   );
 `;
 
+/** A JSONB column, as pg hands it back: an object already, or a string on an odd driver. */
+function codesFrom(value: unknown): Record<string, string> {
+  let parsed: unknown = value;
+  if (typeof value === "string") {
+    try {
+      parsed = JSON.parse(value);
+    } catch {
+      return {};
+    }
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+  const codes: Record<string, string> = {};
+  for (const [name, code] of Object.entries(parsed as Record<string, unknown>)) {
+    if (typeof code === "string" && /^\d{6}$/.test(code)) codes[name] = code;
+  }
+  return codes;
+}
+
 export class Durable {
   private ready: Promise<void> | null = null;
 
@@ -91,8 +112,8 @@ export class Durable {
     await this.quietly("an ended stream", () =>
       this.db.query(
         `INSERT INTO ended_streams
-           (id, code, name, owner_id, url, now_playing, started_at, ended_at)
-         VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
+           (id, code, name, owner_id, url, now_playing, started_at, ended_at, channel_codes)
+         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9::jsonb)
          ON CONFLICT (id) DO UPDATE
            SET code = EXCLUDED.code,
                name = EXCLUDED.name,
@@ -100,7 +121,8 @@ export class Durable {
                url = EXCLUDED.url,
                now_playing = EXCLUDED.now_playing,
                started_at = EXCLUDED.started_at,
-               ended_at = EXCLUDED.ended_at`,
+               ended_at = EXCLUDED.ended_at,
+               channel_codes = EXCLUDED.channel_codes`,
         [
           stream.id,
           stream.code,
@@ -110,6 +132,7 @@ export class Durable {
           stream.nowPlaying,
           stream.startedAt,
           stream.endedAt,
+          JSON.stringify(stream.channelCodes ?? {}),
         ],
       ),
     );
@@ -141,6 +164,7 @@ export class Durable {
         // nothing like a number.
         startedAt: Number(r["started_at"] ?? 0),
         endedAt: Number(r["ended_at"] ?? 0),
+        channelCodes: codesFrom(r["channel_codes"]),
       }));
     } catch (error) {
       this.onEvent(`  could not read ended streams: ${(error as Error).message}`);

package/src/hls.ts

@@ -0,0 +1,265 @@
+/**
+ * A channel as HLS, for the browsers that will not take it any other way.
+ *
+ * A channel is sent as one endless fragmented MP4 down a chunked response,
+ * which Chrome and Firefox play as they would a file. Safari on an iPhone
+ * will not: it asks for a byte range, gets a stream with no length, and gives
+ * up before the first picture -- a spinner that flashes and a player that
+ * never starts. What Safari plays live is HLS, a playlist of short files.
+ *
+ * So this packages the same bytes into HLS on demand: one ffmpeg per channel,
+ * copying (never re-encoding) the fragments it is fed into two-second
+ * MPEG-TS segments in a temporary directory, started when the first playlist
+ * is asked for and stopped a minute after the last. The channel itself is
+ * untouched; this is one more listener on it.
+ */
+import { spawn, type ChildProcess } from "node:child_process";
+import { mkdtempSync, readFileSync, rmSync, statSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+/** Seconds of video per segment. Short, so joining is quick; long enough that a playlist is not churn. */
+export const SEGMENT_SECONDS = 2;
+/** How many segments the playlist offers. About twelve seconds of catch-up. */
+export const PLAYLIST_SEGMENTS = 6;
+/** How long a packager runs with nobody asking for its playlist. */
+export const IDLE_MS = 60_000;
+/** How long the first playlist may take to appear before it is a failure. */
+export const FIRST_PLAYLIST_MS = 20_000;
+
+const SEGMENT = /^seg\d{5}\.ts$/;
+
+/** A segment file name, or "" for anything that is not one. Never a path. */
+export function segmentName(requested: string): string {
+  return SEGMENT.test(requested) ? requested : "";
+}
+
+/**
+ * The playlist with the key on every segment.
+ *
+ * A browser resolves segment names against the playlist's URL and drops its
+ * query, so the key that opened the playlist never reaches the segments and
+ * each one answers 401. The key travels on every line instead.
+ */
+export function withKey(playlist: string, key: string): string {
+  if (key === "") return playlist;
+  return playlist
+    .split("\n")
+    .map((line) => (line !== "" && !line.startsWith("#") ? `${line}?k=${encodeURIComponent(key)}` : line))
+    .join("\n");
+}
+
+/** The ffmpeg arguments: copy what arrives on stdin into a rolling playlist. */
+export function packagerArgs(dir: string): string[] {
+  return [
+    "-hide_banner",
+    "-loglevel", "error",
+    "-i", "pipe:0",
+    "-c", "copy",
+    "-f", "hls",
+    "-hls_time", String(SEGMENT_SECONDS),
+    "-hls_list_size", String(PLAYLIST_SEGMENTS),
+    // Old segments go; the playlist never ends; each segment starts on a
+    // keyframe so a joiner can begin anywhere; written whole then renamed so
+    // a request never reads half a file.
+    "-hls_flags", "delete_segments+omit_endlist+independent_segments+temp_file",
+    "-hls_segment_type", "mpegts",
+    "-hls_segment_filename", join(dir, "seg%05d.ts"),
+    join(dir, "index.m3u8"),
+  ];
+}
+
+export interface Packaged {
+  /** Feed it the channel's bytes: the header first, then every fragment. */
+  write(chunk: Buffer): boolean;
+  /** The channel ended; finish and stop. */
+  end(): void;
+}
+
+/** One channel's packager. */
+class Packager implements Packaged {
+  readonly dir: string;
+  private child: ChildProcess | null = null;
+  private idle: ReturnType<typeof setTimeout> | null = null;
+  private stopped = false;
+  private detach: (() => void) | null = null;
+
+  constructor(
+    private readonly id: string,
+    private readonly ffmpeg: string[],
+    private readonly onStop: (id: string) => void,
+    private readonly onEvent: (message: string) => void,
+  ) {
+    this.dir = mkdtempSync(join(tmpdir(), `nixamp-hls-${id}-`));
+  }
+
+  start(listen: (listener: Packaged) => (() => void) | null): boolean {
+    const [command, ...prefix] = this.ffmpeg as [string, ...string[]];
+    try {
+      this.child = spawn(command, [...prefix, ...packagerArgs(this.dir)], { stdio: ["pipe", "ignore", "pipe"] });
+    } catch (error) {
+      this.onEvent(`  HLS for "${this.id}" could not start: ${(error as Error).message}`);
+      this.stop();
+      return false;
+    }
+    let complaint = "";
+    this.child.stderr?.on("data", (chunk: Buffer) => {
+      if (complaint.length < 4000) complaint += chunk.toString("utf8");
+    });
+    this.child.stdin?.on("error", () => undefined);
+    this.child.on("error", (error) => {
+      this.onEvent(`  HLS for "${this.id}" failed: ${error.message}`);
+      this.stop();
+    });
+    this.child.on("close", (code) => {
+      if (!this.stopped && code !== 0) {
+        this.onEvent(`  HLS for "${this.id}" stopped: ${complaint.trim().split("\n").pop() ?? code}`);
+      }
+      this.stop();
+    });
+    this.detach = listen(this);
+    if (this.detach === null) {
+      this.stop();
+      return false;
+    }
+    this.touch();
+    return true;
+  }
+
+  write(chunk: Buffer): boolean {
+    const stdin = this.child?.stdin;
+    if (!stdin || stdin.destroyed) return false;
+    try {
+      stdin.write(chunk);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  end(): void {
+    try {
+      this.child?.stdin?.end();
+    } catch {
+      // Already gone.
+    }
+    this.stop();
+  }
+
+  /** Somebody asked for the playlist: it is wanted for another minute. */
+  touch(): void {
+    if (this.idle) clearTimeout(this.idle);
+    this.idle = setTimeout(() => this.stop(), IDLE_MS);
+    this.idle.unref?.();
+  }
+
+  /** The playlist as it stands, or "" before the first segment is written. */
+  playlist(): string {
+    try {
+      const text = readFileSync(join(this.dir, "index.m3u8"), "utf8");
+      return text.includes("#EXTINF") ? text : "";
+    } catch {
+      return "";
+    }
+  }
+
+  /** A segment's path, or "" when it is not there (any more). */
+  segment(name: string): string {
+    const safe = segmentName(name);
+    if (safe === "") return "";
+    const path = join(this.dir, safe);
+    try {
+      return statSync(path).isFile() ? path : "";
+    } catch {
+      return "";
+    }
+  }
+
+  stop(): void {
+    if (this.stopped) return;
+    this.stopped = true;
+    if (this.idle) clearTimeout(this.idle);
+    this.idle = null;
+    this.detach?.();
+    this.detach = null;
+    const child = this.child;
+    this.child = null;
+    if (child && child.exitCode === null) {
+      try {
+        child.stdin?.end();
+        child.kill("SIGKILL");
+      } catch {
+        // Already gone.
+      }
+    }
+    try {
+      rmSync(this.dir, { recursive: true, force: true });
+    } catch {
+      // A directory that is already gone is fine.
+    }
+    this.onStop(this.id);
+  }
+}
+
+/**
+ * The packagers, one per channel that somebody is watching this way.
+ *
+ * `listen` is how a packager becomes a listener on its channel: it is handed
+ * the header and then every fragment, exactly as a browser would be.
+ */
+export class HlsPackagers {
+  private readonly running = new Map<string, Packager>();
+
+  constructor(
+    private readonly options: {
+      ffmpeg: string[];
+      listen: (id: string, listener: Packaged) => (() => void) | null;
+      onEvent?: (message: string) => void;
+      /** Injected for tests: how long to wait for the first playlist. */
+      firstPlaylistMs?: number;
+    },
+  ) {}
+
+  /**
+   * The playlist for a channel, starting the packager if it is not running,
+   * and waiting for the first segments to exist. Null when the channel is not
+   * there or nothing could be packaged.
+   */
+  async playlist(id: string): Promise<string | null> {
+    let packager = this.running.get(id);
+    if (!packager) {
+      packager = new Packager(id, this.options.ffmpeg, (gone) => this.running.delete(gone), this.options.onEvent ?? (() => undefined));
+      this.running.set(id, packager);
+      if (!packager.start((listener) => this.options.listen(id, listener))) return null;
+    }
+    packager.touch();
+    const deadline = Date.now() + (this.options.firstPlaylistMs ?? FIRST_PLAYLIST_MS);
+    for (;;) {
+      const text = packager.playlist();
+      if (text !== "") return text;
+      if (Date.now() > deadline || !this.running.has(id)) return null;
+      await new Promise((done) => setTimeout(done, 250));
+    }
+  }
+
+  /** A segment's path, or "" when there is no such segment. */
+  segment(id: string, name: string): string {
+    const packager = this.running.get(id);
+    if (!packager) return "";
+    packager.touch();
+    return packager.segment(name);
+  }
+
+  /** The channel went: stop packaging it. */
+  stop(id: string): void {
+    this.running.get(id)?.stop();
+  }
+
+  stopAll(): void {
+    for (const packager of [...this.running.values()]) packager.stop();
+  }
+
+  get count(): number {
+    return this.running.size;
+  }
+}

package/src/server.ts

@@ -51,6 +51,7 @@ import { stateDir } from "./daemon.ts";
 import { readSession } from "./session.ts";
 import { Directory, ENDED_TTL_MS, parseAnnouncement, type Listing } from "./directory.ts";
 import { PartyLine, telnyxSms } from "./partyline.ts";
+import { HlsPackagers, withKey } from "./hls.ts";
 import {
   contentTypeFor, downloadArgs, fileNameFor, inputArgsFor, linkChannelId, playableLink, resolveLink, saveFormat,
   type ResolvedLink,
@@ -1163,6 +1164,8 @@ export interface HandlerOptions {
   ffprobe?: string[];
   /** yt-dlp, which turns a pasted page into a media address. Null when there is none. */
   ytdlp?: string[] | null;
+  /** Channels as HLS, for Safari on a phone, which plays a live stream no other way. */
+  hls?: HlsPackagers;
   /** A Netscape cookies file for sites that want a signed-in browser, when there is one. */
   cookies?: string;
   /** Who is listening, for the admin view. */
@@ -2913,9 +2916,54 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
     if (path.startsWith("/api/channels/") && options.channels) {
       const channels = options.channels;
       const rest = path.slice("/api/channels/".length);
-      const [rawId, action] = rest.split("/");
+      const [rawId, action, file] = rest.split("/");
       const id = cleanId(rawId);
 
+      // The same channel as HLS: a playlist of short files, which is what
+      // Safari on an iPhone plays live -- it will not take the endless MP4
+      // below, and spun on it a few times before giving up. Packaged on
+      // demand, copying the fragments the browser would have got.
+      if (action === "hls" && request.method === "GET") {
+        if (!options.hls) {
+          json(response, 503, { error: "this server cannot package HLS" });
+          return;
+        }
+        if (!channels.has(id)) {
+          json(response, 404, { error: "nothing is playing on that channel" });
+          return;
+        }
+        if (file === "index.m3u8") {
+          const playlist = await options.hls.playlist(id);
+          if (playlist === null) {
+            json(response, 503, { error: "that channel could not be packaged as HLS yet; try again in a moment" });
+            return;
+          }
+          response.writeHead(200, {
+            ...CORS,
+            "content-type": "application/vnd.apple.mpegurl",
+            "cache-control": "no-store",
+          });
+          // The key rides on every segment line: a browser drops the query
+          // when it resolves a segment against the playlist.
+          response.end(withKey(playlist, url.searchParams.get("k") ?? ""));
+          return;
+        }
+        const segment = options.hls.segment(id, file ?? "");
+        if (segment === "") {
+          json(response, 404, { error: "no such segment" });
+          return;
+        }
+        watch(request, response, "stream", id);
+        response.writeHead(200, {
+          ...CORS,
+          "content-type": "video/mp2t",
+          "cache-control": "no-store",
+          "content-length": statSync(segment).size,
+        });
+        createReadStream(segment).pipe(response);
+        return;
+      }
+
       if (action === undefined && request.method === "GET") {
         // Listening. The response is the fan-out target: whatever ffmpeg
         // produces for this channel is written to it until one end goes away.
@@ -4019,6 +4067,13 @@ export async function serve(argv: string[], version = "0.1.0"): Promise<void> {
       console.log(`  ${info.name} is publishing to "${info.id}" (${info.format} over ${info.via}).`),
     onEnd: (info) => console.log(`  "${info.id}" stopped.`),
   });
+  // Channels as HLS, on demand, for Safari on a phone: one ffmpeg copying a
+  // channel's fragments into short files while somebody is asking for them.
+  const hls = new HlsPackagers({
+    ffmpeg: tools.ffmpeg,
+    listen: (id, listener) => channels.listen(id, listener),
+    onEvent: (message) => console.log(message),
+  });
 
   // The channels this server was carrying when it was last stopped, put back
   // on. A server is restarted to pick up a new version, which is often, and
@@ -4389,6 +4444,7 @@ export async function serve(argv: string[], version = "0.1.0"): Promise<void> {
     // for the sites that will not talk to a datacenter without one.
     ytdlp: tools.ytdlp ?? null,
     cookies: cookiesFile(),
+    hls,
     ...(tls ? { tls } : {}),
     // Untagged, so a directory of five thousand files answers at once; the
     // tags follow through `tag` below.
@@ -4833,6 +4889,7 @@ export async function serve(argv: string[], version = "0.1.0"): Promise<void> {
 
   const shutdown = (): void => {
     rtmp?.stop();
+    hls.stopAll();
     channels.stopAll();
     ingest?.stopRtmp();
     ingest?.close();

package/web/dist/assets/{hls-3VKVEQE3-5T3M0hCY.js → hls-3VKVEQE3-DR8q_kGX.js}

@@ -1 +1 @@
-import{t as e}from"./index-Bqujphpd.js";var t=3;async function n(n){let{media:r,src:i,isTv:a}=n,{default:o}=await e(async()=>{let{default:e}=await import(`./hls-n74Cnh8A.js`);return{default:e}},[]);if(!o.isSupported())return n.onError(`This browser cannot play HLS streams.`),{destroy:()=>void 0,levels:()=>[]};let s=new o({...a?{maxBufferLength:60,maxMaxBufferLength:120,backBufferLength:30,liveSyncDurationCount:4}:{backBufferLength:90},enableWorker:!0}),c=0,l=!1;s.on(o.Events.ERROR,(e,r)=>{if(!l&&r.fatal){if(c>=t){n.onError(`This stream kept failing and has been stopped.`),s.destroy();return}switch(c+=1,r.type){case o.ErrorTypes.NETWORK_ERROR:n.onNotice(`Reconnecting…`),s.startLoad();break;case o.ErrorTypes.MEDIA_ERROR:n.onNotice(`Recovering…`),s.recoverMediaError();break;default:n.onError(`This stream could not be played.`),s.destroy()}}}),s.on(o.Events.MANIFEST_PARSED,()=>{l||(n.onNotice(null),n.onReady?.({live:s.levels.length>0&&!Number.isFinite(r.duration),levels:u()}))}),s.on(o.Events.LEVEL_LOADED,(e,t)=>{l||n.onReady?.({live:t.details.live,levels:u()})}),s.on(o.Events.FRAG_BUFFERED,()=>{l||n.onNotice(null)});function u(){return s.levels.map((e,t)=>({index:t,height:e.height||null,bitrate:e.bitrate||null,label:e.height?`${String(e.height)}p`:`${String(Math.round((e.bitrate||0)/1e3))}k`}))}return s.loadSource(i),s.attachMedia(r),{destroy(){l=!0,s.destroy()},levels:u,setLevel(e){s.currentLevel=e},currentLevel:()=>s.autoLevelEnabled?-1:s.currentLevel}}export{n as createHlsEngine};
+import{t as e}from"./index-g9xRD0Ln.js";var t=3;async function n(n){let{media:r,src:i,isTv:a}=n,{default:o}=await e(async()=>{let{default:e}=await import(`./hls-n74Cnh8A.js`);return{default:e}},[]);if(!o.isSupported())return n.onError(`This browser cannot play HLS streams.`),{destroy:()=>void 0,levels:()=>[]};let s=new o({...a?{maxBufferLength:60,maxMaxBufferLength:120,backBufferLength:30,liveSyncDurationCount:4}:{backBufferLength:90},enableWorker:!0}),c=0,l=!1;s.on(o.Events.ERROR,(e,r)=>{if(!l&&r.fatal){if(c>=t){n.onError(`This stream kept failing and has been stopped.`),s.destroy();return}switch(c+=1,r.type){case o.ErrorTypes.NETWORK_ERROR:n.onNotice(`Reconnecting…`),s.startLoad();break;case o.ErrorTypes.MEDIA_ERROR:n.onNotice(`Recovering…`),s.recoverMediaError();break;default:n.onError(`This stream could not be played.`),s.destroy()}}}),s.on(o.Events.MANIFEST_PARSED,()=>{l||(n.onNotice(null),n.onReady?.({live:s.levels.length>0&&!Number.isFinite(r.duration),levels:u()}))}),s.on(o.Events.LEVEL_LOADED,(e,t)=>{l||n.onReady?.({live:t.details.live,levels:u()})}),s.on(o.Events.FRAG_BUFFERED,()=>{l||n.onNotice(null)});function u(){return s.levels.map((e,t)=>({index:t,height:e.height||null,bitrate:e.bitrate||null,label:e.height?`${String(e.height)}p`:`${String(Math.round((e.bitrate||0)/1e3))}k`}))}return s.loadSource(i),s.attachMedia(r),{destroy(){l=!0,s.destroy()},levels:u,setLevel(e){s.currentLevel=e},currentLevel:()=>s.autoLevelEnabled?-1:s.currentLevel}}export{n as createHlsEngine};