nixamp 0.30.3 → 0.32.0

package/dist/station-mcp.js

@@ -26,7 +26,7 @@ export const STATION_TOOLS = [
     },
     {
         name: "station_create",
-        description: "Make a station from a folder in the library (path relative to it, \"\" for all of it) or from track indexes. It starts private and stopped; nothing is published.",
+        description: "Make a station from a folder in the library (path relative to it, \"\" for all of it), a playlist, or track indexes. It starts private and stopped; nothing is published.",
         inputSchema: {
             type: "object",
             properties: {
@@ -34,6 +34,7 @@ export const STATION_TOOLS = [
                 name: STRING,
                 folder: { ...STRING, description: "A folder under the library, e.g. \"Albums/Late Night\"." },
                 items: { type: "array", items: { type: "integer" }, description: "Track indexes, as /api/state lists them." },
+                playlist: { ...STRING, description: "A playlist id (playlist_list): the station plays its ready items in order." },
                 description: STRING,
                 shuffle: { type: "boolean" },
                 repeat: { type: "boolean", description: "Round and round (default) or once." },
@@ -84,6 +85,24 @@ export const STATION_TOOLS = [
     },
 ];
 const say = (value, isError = false) => ({ content: [{ type: "text", text: value }], ...(isError ? { isError: true } : {}) });
+/** Where to send a tool's request, and with which credential. */
+export function connect(args, options) {
+    const server = typeof args["server"] === "string" ? args["server"].replace(/\/+$/, "") : "";
+    const headers = { "content-type": "application/json" };
+    if (server === "") {
+        const local = options.local === undefined ? (() => { const state = readState(); return state ? { url: daemonUrl(state), key: state.key } : null; })() : options.local;
+        if (!local)
+            return { error: "No nixamp daemon runs on this machine. Start one (nixamp daemon start ~/Music) or pass `server`." };
+        if (local.key)
+            headers[KEY_HEADER] = local.key;
+        return { base: local.url, headers };
+    }
+    const session = options.session === undefined ? readSession() : options.session;
+    if (!session)
+        return { error: "Another server needs this machine signed in as its owner: nixamp login." };
+    headers["authorization"] = `Bearer ${session.token}`;
+    return { base: server, headers };
+}
 export function isStationTool(name) {
     return STATION_TOOLS.some((tool) => tool.name === name);
 }
@@ -95,23 +114,10 @@ function line(station) {
 }
 export async function callStationTool(name, args, options = {}) {
     const send = options.fetcher ?? fetch;
-    const server = typeof args["server"] === "string" ? args["server"].replace(/\/+$/, "") : "";
-    let base = server;
-    const headers = { "content-type": "application/json" };
-    if (server === "") {
-        const local = options.local === undefined ? (() => { const state = readState(); return state ? { url: daemonUrl(state), key: state.key } : null; })() : options.local;
-        if (!local)
-            return say("No nixamp daemon runs on this machine. Start one (nixamp daemon start ~/Music) or pass `server`.", true);
-        base = local.url;
-        if (local.key)
-            headers[KEY_HEADER] = local.key;
-    }
-    else {
-        const session = options.session === undefined ? readSession() : options.session;
-        if (!session)
-            return say("Another server's stations need this machine signed in as its owner: nixamp login.", true);
-        headers["authorization"] = `Bearer ${session.token}`;
-    }
+    const target = connect(args, options);
+    if ("error" in target)
+        return say(target.error, true);
+    const { base, headers } = target;
     const id = typeof args["id"] === "string" ? args["id"] : "";
     const call = async (method, path, body) => {
         const response = await send(`${base}${path}`, { method, headers, ...(body === undefined ? {} : { body: JSON.stringify(body) }) });
@@ -135,7 +141,7 @@ export async function callStationTool(name, args, options = {}) {
             return answer.ok ? say(JSON.stringify(answer.body["station"], null, 2)) : refused(answer.body);
         }
         if (name === "station_create") {
-            const answer = await call("POST", "/api/v1/stations", pick(["name", "folder", "items", "description", "shuffle", "repeat", "bitrate", "idempotencyKey"]));
+            const answer = await call("POST", "/api/v1/stations", pick(["name", "folder", "items", "playlist", "description", "shuffle", "repeat", "bitrate", "idempotencyKey"]));
             return answer.ok ? say(`Made, private and stopped: ${line(answer.body["station"])}`) : refused(answer.body);
         }
         if (name === "station_update") {

package/dist/station-usage.d.ts

@@ -1,2 +1,2 @@
 /** `nixamp station` usage, apart so `nixamp help station` does not load the client. */
-export declare const USAGE = "nixamp station \u2014 make a collection into a station\n\n  nixamp station list\n  nixamp station create --name NAME (--folder PATH | --items 0,1,2) [--shuffle] [--no-repeat] [--bitrate 128]\n  nixamp station show ID\n  nixamp station status ID\n  nixamp station start ID\n  nixamp station stop ID\n  nixamp station skip ID\n  nixamp station retry ID          try every left-out file again\n  nixamp station publish ID --basis owned|permission|licensed|public-domain [--note TEXT] [--unlisted] [--no-list]\n  nixamp station unpublish ID [--private]\n  nixamp station link ID [--rotate]\n  nixamp station delete ID\n\n  --json        machine-readable output\n  --url, --key  another server, as with `nixamp admin`\n\nA new station is private and stopped. Starting it does not publish it.";
+export declare const USAGE = "nixamp station \u2014 make a collection into a station\n\n  nixamp station list\n  nixamp station create --name NAME (--folder PATH | --playlist ID | --items 0,1,2) [--shuffle] [--no-repeat] [--bitrate 128]\n  nixamp station show ID\n  nixamp station status ID\n  nixamp station start ID\n  nixamp station stop ID\n  nixamp station skip ID\n  nixamp station retry ID          try every left-out file again\n  nixamp station publish ID --basis owned|permission|licensed|public-domain [--note TEXT] [--unlisted] [--no-list]\n  nixamp station unpublish ID [--private]\n  nixamp station link ID [--rotate]\n  nixamp station delete ID\n\n  --json        machine-readable output\n  --url, --key  another server, as with `nixamp admin`\n\nA new station is private and stopped. Starting it does not publish it.";

package/dist/station-usage.js

@@ -2,7 +2,7 @@
 export const USAGE = `nixamp station — make a collection into a station
 
   nixamp station list
-  nixamp station create --name NAME (--folder PATH | --items 0,1,2) [--shuffle] [--no-repeat] [--bitrate 128]
+  nixamp station create --name NAME (--folder PATH | --playlist ID | --items 0,1,2) [--shuffle] [--no-repeat] [--bitrate 128]
   nixamp station show ID
   nixamp station status ID
   nixamp station start ID

package/package.json

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

package/src/library-cli.ts

@@ -0,0 +1,175 @@
+/**
+ * `nixamp library <command>`: the index, from a terminal or a script.
+ *
+ * `nixamp library ~/Music` still sets the folder a daemon serves (library.ts);
+ * these are the questions you ask once it is running. Same conventions as
+ * `nixamp station`: the daemon on this machine unless --url/--key, --json for
+ * scripts, exit 0 done, 1 refused, 2 usage, 3 unreachable.
+ */
+import { resolveTarget } from "./admin.ts";
+import { KEY_HEADER } from "./share.ts";
+
+import { LIBRARY_COMMANDS, LIBRARY_USAGE } from "./library-usage.ts";
+
+export { LIBRARY_COMMANDS, LIBRARY_USAGE };
+
+function flag(argv: string[], name: string): string | undefined {
+  const at = argv.indexOf(name);
+  return at === -1 ? undefined : argv[at + 1];
+}
+
+/** Words that are not flags or flag values. */
+function words(argv: string[]): string[] {
+  const out: string[] = [];
+  for (let at = 0; at < argv.length; at++) {
+    const one = argv[at]!;
+    if (one.startsWith("--")) {
+      if (!["--json", "--force", "--wait"].includes(one)) at += 1;
+      continue;
+    }
+    out.push(one);
+  }
+  return out;
+}
+
+export async function libraryTool(argv: string[]): Promise<number> {
+  const [command] = argv;
+  const json = argv.includes("--json");
+  let target;
+  try {
+    target = resolveTarget(argv);
+  } catch (error) {
+    console.error((error as Error).message);
+    return 3;
+  }
+  const headers: Record<string, string> = { "content-type": "application/json", ...(target.key ? { [KEY_HEADER]: target.key } : {}) };
+  const call = async (method: string, path: string, body?: unknown): Promise<{ status: number; body: Record<string, unknown> }> => {
+    let response: Response;
+    try {
+      response = await fetch(`${target.url}${path}`, { method, headers, ...(body === undefined ? {} : { body: JSON.stringify(body) }) });
+    } catch (error) {
+      throw Object.assign(new Error(`could not reach ${target.url}: ${(error as Error).message}`), { unreachable: true });
+    }
+    const parsed = (await response.json().catch(() => ({}))) as Record<string, unknown>;
+    return { status: response.status, body: parsed };
+  };
+  const out = (answer: { status: number; body: Record<string, unknown> }, line: (body: Record<string, unknown>) => string): number => {
+    if (json) console.log(JSON.stringify(answer.body, null, 2));
+    else if (answer.status < 400) console.log(line(answer.body));
+    if (answer.status >= 400) {
+      if (!json) console.error(`nixamp: ${String(answer.body["error"] ?? "refused")} (${String(answer.body["code"] ?? answer.status)})`);
+      return 1;
+    }
+    return 0;
+  };
+  const scanLine = (scan: Record<string, unknown> | null | undefined): string =>
+    scan ? `${String(scan["status"])}: ${String(scan["found"])} found, ${String(scan["unchanged"])} unchanged, ${String(scan["probed"])} read, ${String(scan["failed"])} failed, ${String(scan["missing"])} gone` : "never scanned";
+  const itemLine = (item: Record<string, unknown>): string =>
+    `${String(item["id"])}  ${String(item["artist"] || "?")} — ${String(item["title"])}${item["album"] ? `  (${String(item["album"])})` : ""}${item["state"] !== "ready" ? `  [${String(item["state"])}]` : ""}`;
+  const rest = words(argv.slice(1));
+
+  try {
+    switch (command) {
+      case "status":
+        return out(await call("GET", "/api/v1/library"), (body) => {
+          const counts = body["counts"] as Record<string, number>;
+          const sources = (body["sources"] as Record<string, unknown>[]) ?? [];
+          return [
+            `${String(body["items"])} items: ${Object.entries(counts).filter(([, n]) => n > 0).map(([state, n]) => `${n} ${state}`).join(", ") || "none"}`,
+            ...sources.map((one) => `  ${String(one["id"])}  ${String(one["root"] ?? "")}${one["enabled"] ? "" : " (off)"}\n    last scan ${scanLine(one["lastScan"] as Record<string, unknown> | null)}`),
+          ].join("\n");
+        });
+      case "sources":
+        return out(await call("GET", "/api/v1/library/sources"), (body) =>
+          ((body["sources"] as Record<string, unknown>[]) ?? []).map((one) => `${String(one["id"])}  ${String(one["root"] ?? "")}${one["enabled"] ? "" : " (off)"}`).join("\n") || "No sources.");
+      case "add": {
+        const [path] = rest;
+        if (!path) { console.error("nixamp library add needs a folder"); return 2; }
+        const { resolve } = await import("node:path");
+        const { homedir } = await import("node:os");
+        return out(await call("POST", "/api/v1/library/sources", { root: resolve(path.replace(/^~(?=$|\/)/, homedir())) }), (body) =>
+          `Indexing ${String((body["source"] as Record<string, unknown>)["root"])} as ${String((body["source"] as Record<string, unknown>)["id"])}.`);
+      }
+      case "scan": {
+        let [source] = rest;
+        if (!source) {
+          const listed = await call("GET", "/api/v1/library/sources");
+          const all = (listed.body["sources"] as Record<string, unknown>[]) ?? [];
+          if (all.length !== 1) { console.error("Which source? `nixamp library sources` lists them."); return 2; }
+          source = String(all[0]!["id"]);
+        }
+        const started = await call("POST", `/api/v1/library/sources/${source}/scan`, { force: argv.includes("--force") });
+        if (started.status >= 400 || !argv.includes("--wait")) return out(started, (body) => `Scanning: job ${String((body["job"] as Record<string, unknown>)["jobId"])}.`);
+        const jobId = String((started.body["job"] as Record<string, unknown>)["jobId"]);
+        for (;;) {
+          const polled = await call("GET", `/api/v1/library/jobs/${jobId}`);
+          const job = polled.body["job"] as Record<string, unknown> | undefined;
+          if (polled.status >= 400 || !job || job["status"] !== "running") return out(polled, () => scanLine(job));
+          await new Promise((next) => setTimeout(next, 1000));
+        }
+      }
+      case "search": {
+        const query = new URLSearchParams({ q: rest.join(" "), limit: flag(argv, "--limit") ?? "20", sort: "artist" });
+        for (const name of ["artist", "album", "genre", "state", "folder"]) {
+          const value = flag(argv, `--${name}`);
+          if (value) query.set(name, value);
+        }
+        return out(await call("GET", `/api/v1/library/items?${query}`), (body) => {
+          const items = (body["items"] as Record<string, unknown>[]) ?? [];
+          return items.length ? `${items.map(itemLine).join("\n")}\n${String(body["total"])} in all` : "Nothing matches.";
+        });
+      }
+      case "show": {
+        const [item] = rest;
+        if (!item) { console.error("nixamp library show needs an item id"); return 2; }
+        return out(await call("GET", `/api/v1/library/items/${item}`), (body) => JSON.stringify(body["item"], null, 2));
+      }
+      case "fix": {
+        const [item] = rest;
+        if (!item) { console.error("nixamp library fix needs an item id"); return 2; }
+        const patch: Record<string, unknown> = {};
+        for (const name of ["title", "artist", "album", "albumArtist", "genre"]) {
+          const value = flag(argv, `--${name}`);
+          if (value !== undefined) patch[name] = value;
+        }
+        for (const name of ["track", "disc", "year"]) {
+          const value = flag(argv, `--${name}`);
+          if (value !== undefined) patch[name] = Number(value);
+        }
+        if (Object.keys(patch).length === 0) { console.error("nixamp library fix needs at least one of --title --artist --album --genre --track --disc --year"); return 2; }
+        return out(await call("PATCH", `/api/v1/library/items/${item}`, patch), (body) => itemLine(body["item"] as Record<string, unknown>));
+      }
+      case "remove": {
+        const [source] = rest;
+        if (!source) { console.error("nixamp library remove needs a source id"); return 2; }
+        return out(await call("DELETE", `/api/v1/library/sources/${source}`), (body) => `Forgot ${String(body["forgotten"])} items. No file was touched.`);
+      }
+      case "playlists":
+        return out(await call("GET", "/api/v1/library/playlists"), (body) =>
+          ((body["playlists"] as Record<string, unknown>[]) ?? []).map((one) => `${String(one["id"])}  ${String(one["name"])} (${String(one["count"])})`).join("\n") || "No playlists yet.");
+      case "playlist": {
+        const [verb, first, ...others] = rest;
+        const showList = (body: Record<string, unknown>): string => {
+          const list = body["playlist"] as Record<string, unknown>;
+          const items = (list["items"] as Record<string, unknown>[] | undefined) ?? [];
+          return [`${String(list["id"])}  ${String(list["name"])} (revision ${String(list["revision"])})`, ...items.map((one, at) => `  ${at + 1}. ${itemLine(one)}`)].join("\n");
+        };
+        if (verb === "new" && first) return out(await call("POST", "/api/v1/library/playlists", { name: first, items: others }), showList);
+        if (verb === "show" && first) return out(await call("GET", `/api/v1/library/playlists/${first}`), showList);
+        if (verb === "add" && first && others.length) return out(await call("POST", `/api/v1/library/playlists/${first}/items`, { items: others }), showList);
+        if (verb === "delete" && first) return out(await call("DELETE", `/api/v1/library/playlists/${first}`), () => `Deleted playlist ${first}.`);
+        console.error("nixamp library playlist new NAME [ITEM...] | show ID | add ID ITEM... | delete ID");
+        return 2;
+      }
+      default:
+        console.log(LIBRARY_USAGE);
+        return 2;
+    }
+  } catch (error) {
+    if ((error as { unreachable?: boolean }).unreachable) {
+      console.error(`nixamp: ${(error as Error).message}`);
+      return 3;
+    }
+    throw error;
+  }
+}