nixamp 0.30.1 → 0.32.0

package/dist/library-mcp.d.ts

@@ -0,0 +1,230 @@
+/**
+ * The library as MCP tools: what is here, find something, look again.
+ *
+ * Same target and credential rules as the station tools (station-mcp.ts):
+ * this machine's daemon by its control key, or another server as its owner.
+ */
+import { type StationToolOptions } from "./station-mcp.ts";
+export declare const LIBRARY_TOOLS: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            server: {
+                type: "string";
+                description: string;
+            };
+            artist?: undefined;
+            album?: undefined;
+            genre?: undefined;
+            folder?: undefined;
+            state?: undefined;
+            offset?: undefined;
+            kind?: undefined;
+            q?: undefined;
+            limit?: undefined;
+            name?: undefined;
+            id?: undefined;
+            items?: undefined;
+            at?: undefined;
+            source?: undefined;
+            force?: undefined;
+        };
+        required?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            server: {
+                type: "string";
+                description: string;
+            };
+            q: {
+                readonly type: "string";
+            };
+            artist: {
+                readonly type: "string";
+            };
+            album: {
+                readonly type: "string";
+            };
+            genre: {
+                readonly type: "string";
+            };
+            folder: {
+                readonly type: "string";
+            };
+            state: {
+                type: string;
+                enum: string[];
+            };
+            limit: {
+                type: string;
+            };
+            offset: {
+                type: string;
+            };
+            kind?: undefined;
+            name?: undefined;
+            id?: undefined;
+            items?: undefined;
+            at?: undefined;
+            source?: undefined;
+            force?: undefined;
+        };
+        required?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            artist?: undefined;
+            album?: undefined;
+            genre?: undefined;
+            folder?: undefined;
+            state?: undefined;
+            offset?: undefined;
+            server: {
+                type: "string";
+                description: string;
+            };
+            kind: {
+                type: string;
+                enum: string[];
+            };
+            q: {
+                readonly type: "string";
+            };
+            limit: {
+                type: string;
+            };
+            name?: undefined;
+            id?: undefined;
+            items?: undefined;
+            at?: undefined;
+            source?: undefined;
+            force?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            artist?: undefined;
+            album?: undefined;
+            genre?: undefined;
+            folder?: undefined;
+            state?: undefined;
+            offset?: undefined;
+            kind?: undefined;
+            q?: undefined;
+            limit?: undefined;
+            server: {
+                type: "string";
+                description: string;
+            };
+            name: {
+                readonly type: "string";
+            };
+            items: {
+                type: string;
+                items: {
+                    readonly type: "string";
+                };
+            };
+            id?: undefined;
+            at?: undefined;
+            source?: undefined;
+            force?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            artist?: undefined;
+            album?: undefined;
+            genre?: undefined;
+            folder?: undefined;
+            state?: undefined;
+            offset?: undefined;
+            kind?: undefined;
+            q?: undefined;
+            limit?: undefined;
+            name?: undefined;
+            server: {
+                type: "string";
+                description: string;
+            };
+            id: {
+                readonly type: "string";
+            };
+            items: {
+                type: string;
+                items: {
+                    readonly type: "string";
+                };
+            };
+            at: {
+                type: string;
+            };
+            source?: undefined;
+            force?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        required?: undefined;
+        type: string;
+        properties: {
+            artist?: undefined;
+            album?: undefined;
+            genre?: undefined;
+            folder?: undefined;
+            state?: undefined;
+            offset?: undefined;
+            kind?: undefined;
+            q?: undefined;
+            limit?: undefined;
+            name?: undefined;
+            id?: undefined;
+            items?: undefined;
+            at?: undefined;
+            server: {
+                type: "string";
+                description: string;
+            };
+            source: {
+                readonly type: "string";
+            };
+            force: {
+                type: string;
+            };
+        };
+    };
+})[];
+export declare function isLibraryTool(name: string): boolean;
+type Result = {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError?: boolean;
+};
+export declare function callLibraryTool(name: string, args: Record<string, unknown>, options?: StationToolOptions): Promise<Result>;
+export {};

package/dist/library-mcp.js

@@ -0,0 +1,139 @@
+/**
+ * The library as MCP tools: what is here, find something, look again.
+ *
+ * Same target and credential rules as the station tools (station-mcp.ts):
+ * this machine's daemon by its control key, or another server as its owner.
+ */
+import { connect } from "./station-mcp.js";
+const STRING = { type: "string" };
+const SERVER = { ...STRING, description: "A nixamp server's address; this machine's daemon when omitted." };
+export const LIBRARY_TOOLS = [
+    {
+        name: "library_status",
+        description: "How many items the library has in each state (ready, pending, failed, unsupported, unavailable), its sources, and their last scans.",
+        inputSchema: { type: "object", properties: { server: SERVER } },
+    },
+    {
+        name: "library_search",
+        description: "Find items in the library by words (title, artist, album, genre, folder) and filters. Returns ids usable for stations (as track paths) and corrections.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                server: SERVER,
+                q: STRING, artist: STRING, album: STRING, genre: STRING, folder: STRING,
+                state: { type: "string", enum: ["ready", "pending", "failed", "unsupported", "unavailable", "all"] },
+                limit: { type: "integer" }, offset: { type: "integer" },
+            },
+        },
+    },
+    {
+        name: "library_browse",
+        description: "The library grouped: every artist, album, genre or top-level folder, with counts.",
+        inputSchema: {
+            type: "object",
+            properties: { server: SERVER, kind: { type: "string", enum: ["artists", "albums", "genres", "folders"] }, q: STRING, limit: { type: "integer" } },
+            required: ["kind"],
+        },
+    },
+    {
+        name: "playlist_list",
+        description: "This listener's playlists on the server: id, name, how many items.",
+        inputSchema: { type: "object", properties: { server: SERVER } },
+    },
+    {
+        name: "playlist_create",
+        description: "A new playlist from library item ids (from library_search), in order. A playlist can then be a station: station_create with playlist.",
+        inputSchema: { type: "object", properties: { server: SERVER, name: STRING, items: { type: "array", items: STRING } }, required: ["name"] },
+    },
+    {
+        name: "playlist_add",
+        description: "Add library items to a playlist, at the end or at a place.",
+        inputSchema: { type: "object", properties: { server: SERVER, id: STRING, items: { type: "array", items: STRING }, at: { type: "integer" } }, required: ["id", "items"] },
+    },
+    {
+        name: "library_scan",
+        description: "Look at a source again: new files are read, changed ones re-read, gone ones marked unavailable. Returns a job id; library_status shows when it is done.",
+        inputSchema: { type: "object", properties: { server: SERVER, source: STRING, force: { type: "boolean" } } },
+    },
+];
+export function isLibraryTool(name) {
+    return LIBRARY_TOOLS.some((tool) => tool.name === name);
+}
+const say = (text, isError = false) => ({ content: [{ type: "text", text }], ...(isError ? { isError: true } : {}) });
+export async function callLibraryTool(name, args, options = {}) {
+    const send = options.fetcher ?? fetch;
+    const target = connect(args, options);
+    if ("error" in target)
+        return say(target.error, true);
+    const get = async (method, path, body) => {
+        const response = await send(`${target.base}${path}`, { method, headers: target.headers, ...(body === undefined ? {} : { body: JSON.stringify(body) }) });
+        return { ok: response.ok, body: (await response.json().catch(() => ({}))) };
+    };
+    const refused = (body) => say(`${String(body["error"] ?? "refused")} (${String(body["code"] ?? "error")})`, true);
+    try {
+        if (name === "library_status") {
+            const answer = await get("GET", "/api/v1/library");
+            return answer.ok ? say(JSON.stringify(answer.body, null, 2)) : refused(answer.body);
+        }
+        if (name === "library_search") {
+            const query = new URLSearchParams();
+            for (const key of ["q", "artist", "album", "genre", "folder", "state"])
+                if (typeof args[key] === "string")
+                    query.set(key, args[key]);
+            for (const key of ["limit", "offset"])
+                if (typeof args[key] === "number")
+                    query.set(key, String(args[key]));
+            const answer = await get("GET", `/api/v1/library/items?${query}`);
+            if (!answer.ok)
+                return refused(answer.body);
+            const items = answer.body["items"] ?? [];
+            const lines = items.map((one) => `${String(one["id"])}  ${String(one["artist"] || "?")} — ${String(one["title"])}${one["album"] ? ` (${String(one["album"])})` : ""}  ${String(one["rel"])}`);
+            return say(lines.length ? `${lines.join("\n")}\n${String(answer.body["total"])} in all` : "Nothing matches.");
+        }
+        if (name === "library_browse") {
+            const kind = String(args["kind"] ?? "");
+            const query = new URLSearchParams();
+            if (typeof args["q"] === "string")
+                query.set("q", args["q"]);
+            if (typeof args["limit"] === "number")
+                query.set("limit", String(args["limit"]));
+            const answer = await get("GET", `/api/v1/library/browse/${encodeURIComponent(kind)}?${query}`);
+            if (!answer.ok)
+                return refused(answer.body);
+            const groups = answer.body["groups"] ?? [];
+            return say(groups.map((one) => `${one.name}${one.artist ? ` — ${one.artist}` : ""} (${one.count})`).join("\n") || "Nothing yet.");
+        }
+        if (name === "playlist_list") {
+            const answer = await get("GET", "/api/v1/library/playlists");
+            if (!answer.ok)
+                return refused(answer.body);
+            const lists = answer.body["playlists"] ?? [];
+            return say(lists.map((one) => `${String(one["id"])}  ${String(one["name"])} (${String(one["count"])})`).join("\n") || "No playlists yet.");
+        }
+        if (name === "playlist_create" || name === "playlist_add") {
+            const answer = name === "playlist_create"
+                ? await get("POST", "/api/v1/library/playlists", { name: args["name"], items: args["items"] ?? [] })
+                : await get("POST", `/api/v1/library/playlists/${encodeURIComponent(String(args["id"] ?? ""))}/items`, { items: args["items"], ...(typeof args["at"] === "number" ? { at: args["at"] } : {}) });
+            if (!answer.ok)
+                return refused(answer.body);
+            const list = answer.body["playlist"];
+            return say(`${String(list["id"])}  ${String(list["name"])}: ${String(list["count"])} items, revision ${String(list["revision"])}`);
+        }
+        if (name === "library_scan") {
+            let source = typeof args["source"] === "string" ? args["source"] : "";
+            if (!source) {
+                const listed = await get("GET", "/api/v1/library/sources");
+                const all = listed.body["sources"] ?? [];
+                if (all.length !== 1)
+                    return say("Which source? library_status lists them.", true);
+                source = String(all[0]["id"]);
+            }
+            const answer = await get("POST", `/api/v1/library/sources/${source}/scan`, { force: args["force"] === true });
+            return answer.ok ? say(`Scanning; job ${String(answer.body["job"]["jobId"])}.`) : refused(answer.body);
+        }
+    }
+    catch (error) {
+        return say(`Could not reach ${target.base}: ${error.message}`, true);
+    }
+    return say(`No such tool: ${name}`, true);
+}

package/dist/library-routes.d.ts

@@ -0,0 +1,34 @@
+/**
+ * /api/v1/library: the owner's files, as sources, items and groups.
+ *
+ * Reading -- search, browse, an item, its stream -- is for whoever got past
+ * the server's key: the owner, or somebody the owner gave the listen link to,
+ * which has always been how a library is shared. Only the owner sees where a
+ * file lives (`path`); everybody else gets its place inside the library.
+ * Changing anything -- sources, scans, corrections -- is the owner's.
+ * A station's link reaches none of this.
+ */
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { type LibraryIndex, type LibraryItem, type Probed } from "./library-index.ts";
+import type { Track } from "./audio.ts";
+import type { ListenerStore } from "./library-user.ts";
+export interface LibraryContext {
+    index: LibraryIndex;
+    /** Past the server's key: may read. */
+    canRead: boolean;
+    /** The control key or the owner: may change things. */
+    canWrite: boolean;
+    account: string;
+    /** Who this is, for their playlists and queue; null when nobody in particular. */
+    principal: string | null;
+    listeners?: ListenerStore;
+    probe: (path: string) => Promise<Probed>;
+    /** Tell the player about tags that changed. */
+    retag: (tracks: Track[]) => void;
+    sendFile: (request: IncomingMessage, response: ServerResponse, file: string, cache: string) => void;
+    json: (response: ServerResponse, status: number, body: unknown) => void;
+    readBody: (request: IncomingMessage) => Promise<string>;
+}
+/** An item as a caller may see it: the path only for the owner. */
+export declare function itemView(item: LibraryItem, owner: boolean): Record<string, unknown>;
+export declare function handleLibrary(request: IncomingMessage, response: ServerResponse, path: string, url: URL, ctx: LibraryContext): Promise<boolean>;

package/dist/library-routes.js

@@ -0,0 +1,258 @@
+import { hostname } from "node:os";
+import { LibraryError, shown, trackOf, } from "./library-index.js";
+/** An item as a caller may see it: the path only for the owner. */
+export function itemView(item, owner) {
+    const tags = shown(item);
+    return {
+        id: item.id,
+        sourceId: item.sourceId,
+        rel: item.rel,
+        ...(owner ? { path: item.path, override: item.override, size: item.size } : {}),
+        state: item.state,
+        ...(item.error && owner ? { error: item.error } : {}),
+        ...tags,
+        duration: item.duration,
+        format: { codec: item.codec, bitrateKbps: item.bitrate, sampleRate: item.sampleRate, channels: item.channels },
+        video: item.video,
+        hasArt: item.hasArt,
+    };
+}
+const STATES = new Set(["pending", "ready", "unsupported", "failed", "unavailable", "all"]);
+const SORTS = new Set(["path", "title", "artist", "album", "recent"]);
+const KINDS = new Set(["artists", "albums", "genres", "folders"]);
+export async function handleLibrary(request, response, path, url, ctx) {
+    if (path !== "/api/v1/library" && !path.startsWith("/api/v1/library/"))
+        return false;
+    const method = request.method ?? "GET";
+    const { index } = ctx;
+    const fail = (status, code, error) => {
+        ctx.json(response, status, { error, code });
+        return true;
+    };
+    if (!ctx.canRead)
+        return fail(401, "unauthorized", "this library needs its link, or sign in as its owner");
+    const needWrite = () => {
+        if (ctx.canWrite)
+            return true;
+        fail(403, "forbidden", "only this server's owner changes its library");
+        return false;
+    };
+    const body = async () => {
+        const raw = await ctx.readBody(request);
+        if (raw.trim() === "")
+            return {};
+        const parsed = JSON.parse(raw);
+        if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+            throw new LibraryError("bad_json", "the body is not a JSON object");
+        return parsed;
+    };
+    const number = (name) => {
+        const value = url.searchParams.get(name);
+        return value === null ? undefined : Number(value) || 0;
+    };
+    const text = (name) => url.searchParams.get(name) ?? undefined;
+    try {
+        if (path === "/api/v1/library" && method === "GET") {
+            ctx.json(response, 200, {
+                items: index.size,
+                counts: index.counts(),
+                sources: index.sources().map((one) => ({ id: one.id, enabled: one.enabled, lastScan: one.lastScan, ...(ctx.canWrite ? { root: one.root, host: one.host } : {}) })),
+            });
+            return true;
+        }
+        if (path === "/api/v1/library/sources") {
+            if (method === "GET") {
+                ctx.json(response, 200, { sources: index.sources().map((one) => (ctx.canWrite ? one : { id: one.id, enabled: one.enabled, lastScan: one.lastScan })) });
+                return true;
+            }
+            if (method === "POST") {
+                if (!needWrite())
+                    return true;
+                const input = await body();
+                if (typeof input["root"] !== "string" || input["root"].trim() === "")
+                    throw new LibraryError("root_required", "say which folder: {\"root\": \"/path\"}");
+                const { existsSync, statSync } = await import("node:fs");
+                const root = input["root"].trim();
+                if (!existsSync(root) || !statSync(root).isDirectory())
+                    throw new LibraryError("not_a_folder", "that is not a folder on this machine");
+                const source = index.addSource(root, ctx.account, hostname());
+                const { report } = index.scan(source.id, ctx.probe, { onProgress: (changed) => ctx.retag(changed.filter((one) => one.state === "ready").map(trackOf)) });
+                ctx.json(response, 201, { source, job: report });
+                return true;
+            }
+            return fail(405, "method_not_allowed", "GET or POST");
+        }
+        const sourceMatch = /^\/api\/v1\/library\/sources\/([0-9a-f]{16})(?:\/(scan))?$/.exec(path);
+        if (sourceMatch) {
+            const id = sourceMatch[1];
+            if (sourceMatch[2] === "scan") {
+                if (method !== "POST")
+                    return fail(405, "method_not_allowed", "POST");
+                if (!needWrite())
+                    return true;
+                const input = await body();
+                const { report } = index.scan(id, ctx.probe, {
+                    force: input["force"] === true,
+                    onProgress: (changed) => ctx.retag(changed.filter((one) => one.state === "ready").map(trackOf)),
+                });
+                ctx.json(response, 202, { job: report });
+                return true;
+            }
+            if (method === "GET") {
+                const source = index.source(id);
+                if (!source)
+                    return fail(404, "not_found", "no such source");
+                ctx.json(response, 200, { source: ctx.canWrite ? source : { id: source.id, enabled: source.enabled, lastScan: source.lastScan } });
+                return true;
+            }
+            if (!needWrite())
+                return true;
+            if (method === "PATCH") {
+                const input = await body();
+                if (typeof input["enabled"] !== "boolean")
+                    throw new LibraryError("invalid_value", "enabled must be true or false");
+                ctx.json(response, 200, { source: index.setEnabled(id, input["enabled"]) });
+                return true;
+            }
+            if (method === "DELETE") {
+                const forgotten = index.removeSource(id);
+                ctx.json(response, 200, { deleted: id, forgotten, filesTouched: 0 });
+                return true;
+            }
+            return fail(405, "method_not_allowed", "GET, PATCH or DELETE");
+        }
+        if (path === "/api/v1/library/queue" || path === "/api/v1/library/playlists" || path.startsWith("/api/v1/library/playlists/")) {
+            const listeners = ctx.listeners;
+            if (!listeners)
+                return fail(404, "not_found", "nothing here");
+            const who = ctx.principal;
+            if (who === null)
+                return fail(401, "sign_in_required", "sign in to nixamp.com to keep playlists and pick up where you left off");
+            const known = (id) => index.item(id) !== undefined;
+            const resolved = (ids) => ids.map((id) => {
+                const item = index.item(id);
+                return item ? itemView(item, ctx.canWrite) : { id, state: "unavailable" };
+            });
+            const playlistView = (one, withItems) => ({
+                id: one.id, name: one.name, count: one.items.length, revision: one.revision, createdAt: one.createdAt, updatedAt: one.updatedAt,
+                ...(withItems ? { items: resolved(one.items) } : {}),
+            });
+            const queueView = (queue) => ({ ...queue, items: resolved(queue.items), current: queue.items[queue.at] ?? null });
+            if (path === "/api/v1/library/queue") {
+                if (method === "GET") {
+                    ctx.json(response, 200, { queue: queueView(listeners.queueOf(who)) });
+                    return true;
+                }
+                if (method === "PUT" || method === "PATCH") {
+                    ctx.json(response, 200, { queue: queueView(listeners.setQueue(who, await body(), known)) });
+                    return true;
+                }
+                return fail(405, "method_not_allowed", "GET, PUT or PATCH");
+            }
+            if (path === "/api/v1/library/playlists") {
+                if (method === "GET") {
+                    ctx.json(response, 200, { playlists: listeners.playlistsOf(who).map((one) => playlistView(one, false)) });
+                    return true;
+                }
+                if (method === "POST") {
+                    ctx.json(response, 201, { playlist: playlistView(listeners.create(who, await body(), known), true) });
+                    return true;
+                }
+                return fail(405, "method_not_allowed", "GET or POST");
+            }
+            const playlistMatch = /^\/api\/v1\/library\/playlists\/([0-9a-f]{16})(?:\/(items))?$/.exec(path);
+            if (!playlistMatch)
+                return fail(404, "not_found", "no such playlist");
+            const id = playlistMatch[1];
+            if (playlistMatch[2] === "items") {
+                if (method !== "POST")
+                    return fail(405, "method_not_allowed", "POST");
+                ctx.json(response, 200, { playlist: playlistView(listeners.add(who, id, await body(), known), true) });
+                return true;
+            }
+            if (method === "GET") {
+                ctx.json(response, 200, { playlist: playlistView(listeners.playlist(who, id), true) });
+                return true;
+            }
+            if (method === "PATCH") {
+                ctx.json(response, 200, { playlist: playlistView(listeners.update(who, id, await body(), known), true) });
+                return true;
+            }
+            if (method === "DELETE") {
+                listeners.remove(who, id);
+                ctx.json(response, 200, { deleted: id });
+                return true;
+            }
+            return fail(405, "method_not_allowed", "GET, PATCH or DELETE");
+        }
+        const jobMatch = /^\/api\/v1\/library\/jobs\/([0-9a-f]{16})$/.exec(path);
+        if (jobMatch) {
+            const job = index.job(jobMatch[1]);
+            if (!job)
+                return fail(404, "not_found", "no such job (jobs are kept until the server restarts)");
+            ctx.json(response, 200, { job });
+            return true;
+        }
+        if (path === "/api/v1/library/items" && method === "GET") {
+            const state = text("state");
+            const sort = text("sort");
+            const query = {
+                q: text("q"), artist: text("artist"), album: text("album"), genre: text("genre"), folder: text("folder"), sourceId: text("source"),
+                ...(state && STATES.has(state) ? { state: state } : {}),
+                ...(sort && SORTS.has(sort) ? { sort: sort } : {}),
+                limit: number("limit"), offset: number("offset"),
+            };
+            const { items, total } = index.search(query);
+            ctx.json(response, 200, { items: items.map((one) => itemView(one, ctx.canWrite)), total, limit: Math.min(500, Math.max(1, query.limit ?? 50)), offset: Math.max(0, query.offset ?? 0) });
+            return true;
+        }
+        const browseMatch = /^\/api\/v1\/library\/browse\/([a-z]+)$/.exec(path);
+        if (browseMatch && method === "GET") {
+            const kind = browseMatch[1];
+            if (!KINDS.has(kind))
+                return fail(404, "not_found", "browse artists, albums, genres or folders");
+            ctx.json(response, 200, index.browse(kind, { q: text("q"), limit: number("limit"), offset: number("offset") }));
+            return true;
+        }
+        const itemMatch = /^\/api\/v1\/library\/items\/([0-9a-f]{16})(?:\/(stream))?$/.exec(path);
+        if (itemMatch) {
+            const item = index.item(itemMatch[1]);
+            if (!item)
+                return fail(404, "not_found", "no such item");
+            if (itemMatch[2] === "stream") {
+                if (method !== "GET" && method !== "HEAD")
+                    return fail(405, "method_not_allowed", "GET");
+                if (item.state !== "ready")
+                    return fail(409, "not_ready", `that item is ${item.state}`);
+                const source = index.source(item.sourceId);
+                if (!source?.enabled)
+                    return fail(409, "source_disabled", "that item's source is turned off");
+                // Private: a browser may keep it, a shared cache may not.
+                ctx.sendFile(request, response, item.path, "private, max-age=3600");
+                return true;
+            }
+            if (method === "GET") {
+                ctx.json(response, 200, { item: itemView(item, ctx.canWrite) });
+                return true;
+            }
+            if (method === "PATCH") {
+                if (!needWrite())
+                    return true;
+                const corrected = index.correct(item.id, await body());
+                if (corrected.state === "ready")
+                    ctx.retag([trackOf(corrected)]);
+                ctx.json(response, 200, { item: itemView(corrected, true) });
+                return true;
+            }
+            return fail(405, "method_not_allowed", "GET or PATCH");
+        }
+        return fail(404, "not_found", "nothing here");
+    }
+    catch (error) {
+        if (error instanceof LibraryError)
+            return fail(error.status, error.code, error.message);
+        if (error instanceof SyntaxError)
+            return fail(400, "bad_json", "the body is not JSON");
+        return fail(500, "internal", error instanceof Error ? error.message : String(error));
+    }
+}

package/dist/library-usage.d.ts

@@ -0,0 +1,3 @@
+/** `nixamp library` subcommands and usage, apart so help does not load the client. */
+export declare const LIBRARY_COMMANDS: Set<string>;
+export declare const LIBRARY_USAGE = "nixamp library \u2014 what this server has, indexed\n\n  nixamp library PATH                 the folder the daemon serves (set once)\n  nixamp library status               items by state, sources, last scans\n  nixamp library sources\n  nixamp library add PATH             index another folder (inside your home, not hidden)\n  nixamp library scan [SOURCE] [--force] [--wait]\n  nixamp library search WORDS [--artist A] [--album A] [--state failed] [--limit 20]\n  nixamp library show ITEM\n  nixamp library fix ITEM --title T [--artist A] [--album A] [--genre G] [--track N] [--year N]\n  nixamp library remove SOURCE        forget a folder; its files are not touched\n  nixamp library playlists\n  nixamp library playlist new NAME [ITEM...]\n  nixamp library playlist show|delete PLAYLIST\n  nixamp library playlist add PLAYLIST ITEM...\n\n  --json        machine-readable output\n  --url, --key  another server, as with `nixamp admin`";