nixamp 0.68.2 → 0.69.0

package/dist/school-discovery.js

@@ -0,0 +1,204 @@
+import { SCHOOL_PUBLIC_TOOLS, SCHOOL_TOOLS, callSchoolTool, isSchoolPublicTool, isSchoolTool } from "./school-mcp.js";
+import { SCHOOL_SITE } from "./school-client.js";
+const CORS = {
+    "access-control-allow-origin": "*",
+    "access-control-allow-methods": "GET, POST, DELETE, OPTIONS",
+    "access-control-allow-headers": "authorization, content-type, mcp-session-id, mcp-protocol-version",
+};
+const PATHS = new Set(["/llms.txt", "/openapi.json", "/mcp", "/mcp/public", "/.well-known/oauth-protected-resource"]);
+/** Is this host the school? backtoschool.help (or NIXAMP_SCHOOL_URL), with or without www. */
+export function isSchoolSite(site, env = process.env) {
+    if (!site)
+        return false;
+    const bare = (value) => new URL(value).hostname.replace(/^www\./, "");
+    try {
+        return bare(site) === bare(env["NIXAMP_SCHOOL_URL"] ?? SCHOOL_SITE);
+    }
+    catch {
+        return false;
+    }
+}
+export function schoolLlmsTxt(site, accountSite) {
+    return `# BackToSchool.help
+
+> Live classes anybody can teach and anybody can join: a broadcast (a nixamp station, a screen share, a video link) with chat and raised hands around it. Free to watch. Accounts are nixamp accounts.
+
+## Web
+- ${site}/ : classes live now and coming up
+- ${site}/live/<slug> : one class
+
+## MCP
+- Public, no account (what is on, one class): ${site}/mcp/public
+- Signed in (teach, start, end, delete, check your classes): ${site}/mcp , a nixamp token as the bearer (\`nixamp token create\`) or OAuth via ${accountSite}
+- Local over stdio: npx -y nixamp mcp (the class tools are among nixamp's)
+
+Tools: classes_list, class_get, class_teach (a broadcast link in, a live class out), class_create, class_update, class_start, class_end, class_delete, classes_check (which of your live classes no longer play).
+
+## CLI
+- Install: curl -fsSL ${accountSite}/install.sh | sh   (or npx -y nixamp)
+- Sign in: nixamp login
+- nixamp school list --status live
+- nixamp school teach <station link> --title "..."   make a class and start it
+- nixamp school check | prune --end                 find and end classes whose broadcast stopped
+- nixamp school help
+
+## API
+- OpenAPI: ${site}/openapi.json
+- GET ${site}/api/v1/events?status=live : classes (public ones; ?mine=true with a token)
+- GET ${site}/api/v1/events/<slug> : one class
+- POST ${site}/api/v1/events : make one {title, broadcastUrl, description, topic, visibility, startsAt}
+- POST ${site}/api/v1/events/<slug>/start|end {version} : the version you last read
+- PATCH ${site}/api/v1/events/<slug> {..., version}, DELETE ${site}/api/v1/events/<slug>
+- Auth: Authorization: Bearer <nixamp token>
+
+## What a broadcast can be
+A nixamp station link (https://<server>.nixamp.com:4321/station/<id>?t=<token>), a nixamp.com share link, a Pairux room, or a direct https .m3u8/.mp4/.mp3. Only broadcast what you have the right to: your own teaching, or openly licensed courses (MIT OpenCourseWare is CC BY-NC-SA: free, credited, no ads).
+`;
+}
+export function schoolOpenapi(site, accountSite, version) {
+    const ok = { description: "OK", content: { "application/json": { schema: { type: "object" } } } };
+    const auth = { security: [{ bearer: [] }] };
+    const slug = [{ name: "slug", in: "path", required: true, schema: { type: "string" }, description: "The class's slug or id." }];
+    const versioned = { content: { "application/json": { schema: { type: "object", properties: { version: { type: "integer" } }, required: ["version"] } } } };
+    const fields = {
+        title: { type: "string", maxLength: 160 }, description: { type: "string", maxLength: 5000 }, topic: { type: "string", maxLength: 100 },
+        broadcastUrl: { type: "string", format: "uri" }, visibility: { type: "string", enum: ["public", "unlisted", "private"] },
+        startsAt: { type: "string", format: "date-time" }, chatEnabled: { type: "boolean" }, handRaiseEnabled: { type: "boolean" },
+    };
+    return {
+        openapi: "3.1.0",
+        info: { title: "BackToSchool.help", version, description: "Live classes. Reading is open; teaching wants a nixamp token as the bearer.", license: { name: "MIT", identifier: "MIT" } },
+        servers: [{ url: site }],
+        externalDocs: { description: "llms.txt: MCP, CLI and API in one place", url: `${site}/llms.txt` },
+        components: { securitySchemes: { bearer: { type: "http", scheme: "bearer", description: `A nixamp token (\`nixamp token create\`) or an OAuth access token from ${accountSite}.` } } },
+        paths: {
+            "/api/v1/events": {
+                get: {
+                    summary: "Classes", tags: ["classes"], responses: { 200: ok },
+                    parameters: [
+                        { name: "status", in: "query", schema: { type: "string", enum: ["draft", "scheduled", "starting", "live", "encore", "ended", "cancelled", "archived"] } },
+                        { name: "mine", in: "query", schema: { type: "boolean" }, description: "Only yours (needs the bearer)." },
+                        { name: "limit", in: "query", schema: { type: "integer", maximum: 100 } },
+                    ],
+                },
+                post: { summary: "Make a class (a draft; start it to go live)", tags: ["classes"], ...auth, requestBody: { content: { "application/json": { schema: { type: "object", properties: { kind: { type: "string", enum: ["class", "talk", "concert"] }, ...fields }, required: ["title"] } } } }, responses: { 200: ok } },
+            },
+            "/api/v1/events/{slug}": {
+                parameters: slug,
+                get: { summary: "One class", tags: ["classes"], responses: { 200: ok } },
+                patch: { summary: "Change a class you host", tags: ["classes"], ...auth, requestBody: { content: { "application/json": { schema: { type: "object", properties: { ...fields, version: { type: "integer" } }, required: ["version"] } } } }, responses: { 200: ok } },
+                delete: { summary: "Delete a class you host", tags: ["classes"], ...auth, responses: { 200: ok } },
+            },
+            "/api/v1/events/{slug}/start": { parameters: slug, post: { summary: "Go live", tags: ["classes"], ...auth, requestBody: versioned, responses: { 200: ok } } },
+            "/api/v1/events/{slug}/end": { parameters: slug, post: { summary: "End it", tags: ["classes"], ...auth, requestBody: versioned, responses: { 200: ok } } },
+            "/api/v1/events/{slug}/chat": { parameters: slug, get: { summary: "The class chat", tags: ["chat"], responses: { 200: ok } }, post: { summary: "Say something", tags: ["chat"], ...auth, responses: { 200: ok } } },
+            "/api/v1/auth/me": { get: { summary: "Who the bearer is", tags: ["auth"], ...auth, responses: { 200: ok } } },
+            "/mcp/public": { post: { summary: "MCP (streamable HTTP, JSON-RPC): classes_list, class_get", tags: ["mcp"], responses: { 200: ok } } },
+            "/mcp": { post: { summary: "MCP (streamable HTTP, JSON-RPC): every class tool, as the bearer", tags: ["mcp"], ...auth, responses: { 200: ok } } },
+        },
+    };
+}
+export async function handleSchoolDiscovery(request, response, path, ctx) {
+    if (!PATHS.has(path))
+        return false;
+    const method = request.method ?? "GET";
+    const site = ctx.site.replace(/\/+$/, "");
+    if (method === "OPTIONS") {
+        response.writeHead(204, CORS);
+        response.end();
+        return true;
+    }
+    if (path === "/llms.txt" || path === "/openapi.json" || path === "/.well-known/oauth-protected-resource") {
+        if (method !== "GET" && method !== "HEAD") {
+            ctx.json(response, 405, { error: "GET only" });
+            return true;
+        }
+        const [type, body] = path === "/llms.txt"
+            ? ["text/plain; charset=utf-8", schoolLlmsTxt(site, ctx.accountSite)]
+            : ["application/json; charset=utf-8", JSON.stringify(path === "/openapi.json"
+                    ? schoolOpenapi(site, ctx.accountSite, ctx.version)
+                    : { resource: site, authorization_servers: [ctx.accountSite], bearer_methods_supported: ["header"], resource_name: "BackToSchool.help" }, null, 2)];
+        response.writeHead(200, { ...CORS, "content-type": type, "cache-control": "public, max-age=300" });
+        response.end(method === "HEAD" ? undefined : body);
+        return true;
+    }
+    // MCP. GET has nothing to push; DELETE ends a session nobody keeps.
+    if (method === "GET") {
+        response.writeHead(405, { ...CORS, allow: "POST, DELETE" });
+        response.end();
+        return true;
+    }
+    if (method === "DELETE") {
+        response.writeHead(204, CORS);
+        response.end();
+        return true;
+    }
+    if (method !== "POST") {
+        ctx.json(response, 405, { error: "POST a JSON-RPC message" });
+        return true;
+    }
+    const signed = path === "/mcp";
+    if (signed && (await ctx.whoIs(ctx.token)) === null) {
+        const error = JSON.stringify({ error: "sign in: a nixamp token as the bearer (`nixamp token create`), or OAuth" });
+        response.writeHead(401, {
+            ...CORS,
+            "content-type": "application/json; charset=utf-8",
+            "www-authenticate": `Bearer resource_metadata="${site}/.well-known/oauth-protected-resource"`,
+        });
+        response.end(error);
+        return true;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(await ctx.readBody(request, 256 * 1024));
+    }
+    catch {
+        ctx.json(response, 400, { jsonrpc: "2.0", id: null, error: { code: -32700, message: "parse error" } });
+        return true;
+    }
+    const tools = signed ? SCHOOL_TOOLS : SCHOOL_PUBLIC_TOOLS;
+    const allowed = signed ? isSchoolTool : isSchoolPublicTool;
+    const answers = [];
+    for (const message of (Array.isArray(parsed) ? parsed : [parsed])) {
+        const id = message?.id ?? null;
+        const name = typeof message?.method === "string" ? message.method : "";
+        if (name.startsWith("notifications/"))
+            continue;
+        if (name === "initialize") {
+            answers.push({ jsonrpc: "2.0", id, result: {
+                    protocolVersion: message.params?.["protocolVersion"] ?? "2025-06-18",
+                    capabilities: { tools: { listChanged: false } },
+                    serverInfo: { name: "backtoschool", title: "BackToSchool.help: live classes", version: "1" },
+                    instructions: signed
+                        ? "Live classes on BackToSchool.help. classes_list / class_get to see what is on; class_teach puts a broadcast (a nixamp station link, a Pairux room, an https video) on the air as a class in one call; classes_check finds your live classes whose broadcast stopped, and class_end / class_delete clear them. Only broadcast what you have the right to."
+                        : "Live classes on BackToSchool.help: classes_list and class_get. To teach, use /mcp with a nixamp token as the bearer.",
+                } });
+        }
+        else if (name === "ping") {
+            answers.push({ jsonrpc: "2.0", id, result: {} });
+        }
+        else if (name === "tools/list") {
+            answers.push({ jsonrpc: "2.0", id, result: { tools } });
+        }
+        else if (name === "tools/call" && allowed(String(message.params?.["name"] ?? ""))) {
+            const result = await callSchoolTool(String(message.params["name"]), (message.params?.["arguments"] ?? {}), {
+                site, token: ctx.token || null, ...(ctx.fetcher ? { fetcher: ctx.fetcher } : {}),
+            });
+            answers.push({ jsonrpc: "2.0", id, result });
+        }
+        else if (name === "tools/call") {
+            answers.push({ jsonrpc: "2.0", id, error: { code: -32001, message: "only classes_list and class_get are public; for the rest use /mcp with a nixamp token as the bearer (`nixamp token create`), or OAuth" } });
+        }
+        else {
+            answers.push({ jsonrpc: "2.0", id, error: { code: -32601, message: `no method ${name}` } });
+        }
+    }
+    if (answers.length === 0) {
+        response.writeHead(202, CORS);
+        response.end();
+        return true;
+    }
+    response.writeHead(200, { ...CORS, "content-type": "application/json; charset=utf-8" });
+    response.end(JSON.stringify(Array.isArray(parsed) ? answers : answers[0]));
+    return true;
+}

package/dist/school-mcp.d.ts

@@ -0,0 +1,180 @@
+/**
+ * backtoschool.help classes as MCP tools: what `nixamp school` does, for an agent.
+ *
+ * Reading what is on needs nobody; making, starting, ending and deleting a
+ * class needs the token the rest of nixamp uses, because a class is a live
+ * event on the same accounts. `class_teach` is the one-call path from a
+ * station link (station_list / station_create) to a class on the air.
+ */
+import { type SchoolOptions } from "./school-client.ts";
+export declare const SCHOOL_PUBLIC_TOOLS: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            status: {
+                type: string;
+                enum: string[];
+            };
+            mine: {
+                type: string;
+                description: string;
+            };
+            limit: {
+                type: string;
+            };
+            slug?: undefined;
+        };
+        required?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            status?: undefined;
+            mine?: undefined;
+            limit?: undefined;
+            slug: {
+                type: "string";
+                description: string;
+            };
+        };
+        required: string[];
+    };
+})[];
+export declare const SCHOOL_TOOLS: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            status: {
+                type: string;
+                enum: string[];
+            };
+            mine: {
+                type: string;
+                description: string;
+            };
+            limit: {
+                type: string;
+            };
+            slug?: undefined;
+        };
+        required?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            status?: undefined;
+            mine?: undefined;
+            limit?: undefined;
+            slug: {
+                type: "string";
+                description: string;
+            };
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            title: {
+                readonly type: "string";
+            };
+            description: {
+                readonly type: "string";
+            };
+            topic: {
+                readonly type: "string";
+            };
+            visibility: {
+                readonly type: "string";
+                readonly enum: readonly ["public", "unlisted", "private"];
+            };
+            startsAt: {
+                readonly type: "string";
+                readonly description: "ISO 8601; leave out to start now (class_teach) or keep it a draft (class_create).";
+            };
+            chatEnabled: {
+                readonly type: "boolean";
+            };
+            handRaiseEnabled: {
+                readonly type: "boolean";
+            };
+            broadcastUrl: {
+                type: "string";
+                description: string;
+            };
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            title: {
+                readonly type: "string";
+            };
+            description: {
+                readonly type: "string";
+            };
+            topic: {
+                readonly type: "string";
+            };
+            visibility: {
+                readonly type: "string";
+                readonly enum: readonly ["public", "unlisted", "private"];
+            };
+            startsAt: {
+                readonly type: "string";
+                readonly description: "ISO 8601; leave out to start now (class_teach) or keep it a draft (class_create).";
+            };
+            chatEnabled: {
+                readonly type: "boolean";
+            };
+            handRaiseEnabled: {
+                readonly type: "boolean";
+            };
+            slug: {
+                type: "string";
+                description: string;
+            };
+            broadcastUrl: {
+                type: "string";
+                description: string;
+            };
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        required?: undefined;
+        type: string;
+        properties: {};
+    };
+})[];
+export declare function isSchoolTool(name: string): boolean;
+export declare function isSchoolPublicTool(name: string): boolean;
+type Result = {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError?: boolean;
+};
+export declare function callSchoolTool(name: string, args: Record<string, unknown>, options?: SchoolOptions): Promise<Result>;
+export {};

package/dist/school-mcp.js

@@ -0,0 +1,143 @@
+/**
+ * backtoschool.help classes as MCP tools: what `nixamp school` does, for an agent.
+ *
+ * Reading what is on needs nobody; making, starting, ending and deleting a
+ * class needs the token the rest of nixamp uses, because a class is a live
+ * event on the same accounts. `class_teach` is the one-call path from a
+ * station link (station_list / station_create) to a class on the air.
+ */
+import { broadcastHealth, checkClasses, classUrl, createClass, deleteClass, getClass, listClasses, moveClass, teach, updateClass, } from "./school-client.js";
+const STRING = { type: "string" };
+const SLUG = { ...STRING, description: "The class's slug, id, or its backtoschool.help/live/<slug> link." };
+const BROADCAST = { ...STRING, description: "What plays: a nixamp station link (https://<server>.nixamp.com:4321/station/<id>?t=<token>), a nixamp.com share link, a Pairux room, or an https .m3u8/.mp4/.mp3 URL." };
+const FIELDS = {
+    title: STRING,
+    description: STRING,
+    topic: STRING,
+    visibility: { type: "string", enum: ["public", "unlisted", "private"] },
+    startsAt: { ...STRING, description: "ISO 8601; leave out to start now (class_teach) or keep it a draft (class_create)." },
+    chatEnabled: { type: "boolean" },
+    handRaiseEnabled: { type: "boolean" },
+};
+export const SCHOOL_PUBLIC_TOOLS = [
+    {
+        name: "classes_list",
+        description: "Classes on backtoschool.help: live now, scheduled, drafts or ended. Each with its link, status and what it broadcasts. No sign-in needed (mine=true needs one).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                status: { type: "string", enum: ["draft", "scheduled", "starting", "live", "encore", "ended", "cancelled", "archived"] },
+                mine: { type: "boolean", description: "Only the classes this account hosts." },
+                limit: { type: "integer" },
+            },
+        },
+    },
+    {
+        name: "class_get",
+        description: "One class in full, and whether its broadcast is playing right now.",
+        inputSchema: { type: "object", properties: { slug: SLUG }, required: ["slug"] },
+    },
+];
+export const SCHOOL_TOOLS = [
+    ...SCHOOL_PUBLIC_TOOLS,
+    {
+        name: "class_teach",
+        description: "Make a class of a broadcast and put it on the air now: the one call from a station link to a live class. Returns the class link.",
+        inputSchema: { type: "object", properties: { broadcastUrl: BROADCAST, ...FIELDS }, required: ["title", "broadcastUrl"] },
+    },
+    {
+        name: "class_create",
+        description: "Make a class without starting it: a draft, or scheduled when startsAt is given.",
+        inputSchema: { type: "object", properties: { broadcastUrl: BROADCAST, ...FIELDS }, required: ["title"] },
+    },
+    {
+        name: "class_update",
+        description: "Change a class you host: title, description, topic, broadcast, visibility, time, chat or raised hands.",
+        inputSchema: { type: "object", properties: { slug: SLUG, broadcastUrl: BROADCAST, ...FIELDS }, required: ["slug"] },
+    },
+    {
+        name: "class_start",
+        description: "Put a class you host on the air.",
+        inputSchema: { type: "object", properties: { slug: SLUG }, required: ["slug"] },
+    },
+    {
+        name: "class_end",
+        description: "End a class you host. It stays listed as ended; a repeating class schedules its next session.",
+        inputSchema: { type: "object", properties: { slug: SLUG }, required: ["slug"] },
+    },
+    {
+        name: "class_delete",
+        description: "Delete a class you host, for good.",
+        inputSchema: { type: "object", properties: { slug: SLUG }, required: ["slug"] },
+    },
+    {
+        name: "classes_check",
+        description: "Your live classes, each with whether its broadcast still plays. A class stays live until ended, so this finds the ones showing a dead player; end or delete those.",
+        inputSchema: { type: "object", properties: {} },
+    },
+];
+export function isSchoolTool(name) {
+    return SCHOOL_TOOLS.some((tool) => tool.name === name);
+}
+export function isSchoolPublicTool(name) {
+    return SCHOOL_PUBLIC_TOOLS.some((tool) => tool.name === name);
+}
+const say = (text, isError = false) => ({ content: [{ type: "text", text }], ...(isError ? { isError: true } : {}) });
+function line(item, options) {
+    return `${item.status.padEnd(9)} ${item.title}\n  ${classUrl(item, options)}${item.broadcastUrl ? `\n  plays ${item.broadcastUrl}` : ""}`;
+}
+function fieldsOf(args) {
+    const keys = ["title", "description", "topic", "visibility", "startsAt", "chatEnabled", "handRaiseEnabled", "broadcastUrl"];
+    return Object.fromEntries(keys.filter((key) => args[key] !== undefined).map((key) => [key, args[key]]));
+}
+export async function callSchoolTool(name, args, options = {}) {
+    const slug = typeof args["slug"] === "string" ? args["slug"] : "";
+    try {
+        if (name === "classes_list") {
+            const items = await listClasses({
+                ...(typeof args["status"] === "string" ? { status: args["status"] } : {}),
+                ...(args["mine"] === true ? { mine: true } : {}),
+                ...(typeof args["limit"] === "number" ? { limit: args["limit"] } : {}),
+            }, options);
+            return say(items.length ? items.map((one) => line(one, options)).join("\n\n") : "No classes match.");
+        }
+        if (name === "classes_check") {
+            const checked = await checkClasses(options);
+            if (checked.length === 0)
+                return say("You have no live classes.");
+            return say(checked.map(({ item, health }) => `${health.ok === true ? "plays " : health.ok === false ? "BROKEN" : "unknown"}  ${item.slug}: ${health.reason}`).join("\n"));
+        }
+        if (!slug && name !== "class_teach" && name !== "class_create")
+            return say("Which class? Pass its slug (classes_list).", true);
+        if (name === "class_get") {
+            const item = await getClass(slug, options);
+            const health = await broadcastHealth(item.broadcastUrl, options.fetcher ?? fetch);
+            return say(`${JSON.stringify(item, null, 2)}\n\nbroadcast: ${health.ok === true ? "playing" : health.ok === false ? "NOT playing" : "unknown"} (${health.reason})`);
+        }
+        if (name === "class_teach") {
+            const item = await teach(fieldsOf(args), options);
+            return say(`On the air: ${classUrl(item, options)}`);
+        }
+        if (name === "class_create") {
+            const item = await createClass(fieldsOf(args), options);
+            return say(`Made (${item.status}): ${classUrl(item, options)}\nclass_start ${item.slug} puts it on the air.`);
+        }
+        if (name === "class_update") {
+            const { slug: _slug, ...rest } = args;
+            const item = await updateClass(slug, fieldsOf(rest), options);
+            return say(line(item, options));
+        }
+        if (name === "class_start" || name === "class_end") {
+            const item = await moveClass(slug, name === "class_start" ? "start" : "end", options);
+            return say(line(item, options));
+        }
+        if (name === "class_delete") {
+            await deleteClass(slug, options);
+            return say(`Deleted ${slug}.`);
+        }
+    }
+    catch (error) {
+        return say(error.message, true);
+    }
+    return say(`No such tool: ${name}`, true);
+}

package/dist/server.js

@@ -30,6 +30,7 @@ import { Ingest, normaliseFormat } from "./ingest.js";
 import { BACKLOG_SECONDS, Channels, cleanId, generatedId, rememberChannels, rememberedChannels, rememberedNow, } from "./channels.js";
 import { RtmpListeners } from "./rtmp-in.js";
 import { Accounts, clearedCookie, sessionCookie, tokenFrom } from "./accounts.js";
+import { handleSchoolDiscovery, isSchoolSite } from "./school-discovery.js";
 import { RESET_INVALID, RESET_MESSAGE, resendPasswordReset } from "./password-reset.js";
 import { passwordResetPage } from "./password-reset-page.js";
 import { anonymousHandle, Handles } from "./handles.js";
@@ -3113,6 +3114,15 @@ export function createHandler(engine, options) {
             json(response, 200, { name: "nixamp", version: options.version, media: options.media });
             return;
         }
+        // backtoschool.help's own llms.txt, OpenAPI and class MCP, ahead of nixamp's (school-discovery.ts).
+        if (options.accounts && webSite && isSchoolSite(webSite.site)) {
+            const accounts = options.accounts;
+            if (await handleSchoolDiscovery(request, response, path, {
+                site: webSite.site, accountSite: options.site ?? "https://nixamp.com", version: options.version,
+                whoIs: (token) => accounts.whoIs(token), token: tokenFrom(request.headers), readBody, json,
+            }))
+                return;
+        }
         // Every way into nixamp, for agents and stores: llms.txt, OpenAPI, health, desktop downloads (discovery.ts).
         if (options.accounts && options.site && await handleDiscovery(request, response, path, { site: options.site, version: options.version, release, json }))
             return;

package/dist/station-mcp.d.ts

@@ -2,6 +2,7 @@ export declare const STATION_TOOLS: ({
     name: string;
     description: string;
     inputSchema: {
+        required?: undefined;
         type: string;
         properties: {
             server: {
@@ -72,7 +73,6 @@ export declare const STATION_TOOLS: ({
             id?: undefined;
             private?: undefined;
         };
-        required?: undefined;
     };
 } | {
     name: string;
@@ -531,6 +531,7 @@ export declare const STATION_TOOLS: ({
     name: string;
     description: string;
     inputSchema: {
+        required?: undefined;
         type: string;
         properties: {
             playlist?: undefined;
@@ -615,12 +616,12 @@ export declare const STATION_TOOLS: ({
             id?: undefined;
             private?: undefined;
         };
-        required?: undefined;
     };
 } | {
     name: string;
     description: string;
     inputSchema: {
+        required?: undefined;
         type: string;
         properties: {
             playlist?: undefined;
@@ -718,12 +719,12 @@ export declare const STATION_TOOLS: ({
             id?: undefined;
             private?: undefined;
         };
-        required?: undefined;
     };
 } | {
     name: string;
     description: string;
     inputSchema: {
+        required?: undefined;
         type: string;
         properties: {
             playlist?: undefined;
@@ -862,12 +863,12 @@ export declare const STATION_TOOLS: ({
             id?: undefined;
             private?: undefined;
         };
-        required?: undefined;
     };
 } | {
     name: string;
     description: string;
     inputSchema: {
+        required?: undefined;
         type: string;
         properties: {
             playlist?: undefined;
@@ -960,12 +961,12 @@ export declare const STATION_TOOLS: ({
             license?: undefined;
             private?: undefined;
         };
-        required?: undefined;
     };
 } | {
     name: string;
     description: string;
     inputSchema: {
+        required?: undefined;
         type: string;
         properties: {
             playlist?: undefined;
@@ -1060,7 +1061,6 @@ export declare const STATION_TOOLS: ({
             };
             private?: undefined;
         };
-        required?: undefined;
     };
 } | {
     name: string;

package/package.json

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