nixamp 0.36.4 → 0.37.1

package/dist/ai-keys.d.ts

@@ -0,0 +1,9 @@
+export declare const AI_KEY_NAMES: readonly ["ELEVENLABS_API_KEY", "GEMINI_API_KEY", "OPENAI_API_KEY", "ANTHROPIC_API_KEY"];
+export type AiKeyName = (typeof AI_KEY_NAMES)[number];
+export declare function aiKeysFile(): string;
+/** The key, from the environment or ai.json; "" when neither has it. */
+export declare function aiKey(name: AiKeyName, env?: Record<string, string | undefined>, file?: string): string;
+/** Which keys are set, never their values. */
+export declare function aiKeysSet(env?: Record<string, string | undefined>, file?: string): Record<AiKeyName, boolean>;
+/** Keep (or with "" forget) a key in ai.json. */
+export declare function saveAiKey(name: AiKeyName, value: string, file?: string): void;

package/dist/ai-keys.js

@@ -0,0 +1,46 @@
+/**
+ * The keys AI radio uses, and where they come from.
+ *
+ * The environment first, as everywhere else; then `ai.json` beside the
+ * server's own keys (0600), which `nixamp station ai key NAME` fills from
+ * stdin so a daemon restarted by `nixamp update` still has them. A key is
+ * never shown back: the owner view says which ones are set, not what they are.
+ */
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { stateDir } from "./daemon.js";
+export const AI_KEY_NAMES = ["ELEVENLABS_API_KEY", "GEMINI_API_KEY", "OPENAI_API_KEY", "ANTHROPIC_API_KEY"];
+export function aiKeysFile() {
+    return join(stateDir(), "ai.json");
+}
+function saved(file = aiKeysFile()) {
+    try {
+        const parsed = JSON.parse(readFileSync(file, "utf8"));
+        if (typeof parsed !== "object" || parsed === null)
+            return {};
+        return Object.fromEntries(Object.entries(parsed).filter((pair) => typeof pair[1] === "string"));
+    }
+    catch {
+        return {};
+    }
+}
+/** The key, from the environment or ai.json; "" when neither has it. */
+export function aiKey(name, env = process.env, file = aiKeysFile()) {
+    return (env[name] ?? "").trim() || (saved(file)[name] ?? "").trim();
+}
+/** Which keys are set, never their values. */
+export function aiKeysSet(env = process.env, file = aiKeysFile()) {
+    return Object.fromEntries(AI_KEY_NAMES.map((name) => [name, aiKey(name, env, file) !== ""]));
+}
+/** Keep (or with "" forget) a key in ai.json. */
+export function saveAiKey(name, value, file = aiKeysFile()) {
+    const next = saved(file);
+    if (value.trim())
+        next[name] = value.trim();
+    else
+        delete next[name];
+    mkdirSync(dirname(file), { recursive: true });
+    const temporary = `${file}.${process.pid}.tmp`;
+    writeFileSync(temporary, `${JSON.stringify(next, null, 2)}\n`, { mode: 0o600 });
+    renameSync(temporary, file);
+}

package/dist/ai-radio.d.ts

@@ -0,0 +1,148 @@
+import { askJson } from "./ai-text.ts";
+import type { LibraryIndex, Probed } from "./library-index.ts";
+import type { StationRunner } from "./station-runner.ts";
+import { type StationStore } from "./stations.ts";
+export interface AiTrack {
+    file: string;
+    title: string;
+    /** The brief the music model was given. */
+    prompt: string;
+    seconds: number;
+    /** Who wrote the brief and who composed it, e.g. "gemini-flash-latest + elevenlabs/music_v1". */
+    made: string;
+    createdAt: number;
+}
+export interface AiStation {
+    key: string;
+    name: string;
+    /** The owner's words for the music. Every brief starts from these. */
+    style: string;
+    description: string;
+    vocals: boolean;
+    /** Length of each track, 30-300 s. */
+    trackSeconds: number;
+    /** New tracks a day once the first few exist. */
+    perDay: number;
+    enabled: boolean;
+    /** Public, listed, basis owned, as soon as it has a track. */
+    publish: boolean;
+    /** The station it plays on; "" until the first track exists. */
+    stationId: string;
+    tracks: AiTrack[];
+    lastAttemptAt: number;
+    lastError: string;
+    /** Failures in a row; backs off after each. */
+    failures: number;
+    createdAt: number;
+}
+export interface Preset {
+    name: string;
+    style: string;
+    description: string;
+    vocals: boolean;
+}
+/** Styles to start from: `nixamp station ai create --preset lofi`. */
+export declare const PRESETS: Record<string, Preset>;
+export declare const DEFAULTS: {
+    trackSeconds: number;
+    perDay: number;
+    monthlySeconds: number;
+    seedTracks: number;
+};
+export interface Composer {
+    /** e.g. "elevenlabs/music_v1". */
+    name: string;
+    /** Writes an MP3 to `out`. Throws OutOfCredit when the account cannot pay. */
+    compose(input: {
+        prompt: string;
+        seconds: number;
+        vocals: boolean;
+        out: string;
+    }): Promise<void>;
+}
+export declare class OutOfCredit extends Error {
+}
+/** ElevenLabs Music: a paid plan's music may be broadcast. */
+export declare function elevenLabsComposer(key: string, fetcher?: typeof fetch): Composer;
+/**
+ * A model of the owner's own (MusicGen, ACE-Step...): NIXAMP_AI_MUSIC_COMMAND
+ * is run with {prompt}, {seconds}, {vocals} and {out} replaced, each as one
+ * argument, and must leave an MP3 at {out}.
+ */
+export declare function commandComposer(template: string): Composer;
+/** The composer this server can use, or null with the reason. */
+export declare function composerFromEnv(env?: Record<string, string | undefined>): Composer | null;
+/** A brief without a language model: the style, with a mood and a name drawn for it. */
+export declare function plainBrief(station: Pick<AiStation, "style" | "tracks">, random?: () => number): {
+    title: string;
+    prompt: string;
+};
+export declare function writeBrief(station: Pick<AiStation, "name" | "style" | "vocals" | "tracks">, ask?: typeof askJson): Promise<{
+    title: string;
+    prompt: string;
+    model: string;
+}>;
+export interface AiRadioDeps {
+    index: LibraryIndex;
+    store: StationStore;
+    runner: StationRunner;
+    probe: (path: string) => Promise<Probed>;
+    /** ffmpeg argv prefix, for the tags. */
+    ffmpeg: string[];
+    /** The folder the music goes in: a managed library source. */
+    root: string;
+    owner: string;
+    /** Whether another station may be started now (the server's running limit). */
+    mayStart: () => boolean;
+    composer?: () => Composer | null;
+    /** Writes `from` with these tags to `to`; ffmpeg's stream copy by default. */
+    tag?: (from: string, to: string, tags: Record<string, string>) => Promise<void>;
+    ask?: typeof askJson;
+    canAsk?: () => boolean;
+    now?: () => number;
+    log?: (line: string) => void;
+}
+export interface AiRadioSettings {
+    /** Seconds of music a month across every AI station; 0 for no cap. */
+    monthlySeconds: number;
+    /** Set by a provider that is out of credit; cleared by `resume`. */
+    pausedReason: string;
+}
+export declare class AiRadio {
+    private readonly file;
+    private readonly deps;
+    private stations;
+    private settings;
+    private usage;
+    private busy;
+    private sourceId;
+    private timer;
+    constructor(file: string, deps: AiRadioDeps);
+    static fileFor(stateDir: string, port: number): string;
+    private now;
+    private save;
+    private source;
+    private composer;
+    list(): AiStation[];
+    get(key: string): AiStation | undefined;
+    /** What the owner sees: the stations, this month's seconds, and why nothing is being made. */
+    status(): Record<string, unknown>;
+    /** Change the month's cap; `resume` clears a stop for lack of credit. */
+    configure(input: Record<string, unknown>): AiRadioSettings;
+    create(input: Record<string, unknown>): AiStation;
+    update(key: string, input: Record<string, unknown>): AiStation;
+    /** Forget an AI station. Its music and its station stay unless `files` is true. */
+    remove(key: string, files?: boolean): void;
+    /** When this station's next track is due; 0 when now, -1 when never. */
+    nextAt(station: AiStation): number;
+    /** Every 5 minutes: the station most overdue gets its next track. One at a time. */
+    startSchedule(everyMs?: number): void;
+    stopSchedule(): void;
+    private budgetLeft;
+    tick(): Promise<void>;
+    /** Compose one track for this station now (the owner's "generate"), within the month's cap. */
+    generate(key: string): Promise<AiTrack>;
+    /** The station gets its tracks: made with the first one, then kept in step. */
+    private place;
+    private require;
+}