nixamp 0.6.4 → 0.7.1

package/src/playlist.ts

@@ -87,6 +87,64 @@ export async function readPlaylist(source: string): Promise<Entry[]> {
   return entries;
 }
 
+/**
+ * The audio linked from a directory listing a web server generated.
+ *
+ * A seedbox or a plain Apache with autoindex on serves a folder as an HTML page
+ * of relative links. Handed one of those, nixamp used to make a single track of
+ * the page itself and give it to ffmpeg, which is asked to decode HTML and says
+ * so in a way nobody reads. It is a folder; it should behave like one.
+ *
+ * Not recursive, deliberately: one page is one album, the subdirectory links are
+ * on it, and walking a stranger's whole tree from a text box is a different and
+ * much larger thing to ask for.
+ */
+export async function readRemoteIndex(source: string, send: typeof fetch = fetch): Promise<Entry[]> {
+  let answer: Response;
+  try {
+    answer = await send(source, {
+      redirect: "follow",
+      headers: { accept: "text/html,*/*" },
+      signal: AbortSignal.timeout(15_000),
+    });
+  } catch {
+    return [];
+  }
+  if (!answer.ok) return [];
+  // Anything that is not a page is the thing itself, and the caller plays it.
+  if (!/^text\/html/i.test(answer.headers.get("content-type") ?? "")) return [];
+
+  const html = await answer.text().catch(() => "");
+  const found: Entry[] = [];
+  const seen = new Set<string>();
+  for (const match of html.matchAll(/href\s*=\s*["']([^"']+)["']/gi)) {
+    const href = match[1];
+    // The sort links an index puts at the top of every column, and anchors.
+    if (!href || href.startsWith("?") || href.startsWith("#")) continue;
+    let url: URL;
+    try {
+      // Relative to the page, which is how an index writes them.
+      url = new URL(href.replace(/&amp;/g, "&"), source);
+    } catch {
+      continue;
+    }
+    if (!isAudio(url.pathname)) continue;
+    const link = url.toString();
+    if (seen.has(link)) continue;
+    seen.add(link);
+    found.push({
+      source: link,
+      // The name as a person wrote it, not as a URL spells it.
+      title: decodeURIComponent(url.pathname.split("/").pop() ?? link),
+      duration: 0,
+    });
+  }
+  // Server order is by whatever column the index sorted on; by name is what
+  // somebody handing over an album meant.
+  found.sort((a, b) => a.title.localeCompare(b.title, undefined, { numeric: true }));
+  return found;
+}
+
 /**
  * Everything `nixamp <thing>` can be handed: a directory, a file, a playlist,
  * or a URL to any of those.
@@ -112,9 +170,18 @@ export async function loadSource(tools: Tools, source: string, probeTags = true)
     );
   }
 
-  // A bare URL is one remote thing to play. Whether it is a song or a live
-  // stream is ffmpeg's problem, and it is good at it.
-  if (isRemote(source)) return [bare({ source, title: nameOf(source), duration: 0 })];
+  if (isRemote(source)) {
+    // A URL that names no file is probably a folder, and a folder served over
+    // http is a page of links. Asked only when it could be one: a stream URL
+    // must not pay for a fetch that will tell us nothing.
+    if (!isAudio(new URL(source).pathname)) {
+      const listed = await readRemoteIndex(source);
+      if (listed.length > 0) return listed.map(bare);
+    }
+    // A bare URL is one remote thing to play. Whether it is a song or a live
+    // stream is ffmpeg's problem, and it is good at it.
+    return [bare({ source, title: nameOf(source), duration: 0 })];
+  }
 
   return loadPlaylist(tools, source, probeTags);
 }

package/src/server.ts

@@ -12,6 +12,7 @@
 import { createReadStream, statSync } from "node:fs";
 import { createServer as createHttpServer, type IncomingMessage, type Server, type ServerResponse } from "node:http";
 import { createServer as createHttpsServer } from "node:https";
+import { randomBytes } from "node:crypto";
 import { hostname, networkInterfaces } from "node:os";
 import { spawn, spawnSync } from "node:child_process";
 import { readFileSync } from "node:fs";
@@ -28,6 +29,8 @@ import { Ingest, normaliseFormat } from "./ingest.ts";
 import { Channels, cleanId } from "./channels.ts";
 import { RtmpListeners } from "./rtmp-in.ts";
 import { Accounts, clearedCookie, sessionCookie, tokenFrom } from "./accounts.ts";
+import { anonymousHandle, Handles } from "./handles.ts";
+import { OpenDirs } from "./opendirs.ts";
 import { Servers } from "./servers.ts";
 import { DeviceGrants } from "./device.ts";
 import { BAD_KEY_LIMIT, callerOf, Guard, SIGN_IN_LIMIT } from "./guard.ts";
@@ -80,7 +83,7 @@ import {
   type Tools, type Track,
 } from "./audio.ts";
 import { Analyser, bandEdges, bands, decay } from "./fft.ts";
-import { loadSource, loadTagged } from "./playlist.ts";
+import { loadSource, loadTagged, readRemoteIndex } from "./playlist.ts";
 import {
   emptySnapshot, parseCommand,
   type Command, type RemoteTrack, type Snapshot,
@@ -692,6 +695,10 @@ export function isSignInPath(path: string): boolean {
     // rather than by a share key it has nothing to do with.
     path === "/api/v1/servers" ||
     path.startsWith("/api/v1/servers/") ||
+    path === "/api/v1/me/handle" ||
+    // Public to read, so it must not be behind a share key either.
+    path === "/api/v1/opendirs" ||
+    path.startsWith("/api/v1/opendirs/") ||
     OAUTH_ROUTE.test(path)
   );
 }
@@ -778,6 +785,10 @@ export interface HandlerOptions {
   signIn?: SignIn;
   /** The servers each account runs, on the instance that keeps accounts. */
   servers?: Servers;
+  /** The name other people see, which is never the address they signed up with. */
+  handles?: Handles;
+  /** Open directories people have found, which anyone may read. */
+  openDirs?: OpenDirs;
   /** True when this instance is reached over https, for the cookie's Secure. */
   secureCookies?: boolean;
   /** A certificate and key in PEM, when this server is to speak https itself. */
@@ -1256,6 +1267,43 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
         return;
       }
 
+      // --- the name other people see ---------------------------------------
+      //
+      // Separate from the address on purpose. The address is a credential and
+      // a way to reach somebody; publishing it in a directory listing or an
+      // invite would be publishing what they log in with.
+      if (path === "/api/v1/me/handle" && options.handles) {
+        const handles = options.handles;
+        const who = await accounts.whoIs(tokenFrom(request.headers));
+        if (who === null) {
+          json(response, 401, { error: "not signed in" });
+          return;
+        }
+
+        if (request.method === "GET") {
+          json(response, 200, { handle: await handles.of(who.id) });
+          return;
+        }
+        if (request.method === "PUT" || request.method === "POST") {
+          let body: { handle?: unknown };
+          try {
+            body = JSON.parse(await readBody(request)) as typeof body;
+          } catch {
+            json(response, 400, { error: "bad JSON" });
+            return;
+          }
+          const claimed = await handles.claim(who.id, body.handle);
+          if (claimed.error) {
+            json(response, 409, { error: claimed.error });
+            return;
+          }
+          json(response, 200, { handle: claimed.handle });
+          return;
+        }
+        json(response, 405, { error: "GET or PUT" });
+        return;
+      }
+
       // --- the servers this account runs ----------------------------------
       //
       // Kept against the account rather than the machine, so the list reads the
@@ -1413,6 +1461,18 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
         ? await accounts.signUp(body.email, body.password)
         : await accounts.signIn(body.email, body.password);
 
+      // A handle asked for at sign-up, or one nobody has to think about. Never
+      // derived from the address: turning anthony@… into "anthony" is the leak
+      // this whole idea exists to avoid, and it is one nobody would notice
+      // until it was already in a directory listing.
+      if (signingUp && result.ok && result.account && options.handles) {
+        const asked = (body as { handle?: unknown }).handle;
+        const claimed = await options.handles.claim(result.account.id, asked);
+        if (claimed.error) {
+          await options.handles.claim(result.account.id, anonymousHandle((size) => randomBytes(size)));
+        }
+      }
+
       // Getting it right costs nothing: the counters only exist to stop people
       // who keep getting it wrong.
       if (result.ok) for (const bucket of buckets) guard.forget(bucket);
@@ -1441,6 +1501,79 @@ export function createHandler(engine: Engine, options: HandlerOptions) {
       return;
     }
 
+    // --- open directories somebody found -----------------------------------
+    //
+    // Its own list, not the stream directory: that one is what is playing now,
+    // with a heartbeat and a room code and somebody at the other end, and this
+    // one is a folder on the web that is always there and belongs to nobody
+    // here. Reading needs no account. Adding does, because a public list with
+    // nobody accountable for its rows is a list of whatever anyone felt like.
+    if ((path === "/api/v1/opendirs" || path.startsWith("/api/v1/opendirs/")) && options.openDirs) {
+      const dirs = options.openDirs;
+
+      if (path === "/api/v1/opendirs" && request.method === "GET") {
+        const limit = Number(url.searchParams.get("limit") ?? "50");
+        const before = Number(url.searchParams.get("before") ?? "0");
+        const page = await dirs.list(Number.isFinite(limit) ? limit : 50, Number.isFinite(before) ? before : 0);
+        const names = options.handles ? await options.handles.many(page.addedBy) : new Map<string, string>();
+        json(response, 200, {
+          opendirs: page.rows.map((row, at) => ({
+            ...row,
+            // A handle or nothing. The address that signed up is never here.
+            by: names.get(page.addedBy[at] ?? "") ?? "",
+          })),
+          next: page.next,
+        });
+        return;
+      }
+
+      if (path === "/api/v1/opendirs" && request.method === "POST" && options.accounts) {
+        const who = await options.accounts.whoIs(tokenFrom(request.headers));
+        if (who === null) {
+          json(response, 401, { error: "sign in to publish one" });
+          return;
+        }
+        let body: { url?: unknown; name?: unknown };
+        try {
+          body = JSON.parse(await readBody(request)) as typeof body;
+        } catch {
+          json(response, 400, { error: "bad JSON" });
+          return;
+        }
+
+        // Read before publishing. A row nobody can play is worse than no row,
+        // and the count is the one fact a reader wants before clicking.
+        const listed = typeof body.url === "string" ? await readRemoteIndex(body.url) : [];
+        if (listed.length === 0) {
+          json(response, 422, { error: "nothing playable was linked from that page" });
+          return;
+        }
+        const made = await dirs.add(who.id, body.url, body.name, listed.length);
+        if (made === null) {
+          json(response, 422, { error: "that needs an http or https address" });
+          return;
+        }
+        const handle = options.handles ? await options.handles.of(who.id) : "";
+        json(response, 201, { opendir: { ...made, by: handle } });
+        return;
+      }
+
+      const dirId = path.slice("/api/v1/opendirs/".length);
+      if (dirId && request.method === "DELETE" && options.accounts) {
+        const who = await options.accounts.whoIs(tokenFrom(request.headers));
+        if (who === null) {
+          json(response, 401, { error: "not signed in" });
+          return;
+        }
+        const gone = await dirs.remove(who.id, dirId);
+        json(response, gone ? 200 : 404, gone ? { ok: true } : { error: "not yours, or not there" });
+        return;
+      }
+
+      json(response, 405, { error: "GET, POST or DELETE" });
+      return;
+    }
+
     // --- coming back from a provider ---------------------------------------
     //
     // /api/v1/<provider>/oauth/start sends a browser away, and .../callback is
@@ -2624,7 +2757,9 @@ export async function serve(argv: string[], version = "0.1.0"): Promise<void> {
           // all: a browser already signed in can approve a terminal.
           // The same pool the follows and reminders use: three small tables in
           // one database do not want three sets of connections.
-          ...(pool ? { servers: new Servers(pool) } : {}),
+          ...(pool
+            ? { servers: new Servers(pool), handles: new Handles(pool), openDirs: new OpenDirs(pool) }
+            : {}),
           signIn: new SignIn(
             providersFrom(process.env),
             new DeviceGrants(),

package/src/session.ts

@@ -659,3 +659,103 @@ interface ServerRow {
   url: string;
   key: string;
 }
+
+/** One row of the public open-directory list, as the API sends it. */
+interface OpenDirRow {
+  id: string;
+  url: string;
+  name: string;
+  tracks: number;
+  by: string;
+}
+
+/**
+ * `nixamp opendir list|add|remove`, the public list of folders people found.
+ *
+ * Reading needs no account, which is why `list` works signed out. Adding needs
+ * one, because a public list with nobody accountable for its rows is a list of
+ * whatever anybody felt like putting there.
+ */
+export async function opendirs(argv: string[], fetcher: typeof fetch = fetch): Promise<number> {
+  const [command = "list", ...rest] = argv;
+  const session = readSession();
+  const site = session?.site ?? DEFAULT_DIRECTORY;
+  const where = `${site}/api/v1/opendirs`;
+  const headers: Record<string, string> = {
+    "content-type": "application/json",
+    ...(session ? { authorization: `Bearer ${session.token}` } : {}),
+  };
+  const at = (flag: string): string | undefined => {
+    const index = rest.indexOf(flag);
+    return index === -1 ? undefined : rest[index + 1];
+  };
+
+  try {
+    if (command === "list" || command === "ls") {
+      const answer = await fetcher(where, { headers });
+      const body = (await answer.json().catch(() => ({}))) as { opendirs?: OpenDirRow[]; error?: string };
+      if (!answer.ok) {
+        console.error(`nixamp: ${body.error ?? `could not read the list (${answer.status})`}`);
+        return 1;
+      }
+      const rows = body.opendirs ?? [];
+      if (rows.length === 0) {
+        console.log("Nothing published yet. `nixamp opendir add <url>` puts one there.");
+        return 0;
+      }
+      const width = Math.max(...rows.map((row) => row.name.length));
+      for (const row of rows) {
+        const who = row.by ? ` by ${row.by}` : "";
+        console.log(`${row.id}  ${row.name.padEnd(width)}  ${row.tracks} tracks${who}`);
+        console.log(`  ${row.url}`);
+      }
+      return 0;
+    }
+
+    if (session === null) {
+      console.error("nixamp: sign in to publish or remove one. Try `nixamp login`.");
+      return 1;
+    }
+
+    if (command === "add" || command === "publish") {
+      const target = rest.find((a) => /^https?:\/\//.test(a)) ?? "";
+      if (!target) {
+        console.error("nixamp: which folder? Give the URL of a directory listing.");
+        return 64;
+      }
+      const answer = await fetcher(where, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ url: target, name: at("--name") ?? "" }),
+      });
+      const body = (await answer.json().catch(() => ({}))) as { opendir?: OpenDirRow; error?: string };
+      if (!answer.ok || !body.opendir) {
+        console.error(`nixamp: ${body.error ?? `could not publish it (${answer.status})`}`);
+        return 1;
+      }
+      console.log(`${body.opendir.id}  ${body.opendir.name}  ${body.opendir.tracks} tracks`);
+      return 0;
+    }
+
+    if (command === "remove" || command === "rm") {
+      const id = rest.find((a) => !a.startsWith("-")) ?? "";
+      if (!id) {
+        console.error("nixamp: which one? `nixamp opendir list` shows their ids.");
+        return 64;
+      }
+      const answer = await fetcher(`${where}/${encodeURIComponent(id)}`, { method: "DELETE", headers });
+      if (!answer.ok) {
+        console.error(`nixamp: ${answer.status === 404 ? "not yours, or not there" : "could not remove it"}`);
+        return 1;
+      }
+      console.log(`Removed ${id}.`);
+      return 0;
+    }
+
+    console.error(`nixamp: no such opendir command: ${command}`);
+    return 64;
+  } catch (error) {
+    console.error(`nixamp: could not reach ${site}: ${(error as Error).message}`);
+    return 69;
+  }
+}

package/web/dist/index.html

@@ -173,5 +173,6 @@
         <a href="https://github.com/profullstack/nixamp">github.com/profullstack/nixamp</a>
       </footer>
     </main>
+      <script data-site="f6b791a3-13e0-4212-a2c9-abafc3b7aff0" src="https://crawlproof.com/stats.js" async></script>
   </body>
 </html>

package/web/dist/sw.js

@@ -1,5 +1,5 @@
 /* nixamp service worker — generated, do not edit */
-const CACHE = "nixamp-1788945118927";
+const CACHE = "nixamp-1788946637747";
 const PRECACHE = [
   "/",
   "/apple-touch-icon.png",