nixamp 0.63.3 → 0.65.1

package/dist/server.js

@@ -124,6 +124,7 @@ import { StoredTranslations } from "./translate-jobs.js";
 import { Transcripts, fileFingerprint, formatOf, idFrom, languageCode, linesFrom, mediaOfLive, mediaOfUrl, toSrt, toText, toVtt, transcriptIdOf, wire, } from "./transcripts.js";
 import { handleMessage as mcpMessage } from "./mcp.js";
 import { PUBLIC_TOOLS, callPublicTool, isPublicTool } from "./directory-mcp.js";
+import { handleDiscovery, isDiscoveryPath, latestRelease } from "./discovery.js";
 import { Media, factsFromRequest, holderFrom, mediaId, openFileListing, openFileOf } from "./media.js";
 import { mediaPage } from "./media-page.js";
 import { describeFile, refreshChanged } from "./media-local.js";
@@ -196,7 +197,8 @@ export function parseServeArgs(argv) {
         tlsCert: process.env["NIXAMP_TLS_CERT"] ?? "",
         tlsKey: process.env["NIXAMP_TLS_KEY"] ?? "",
         x402: false,
-        owner: "",
+        // The account that administers this server, for one with no key but accounts (nixamp.com).
+        owner: process.env["NIXAMP_OWNER"] ?? "",
         ingest: false,
         rtmpIn: 0,
         rtmpStreams: 3,
@@ -1478,6 +1480,12 @@ async function readBytes(request, limit) {
 export function createHandler(engine, options) {
     // One per server, so the counters survive between requests and die with it.
     const guard = new Guard();
+    // --no-key opens a server to whoever reaches it, unless it has an owner: then
+    // anyone may listen and only the owner (or the control key) administers.
+    // nixamp.com is that server; without this every visitor was its admin.
+    const openToAll = (key) => key === null && !options.owner?.claimed;
+    // nixamp.com's /download asks GitHub which release is latest; one answer per ten minutes.
+    const release = latestRelease();
     const tracker = options.connections ?? new Connections();
     const started = Date.now();
     /** Count a request in, count its bytes, and close it out exactly once. */
@@ -1631,7 +1639,7 @@ export function createHandler(engine, options) {
                 cors: CORS,
                 watch: (incoming, outgoing, track) => watch(incoming, outgoing, "stream", track),
                 controls: async () => {
-                    if (key === null)
+                    if (openToAll(key))
                         return true;
                     if (scopeOf(keyFrom(request, url), key, null) === "control")
                         return true;
@@ -2333,6 +2341,8 @@ export function createHandler(engine, options) {
             !(/^\/radio\/(artist|album)\//.test(path) && Boolean(options.music)) &&
             // What is on, as MCP, for anybody.
             path !== "/mcp/public" &&
+            // llms.txt, the OpenAPI document, the health check and the desktop downloads (nixamp.com).
+            !(isDiscoveryPath(path) && Boolean(options.accounts && options.site)) &&
             // Supporting a copyright holder is for anybody listening.
             !/^\/support\/[a-z0-9-]{1,40}$/.test(path) && path !== "/support/cancel" && !/^\/api\/v1\/support\/[a-z0-9-]{1,40}$/.test(path) &&
             // A station's short link, which sends the browser to wherever it plays.
@@ -2394,7 +2404,7 @@ export function createHandler(engine, options) {
         // or the owner's nixamp.com session. Asked by the routes that do not go
         // through the admin gate further down.
         const controlOf = async () => {
-            if (key === null)
+            if (openToAll(key))
                 return { allowed: true, account: "" };
             if (scopeOf(keyFrom(request, url), key, listenKey) === "control")
                 return { allowed: true, account: "" };
@@ -3037,6 +3047,9 @@ export function createHandler(engine, options) {
             json(response, 200, { name: "nixamp", version: options.version, media: options.media });
             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;
         if (path === "/reset-password" && options.accounts?.passwordResets) {
             if (request.method !== "GET" && request.method !== "HEAD") {
                 json(response, 405, { error: "GET only" });
@@ -4813,10 +4826,10 @@ export function createHandler(engine, options) {
                 (request.method === "DELETE" && channelAction === undefined)) &&
             eventChannelRequest);
         if (options.owner && needsAdmin(path, request.method ?? "GET") && !eventMediaOperation) {
-            // A server started with --no-key has said that anyone who can reach the
-            // port may drive it, and prints exactly that. Locking administration to
-            // nobody would contradict it and leave such a server unadministrable.
-            const holdsControl = key === null || scopeOf(keyFrom(request, url), key, null) === "control";
+            // A server started with --no-key and no owner has said that anyone who
+            // can reach the port may drive it, and prints exactly that. With an owner
+            // (nixamp.com), --no-key only means anyone may listen: the owner drives.
+            const holdsControl = openToAll(key) || scopeOf(keyFrom(request, url), key, null) === "control";
             // A session in the query as well as in a header or a cookie: from
             // nixamp.com's page a server is another origin, and the cookie stays
             // home, so the session travels the way the key does.
@@ -4972,7 +4985,7 @@ export function createHandler(engine, options) {
             if (path === "/api/catalogs" && request.method === "GET") {
                 // Where a list is read from is the administrator's business, not a
                 // listener's: it can carry a provider's credentials in the URL.
-                const holdsControl = key === null || scopeOf(keyFrom(request, url), key, null) === "control";
+                const holdsControl = openToAll(key) || scopeOf(keyFrom(request, url), key, null) === "control";
                 const admin = options.owner
                     ? (await options.owner.check(holdsControl, tokenFrom(request.headers))).allowed
                     : holdsControl;
@@ -7246,6 +7259,24 @@ export async function serve(argv, version = "0.1.0") {
                 throw new Error((await answer.json().catch(() => ({}))).error ?? `nixamp.com answered ${answer.status}`);
             return Buffer.from(await answer.arrayBuffer());
         },
+        // A singer's close-up redrawn to the song's own seconds, by nixamp.com (fal.ai), under the same cap.
+        lipsync: async (input) => {
+            const session = readSession();
+            const here = stations.publicBase?.() ?? "";
+            if (!session?.token || !/^https:\/\//.test(here))
+                throw new VeoUnavailable("this server is not signed in to nixamp.com");
+            const answer = await fetch(`${session.site.replace(/\/+$/, "")}/api/v1/music/veo`, {
+                method: "POST",
+                headers: { "content-type": "application/json", authorization: `Bearer ${session.token}`, "x-nixamp-server": here },
+                body: JSON.stringify({ lipsync: true, seconds: input.seconds, video: input.video.toString("base64"), audio: input.audio.toString("base64") }),
+                signal: AbortSignal.timeout(15 * 60_000),
+            });
+            if (answer.status === 402)
+                throw new VeoUnavailable((await answer.json().catch(() => ({}))).error ?? `HTTP ${answer.status}`);
+            if (!answer.ok)
+                throw new Error((await answer.json().catch(() => ({}))).error ?? `nixamp.com answered ${answer.status}`);
+            return Buffer.from(await answer.arrayBuffer());
+        },
         // A release is told to nixamp.com as this server's owner; nixamp.com tells the artist's followers.
         announce: (release) => {
             const session = readSession();
@@ -7555,6 +7586,8 @@ export async function serve(argv, version = "0.1.0") {
         ledger: pool ? pgLedger(pool) : fileLedger(VeoStudio.fileFor(stateDir(), options.port)),
         monthlyUsd: Number(process.env["NIXAMP_VEO_MONTHLY_USD"] ?? 50),
         usdPerSecond: Number(process.env["NIXAMP_VEO_USD_PER_SECOND"] ?? 0.15),
+        ...(process.env["FAL_KEY"] ? { falKey: process.env["FAL_KEY"] } : {}),
+        lipsyncUsdPerSecond: Number(process.env["NIXAMP_LIPSYNC_USD_PER_SECOND"] ?? 0.1),
     }) : undefined;
     /** The signed-in account owns a server listed in the directory at this base. */
     const ownsListed = async (request, base) => {
@@ -7578,11 +7611,28 @@ export async function serve(argv, version = "0.1.0") {
         if (request.method !== "POST")
             return { status: 405, body: { error: "GET or POST" } };
         let input;
+        // A lip sync carries an 8 s 1080p shot and its seconds of the song: up to 48 MB as base64.
         try {
-            input = JSON.parse(await readBody(request, 2 * 1024 * 1024));
+            input = JSON.parse(await readBody(request, 48 * 1024 * 1024));
         }
         catch {
-            return { status: 400, body: { error: "a JSON body under 2 MB" } };
+            return { status: 400, body: { error: "a JSON body under 48 MB" } };
+        }
+        if (input.lipsync === true) {
+            if (!veoStudio.canLipsync)
+                return { status: 404, body: { error: "lip sync is not set up here" } };
+            const video = Buffer.from(String(input.video ?? ""), "base64");
+            const audio = Buffer.from(String(input.audio ?? ""), "base64");
+            if (video.length < 10_000 || audio.length < 1_000)
+                return { status: 400, body: { error: "a shot and its audio" } };
+            try {
+                return { status: 200, body: null, video: await veoStudio.lipsync({ video, audio, seconds: Number(input.seconds ?? 8) }) };
+            }
+            catch (error) {
+                if (error instanceof VeoBudgetError)
+                    return { status: 402, body: { error: error.message, code: "budget", ...(await veoStudio.status()) } };
+                return { status: 422, body: { error: error.message, code: "refused" } };
+            }
         }
         const prompt = String(input.prompt ?? "").trim();
         if (prompt.length < 20)
@@ -8399,7 +8449,10 @@ export async function serve(argv, version = "0.1.0") {
         console.log(`  Nothing outside reaches it until ${port} is forwarded here.`);
     }
     console.log("");
-    if (key === null) {
+    if (key === null && owner.claimed) {
+        console.log("  No key: anyone who can reach this port can hear it; only its owner can drive it.");
+    }
+    else if (key === null) {
         console.log("  No key: anyone who can reach this port can drive it and hear it.");
     }
     else {

package/dist/station-cli.js

@@ -540,6 +540,7 @@ async function labelCommand(argv, call, show) {
                 resetDay: number("--reset-day"),
                 veo: has(argv, "--veo") ? true : has(argv, "--no-veo") ? false : undefined,
                 veoShots: number("--veo-shots"),
+                lipsyncShots: number("--lipsync-shots"),
                 genreOrder: flag(argv, "--genres"),
                 enabled: has(argv, "--off") ? false : has(argv, "--on") ? true : undefined,
                 publish: has(argv, "--unlisted") ? false : has(argv, "--public") ? true : undefined,

package/dist/station-mcp.d.ts

@@ -52,6 +52,7 @@ export declare const STATION_TOOLS: ({
             resetDay?: undefined;
             veo?: undefined;
             veoShots?: undefined;
+            lipsyncShots?: undefined;
             genreOrder?: undefined;
             state?: undefined;
             reason?: undefined;
@@ -130,6 +131,7 @@ export declare const STATION_TOOLS: ({
             resetDay?: undefined;
             veo?: undefined;
             veoShots?: undefined;
+            lipsyncShots?: undefined;
             genreOrder?: undefined;
             state?: undefined;
             reason?: undefined;
@@ -231,6 +233,7 @@ export declare const STATION_TOOLS: ({
             resetDay?: undefined;
             veo?: undefined;
             veoShots?: undefined;
+            lipsyncShots?: undefined;
             genreOrder?: undefined;
             state?: undefined;
             reason?: undefined;
@@ -329,6 +332,7 @@ export declare const STATION_TOOLS: ({
             resetDay?: undefined;
             veo?: undefined;
             veoShots?: undefined;
+            lipsyncShots?: undefined;
             genreOrder?: undefined;
             state?: undefined;
             reason?: undefined;
@@ -409,6 +413,7 @@ export declare const STATION_TOOLS: ({
             resetDay?: undefined;
             veo?: undefined;
             veoShots?: undefined;
+            lipsyncShots?: undefined;
             genreOrder?: undefined;
             state?: undefined;
             reason?: undefined;
@@ -496,6 +501,7 @@ export declare const STATION_TOOLS: ({
             resetDay?: undefined;
             veo?: undefined;
             veoShots?: undefined;
+            lipsyncShots?: undefined;
             genreOrder?: undefined;
             state?: undefined;
             reason?: undefined;
@@ -583,6 +589,7 @@ export declare const STATION_TOOLS: ({
             resetDay?: undefined;
             veo?: undefined;
             veoShots?: undefined;
+            lipsyncShots?: undefined;
             genreOrder?: undefined;
             state?: undefined;
             reason?: undefined;
@@ -687,6 +694,7 @@ export declare const STATION_TOOLS: ({
             resetDay?: undefined;
             veo?: undefined;
             veoShots?: undefined;
+            lipsyncShots?: undefined;
             genreOrder?: undefined;
             state?: undefined;
             reason?: undefined;
@@ -817,6 +825,10 @@ export declare const STATION_TOOLS: ({
                 type: string;
                 description: string;
             };
+            lipsyncShots: {
+                type: string;
+                description: string;
+            };
             genreOrder: {
                 type: string;
                 items: {
@@ -890,6 +902,7 @@ export declare const STATION_TOOLS: ({
             resetDay?: undefined;
             veo?: undefined;
             veoShots?: undefined;
+            lipsyncShots?: undefined;
             genreOrder?: undefined;
             server: {
                 type: "string";
@@ -986,6 +999,7 @@ export declare const STATION_TOOLS: ({
             resetDay?: undefined;
             veo?: undefined;
             veoShots?: undefined;
+            lipsyncShots?: undefined;
             genreOrder?: undefined;
             state?: undefined;
             reason?: undefined;
@@ -1084,6 +1098,7 @@ export declare const STATION_TOOLS: ({
             resetDay?: undefined;
             veo?: undefined;
             veoShots?: undefined;
+            lipsyncShots?: undefined;
             genreOrder?: undefined;
             state?: undefined;
             reason?: undefined;

package/dist/station-mcp.js

@@ -123,7 +123,8 @@ export const STATION_TOOLS = [
                 newArtistChance: { type: "number", description: "0-1: how often the day's album is by a new artist." },
                 resetDay: { type: "integer", description: "Day of the month (1-28) the budget renews: the music provider's billing day." },
                 veo: { type: "boolean", description: "Each album's single gets filmed Veo shots of the band (nixamp.com's monthly Veo cap applies)." },
-                veoShots: { type: "integer", description: "8 s Veo shots per single (1-8)." },
+                veoShots: { type: "integer", description: "8 s Veo shots of the band per single (1-8); nobody sings in them." },
+                lipsyncShots: { type: "integer", description: "Close-ups of the singer per single, lip-synced to the song on nixamp.com (0-4; 0 = the band only)." },
                 genreOrder: { type: "array", items: STRING, description: "Genres whose artists get albums first, in order." },
             },
         },
@@ -243,7 +244,7 @@ export async function callStationTool(name, args, options = {}) {
             const key = typeof args["key"] === "string" && /^[a-f0-9]{10}$/.test(args["key"]) ? args["key"] : "";
             const answer = action === "status" ? await call("GET", "/api/v1/stations/label")
                 : action === "sign" ? await call("POST", "/api/v1/stations/label/artists", pick(["preset", "roster", "name", "genre", "sound", "voice", "bio", "themes", "enabled"]))
-                    : action === "configure" ? await call("POST", "/api/v1/stations/label", pick(["holder", "monthlySeconds", "everyDays", "seedAlbums", "songsPerAlbum", "songSeconds", "parallel", "genreOrder", "albumsPerDay", "newArtistChance", "resetDay", "veo", "veoShots", "enabled", "publish"]))
+                    : action === "configure" ? await call("POST", "/api/v1/stations/label", pick(["holder", "monthlySeconds", "everyDays", "seedAlbums", "songsPerAlbum", "songSeconds", "parallel", "genreOrder", "albumsPerDay", "newArtistChance", "resetDay", "veo", "veoShots", "lipsyncShots", "enabled", "publish"]))
                         : action === "run" ? await call("POST", "/api/v1/stations/label/run", {})
                             : action === "resume" ? await call("POST", "/api/v1/stations/label", { resume: true })
                                 : !key ? null

package/dist/veo-studio.d.ts

@@ -22,6 +22,10 @@ export interface VeoStudioOptions {
     ledger: VeoLedger;
     monthlyUsd?: number;
     usdPerSecond?: number;
+    /** fal.ai's key (FAL_KEY): a singer's close-up redrawn to the song's own vocal (Sync lipsync-2). Without it, no lip sync. */
+    falKey?: string;
+    /** What a second of lip sync is counted at under the same monthly cap; deliberately high ($0.10). */
+    lipsyncUsdPerSecond?: number;
     model?: string;
     fetcher?: typeof fetch;
     now?: () => number;
@@ -48,5 +52,17 @@ export declare class VeoStudio {
         seconds: number;
         references: Buffer[];
     }): Promise<Buffer>;
+    get canLipsync(): boolean;
+    /**
+     * A singer's close-up with the mouth redrawn to `audio` (the same seconds of
+     * the song): Sync's lipsync-2 on fal.ai. Veo's singers mouth a melody of their
+     * own; this makes them sing ours. Paid under the same monthly cap.
+     */
+    lipsync(input: {
+        video: Buffer;
+        audio: Buffer;
+        seconds: number;
+    }): Promise<Buffer>;
+    private sync;
     private make;
 }

package/dist/veo-studio.js

@@ -108,6 +108,65 @@ export class VeoStudio {
             throw error;
         }
     }
+    get canLipsync() { return Boolean(this.options.falKey); }
+    /**
+     * A singer's close-up with the mouth redrawn to `audio` (the same seconds of
+     * the song): Sync's lipsync-2 on fal.ai. Veo's singers mouth a melody of their
+     * own; this makes them sing ours. Paid under the same monthly cap.
+     */
+    async lipsync(input) {
+        const key = this.options.falKey;
+        if (!key)
+            throw new VeoRefused("lip sync is not set up here");
+        const cost = Math.max(1, Math.min(10, input.seconds)) * (this.options.lipsyncUsdPerSecond ?? 0.1);
+        const month = this.month();
+        if (!(await this.options.ledger.reserve(month, cost, this.cap)))
+            throw new VeoBudgetError(`this month's $${this.cap} of video is spent`);
+        try {
+            return await this.sync(key, input.video, input.audio);
+        }
+        catch (error) {
+            await this.options.ledger.refund(month, cost).catch(() => undefined);
+            throw error;
+        }
+    }
+    async sync(key, video, audio) {
+        const send = this.options.fetcher ?? fetch;
+        const auth = { authorization: `Key ${key}`, "content-type": "application/json" };
+        // fal.ai takes inputs by URL only (a data: URI is "invalid"): its own storage first.
+        const upload = async (bytes, type, name) => {
+            const init = await send("https://rest.alpha.fal.ai/storage/upload/initiate?storage_type=fal-cdn-v3", { method: "POST", headers: auth, body: JSON.stringify({ content_type: type, file_name: name }), signal: AbortSignal.timeout(30_000) });
+            const slot = await init.json().catch(() => ({}));
+            if (!slot.upload_url || !slot.file_url)
+                throw new VeoRefused(`fal.ai storage refused the upload (HTTP ${init.status})`);
+            const put = await send(slot.upload_url, { method: "PUT", headers: { "content-type": type }, body: new Uint8Array(bytes), signal: AbortSignal.timeout(120_000) });
+            if (!put.ok)
+                throw new VeoRefused(`fal.ai storage refused the upload (HTTP ${put.status})`);
+            return slot.file_url;
+        };
+        const [videoUrl, audioUrl] = await Promise.all([upload(video, "video/mp4", "shot.mp4"), upload(audio, "audio/mpeg", "vocal.mp3")]);
+        const started = await send("https://queue.fal.run/fal-ai/sync-lipsync/v2", { method: "POST", headers: auth, body: JSON.stringify({ video_url: videoUrl, audio_url: audioUrl }), signal: AbortSignal.timeout(60_000) });
+        const job = await started.json().catch(() => ({}));
+        if (!started.ok || !job.status_url || !job.response_url)
+            throw new VeoRefused(`fal.ai refused the lip sync: HTTP ${started.status}`);
+        const sleep = this.options.sleep ?? ((ms) => new Promise((done) => setTimeout(done, ms)));
+        for (let tries = 0; tries < 120; tries++) {
+            await sleep(5_000);
+            const state = await (await send(job.status_url, { headers: auth, signal: AbortSignal.timeout(30_000) })).json().catch(() => ({}));
+            if (state.status !== "COMPLETED")
+                continue;
+            const answer = await send(job.response_url, { headers: auth, signal: AbortSignal.timeout(30_000) });
+            const result = await answer.json().catch(() => ({}));
+            if (!answer.ok || !result.video?.url)
+                throw new VeoRefused(`the lip sync failed: ${result.detail?.[0]?.msg ?? `HTTP ${answer.status}`}`);
+            const out = await send(result.video.url, { signal: AbortSignal.timeout(120_000) });
+            const bytes = Buffer.from(await out.arrayBuffer());
+            if (!out.ok || bytes.length < 10_000)
+                throw new VeoRefused(`the lip-synced clip did not download (HTTP ${out.status})`);
+            return bytes;
+        }
+        throw new VeoRefused("the lip sync took too long (10 minutes)");
+    }
     async make(prompt, seconds, references) {
         const send = this.options.fetcher ?? fetch;
         const headers = { "x-goog-api-key": this.options.key, "content-type": "application/json" };

package/package.json

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