@gentbajko/slopify 0.6.1 → 0.7.0

package/dist/edge/http/providers.js

@@ -4,6 +4,7 @@ import { z } from "zod";
 import { cliPathMaxLength, saveCliPath } from "../../slices/settings/cli-paths.js";
 import { keyStatus, removeProviderKey, saveProviderKey } from "../../slices/settings/keys.js";
 import { providerById, providerIds } from "../../slices/settings/model.js";
+import { createModelCatalog } from "../../slices/settings/models.js";
 import { providerStatuses } from "../../slices/settings/readiness.js";
 import { onInvalid, problem, titleOf } from "./problem.js";
 const providerParam = z.object({ id: z.enum(providerIds) });
@@ -17,10 +18,22 @@ const keyBody = z.object({ key: z.string().min(1).max(4096) });
 export function providerRoutes(deps) {
     const keys = { db: deps.db, clock: deps.clock };
     const readiness = { db: deps.db, probe: deps.probe };
+    const catalog = createModelCatalog({
+        load: deps.modelsFor ?? (() => Promise.reject(new Error("Model catalog unavailable"))),
+        fallback: deps.fallbackModelsFor ?? (() => []),
+        now: () => deps.clock.now().getTime(),
+        report: (provider) => deps.log.write("warn", "model-catalog", { detail: `Could not load models for ${provider}` }),
+    });
     return (new Hono()
         // What Settings draws its rails from and Play its dropdowns: every provider, with
         // the one fact that decides whether it is selectable.
         .get("/", async (c) => c.json({ providers: await providerStatuses(readiness) }))
+        .get("/:id/models", zValidator("param", providerParam, onInvalid), async (c) => {
+        const { id } = c.req.valid("param");
+        const result = await catalog.get(id, providerById(id).family, c.req.query("refresh") === "1");
+        c.header("Cache-Control", "no-store");
+        return c.json(result);
+    })
         .put("/:id/path", zValidator("param", providerParam, onInvalid), zValidator("json", pathBody, onInvalid), async (c) => {
         const result = await saveCliPath(readiness, c.req.valid("param").id, c.req.valid("json").path);
         if (!result.ok)
@@ -30,6 +43,7 @@ export function providerRoutes(deps) {
                 detail: result.message,
                 extensions: { fields: [{ field: "path", message: result.message }] },
             });
+        catalog.invalidate(c.req.valid("param").id);
         return c.json(result.status);
     })
         .put("/:id/key", zValidator("param", providerParam, onInvalid), zValidator("json", keyBody, onInvalid), (c) => {
@@ -38,6 +52,7 @@ export function providerRoutes(deps) {
         if (!result.ok) {
             return refusal(c, id, result.reason);
         }
+        catalog.invalidate(id);
         // The response says a key is stored and shows the mask, never the value.
         return c.json(keyStatus(keys, id));
     })
@@ -47,6 +62,7 @@ export function providerRoutes(deps) {
         if (!result.ok) {
             return refusal(c, id, result.reason);
         }
+        catalog.invalidate(id);
         return c.body(null, 204);
     }));
 }

package/dist/edge/http/update.js

@@ -0,0 +1,57 @@
+import { Hono } from "hono";
+import { problem, titleOf } from "./problem.js";
+export function updateRoutes(deps) {
+    const unavailable = {
+        currentVersion: deps.version,
+        latestVersion: null,
+        available: false,
+        busy: false,
+        canUpdate: false,
+        status: "idle",
+        blockedReason: "In-app updates are unavailable for this server.",
+    };
+    return new Hono()
+        .get("/ready", (c) => {
+        c.header("Cache-Control", "no-store");
+        if (!deps.updater?.ready(c.req.header("X-Slopify-Update-Token") ?? ""))
+            return problem(c, { status: 403, title: titleOf(403) });
+        return c.json({ status: "ok", version: deps.version });
+    })
+        .post("/activate", async (c) => {
+        c.header("Cache-Control", "no-store");
+        const token = c.req.header("X-Slopify-Update-Token") ?? "";
+        if (!deps.updater?.ready(token))
+            return problem(c, { status: 403, title: titleOf(403) });
+        if (!(await deps.updater.activate(token)))
+            return problem(c, { status: 409, title: titleOf(409) });
+        return c.json({ status: "ok", version: deps.version });
+    })
+        .get("/", async (c) => {
+        c.header("Cache-Control", "no-store");
+        return c.json(deps.updater === undefined
+            ? unavailable
+            : await deps.updater.check(c.req.query("refresh") === "1"));
+    })
+        .post("/", async (c) => {
+        const origin = c.req.header("Origin");
+        if (origin !== undefined && origin !== new URL(c.req.url).origin)
+            return problem(c, {
+                status: 403,
+                title: titleOf(403),
+                detail: "Start updates from the Slopify page on this server.",
+            });
+        if (deps.updater === undefined)
+            return problem(c, { status: 409, title: titleOf(409), detail: unavailable.blockedReason });
+        const result = await deps.updater.start();
+        if (result.ok)
+            return c.json(result.info, 202);
+        const status = result.code ?? 409;
+        return problem(c, {
+            status,
+            title: titleOf(status),
+            detail: result.info.blockedReason ??
+                result.info.error ??
+                "No newer published update is available.",
+        });
+    });
+}

package/dist/edge/update-worker.js

@@ -0,0 +1,44 @@
+import { readFile, rm } from "node:fs/promises";
+import { updatePlanSchema } from "../updater/plan.js";
+import { performUpdate } from "../updater/worker.js";
+const planPath = process.argv[2];
+try {
+    if (planPath === undefined || !process.connected)
+        throw new Error("An update plan and parent process are required.");
+    const plan = updatePlanSchema.parse(JSON.parse(await readFile(planPath, "utf8")));
+    await rm(planPath, { force: true });
+    await performUpdate(plan, () => new Promise((resolve, reject) => {
+        if (!process.connected) {
+            reject(new Error("The update parent disconnected."));
+            return;
+        }
+        const fail = () => {
+            clearTimeout(timer);
+            reject(new Error("The update parent disconnected."));
+        };
+        const timer = setTimeout(() => reject(new Error("The update handoff timed out.")), 60_000);
+        process.once("disconnect", fail);
+        process.once("message", (message) => {
+            clearTimeout(timer);
+            process.off("disconnect", fail);
+            if (typeof message === "object" &&
+                message !== null &&
+                "type" in message &&
+                message.type === "handoff")
+                resolve();
+            else
+                reject(new Error("The update handoff was refused."));
+        });
+        process.send?.({ type: "installed" }, (error) => {
+            if (error !== null)
+                fail();
+        });
+    }));
+    if (process.connected)
+        process.disconnect?.();
+}
+catch {
+    if (process.connected)
+        process.disconnect?.();
+    process.exitCode = 1;
+}

package/dist/kernel/audio-preview.js

@@ -0,0 +1,188 @@
+import { randomUUID } from "node:crypto";
+const inactive = { append: () => { }, complete: () => { }, interrupt: () => { } };
+// A preview is a disposable copy of bytes from the paid call already in flight.
+// It never initiates synthesis, persists audio, or backpressures the provider.
+// Readers pull from shared bounded storage, so a slow browser cannot grow a queue.
+export function createAudioPreviewStore(limits = {}) {
+    const maxBytes = limits.maxBytes ?? 64 * 1024 * 1024;
+    const maxEntryBytes = limits.maxEntryBytes ?? 16 * 1024 * 1024;
+    const maxEntries = limits.maxEntries ?? 128;
+    const keepMs = limits.keepMs ?? 5 * 60_000;
+    const now = limits.now ?? Date.now;
+    const entries = new Map();
+    let retained = 0;
+    let closed = false;
+    const notify = (entry) => {
+        const listeners = [...entry.changed];
+        entry.changed.clear();
+        for (const listener of listeners)
+            listener();
+    };
+    const stop = (entry, state) => {
+        retained -= entry.bytes;
+        entry.bytes = 0;
+        entry.chunks.length = 0;
+        entry.state = state;
+        entry.endedAt = now();
+        notify(entry);
+    };
+    const remove = (entry) => {
+        stop(entry, "interrupted");
+        entries.delete(entry.id);
+    };
+    const prune = () => {
+        for (const entry of entries.values()) {
+            if (entry.endedAt !== undefined && now() - entry.endedAt >= keepMs)
+                remove(entry);
+        }
+    };
+    const expiry = setInterval(prune, Math.min(keepMs, 30_000));
+    expiry.unref();
+    const store = {
+        begin(projectId, key, label) {
+            if (closed)
+                return inactive;
+            prune();
+            for (const entry of entries.values()) {
+                if (entry.projectId === projectId && entry.key === key)
+                    remove(entry);
+            }
+            // At capacity, completed previews yield to current generation. Otherwise
+            // this request has no preview; the normal durable narration still succeeds.
+            if (entries.size >= maxEntries) {
+                const oldest = [...entries.values()].find((entry) => entry.state !== "streaming");
+                if (oldest !== undefined)
+                    remove(oldest);
+            }
+            if (entries.size >= maxEntries)
+                return inactive;
+            const entry = {
+                id: randomUUID(),
+                projectId,
+                key,
+                label,
+                chunks: [],
+                changed: new Set(),
+                state: "streaming",
+                bytes: 0,
+                endedAt: undefined,
+            };
+            entries.set(entry.id, entry);
+            const active = () => entries.get(entry.id) === entry && entry.state === "streaming";
+            return {
+                append(bytes) {
+                    if (!active() || bytes.byteLength === 0)
+                        return;
+                    if (retained + bytes.byteLength > maxBytes ||
+                        entry.bytes + bytes.byteLength > maxEntryBytes) {
+                        stop(entry, "unavailable");
+                        return;
+                    }
+                    // Own these bounded buffers. A provider may reuse its read buffer.
+                    for (let at = 0; at < bytes.byteLength; at += 64 * 1024) {
+                        entry.chunks.push(bytes.slice(at, at + 64 * 1024));
+                    }
+                    retained += bytes.byteLength;
+                    entry.bytes += bytes.byteLength;
+                    notify(entry);
+                },
+                complete() {
+                    if (!active())
+                        return;
+                    entry.state = "ready";
+                    entry.endedAt = now();
+                    notify(entry);
+                },
+                interrupt() {
+                    if (active())
+                        stop(entry, "interrupted");
+                },
+            };
+        },
+        list(projectId) {
+            prune();
+            return [...entries.values()]
+                .filter((entry) => entry.projectId === projectId)
+                .map(({ id, label, state, bytes }) => ({ id, label, state, bytes }));
+        },
+        stream(projectId, id, signal) {
+            prune();
+            const entry = entries.get(id);
+            if (entry === undefined ||
+                entry.projectId !== projectId ||
+                entry.state === "interrupted" ||
+                entry.state === "unavailable")
+                return undefined;
+            return follow(entry, signal);
+        },
+        clear(projectId) {
+            for (const entry of entries.values())
+                if (entry.projectId === projectId)
+                    remove(entry);
+        },
+        close() {
+            closed = true;
+            clearInterval(expiry);
+            for (const entry of entries.values())
+                remove(entry);
+        },
+    };
+    return store;
+}
+function follow(entry, signal) {
+    let index = 0;
+    let ended = false;
+    let wake;
+    let control;
+    const detach = () => {
+        ended = true;
+        signal.removeEventListener("abort", abort);
+        if (wake !== undefined) {
+            entry.changed.delete(wake);
+            wake();
+            wake = undefined;
+        }
+    };
+    const abort = () => {
+        if (ended)
+            return;
+        detach();
+        control?.error(new Error("Audio preview disconnected"));
+    };
+    return new ReadableStream({
+        start(controller) {
+            control = controller;
+            if (signal.aborted)
+                abort();
+            else
+                signal.addEventListener("abort", abort, { once: true });
+        },
+        async pull(controller) {
+            while (!ended) {
+                if (entry.state === "interrupted" || entry.state === "unavailable") {
+                    detach();
+                    controller.error(new Error("Audio preview was interrupted"));
+                    return;
+                }
+                const bytes = entry.chunks[index];
+                if (bytes !== undefined) {
+                    index += 1;
+                    controller.enqueue(bytes);
+                    return;
+                }
+                if (entry.state === "ready") {
+                    detach();
+                    controller.close();
+                    return;
+                }
+                await new Promise((resolve) => {
+                    wake = resolve;
+                    entry.changed.add(resolve);
+                });
+            }
+        },
+        cancel() {
+            detach();
+        },
+    }, { highWaterMark: 0 });
+}

package/dist/kernel/runner/providers.js

@@ -1,3 +1,4 @@
+import { randomUUID } from "node:crypto";
 import { attempt } from "./attempt.js";
 export function stageProviders(deps, context, pieceId) {
     const ctx = {
@@ -15,7 +16,18 @@ export function stageProviders(deps, context, pieceId) {
             // Resolved once; the adapter reads the stored key per request, so a key replaced
             // mid-run still reaches the next attempt.
             const port = deps.registry.llm(call.provider);
+            const callId = randomUUID();
+            const preview = (text, reset) => context.emit({
+                type: "llm.preview",
+                projectId: context.stage.projectId,
+                stage: context.stage.kind,
+                callId,
+                label: call.previewLabel ?? context.stage.kind,
+                text,
+                ...(reset === undefined ? {} : { reset }),
+            });
             return attempt(ctx, async (signal, progress) => {
+                preview("", true);
                 let text = "";
                 let usage = null;
                 let finishReason = null;
@@ -25,10 +37,12 @@ export function stageProviders(deps, context, pieceId) {
                     ...(call.webSearch === undefined ? {} : { webSearch: call.webSearch }),
                     signal,
                 })) {
+                    signal.throwIfAborted();
                     // Every event is a sign of life, so the idle clock restarts here.
                     progress();
                     if (event.type === "delta") {
                         text += event.text;
+                        preview(event.text);
                     }
                     else if (event.type === "done") {
                         usage = event.usage;
@@ -46,33 +60,69 @@ export function stageProviders(deps, context, pieceId) {
                 return answer;
             }, { kind: "llm", streaming: port.capabilities.streams });
         },
-        tts: (call) => {
+        tts: (call, observe) => {
             const port = deps.registry.tts(call.provider);
+            let continuation;
+            const notify = (event) => {
+                try {
+                    observe?.(event);
+                }
+                catch {
+                    // A preview is optional. A broken observer must never repeat a paid call.
+                    deps.log.write("warn", "audio.preview", {
+                        projectId: context.stage.projectId,
+                        stage: "audio",
+                        detail: "Could not update the live audio preview",
+                    });
+                }
+            };
             return attempt(ctx, async (signal, progress) => {
-                const spoken = await port.synthesize({
-                    voiceId: call.voiceId,
-                    text: call.text,
-                    signal,
-                });
-                const reader = spoken.audio.getReader();
-                const chunks = [];
-                let total = 0;
-                for (;;) {
-                    const { done, value } = await reader.read();
-                    if (done || value === undefined) {
-                        break;
+                notify({ type: "start" });
+                try {
+                    const spoken = await port.synthesize({
+                        model: call.model,
+                        voiceId: call.voiceId,
+                        text: call.text,
+                        signal,
+                        onActivity: progress,
+                        continuation: {
+                            read: () => continuation,
+                            write: (token) => {
+                                continuation = token;
+                            },
+                        },
+                    });
+                    const reader = spoken.audio.getReader();
+                    const chunks = [];
+                    let total = 0;
+                    try {
+                        for (;;) {
+                            const { done, value } = await reader.read();
+                            signal.throwIfAborted();
+                            if (done || value === undefined)
+                                break;
+                            progress();
+                            chunks.push(value);
+                            total += value.length;
+                            notify({ type: "chunk", bytes: value });
+                        }
                     }
-                    progress();
-                    chunks.push(value);
-                    total += value.length;
+                    finally {
+                        reader.releaseLock();
+                    }
+                    const bytes = new Uint8Array(total);
+                    let at = 0;
+                    for (const chunk of chunks) {
+                        bytes.set(chunk, at);
+                        at += chunk.length;
+                    }
+                    notify({ type: "complete" });
+                    return { bytes, container: spoken.container };
                 }
-                const bytes = new Uint8Array(total);
-                let at = 0;
-                for (const chunk of chunks) {
-                    bytes.set(chunk, at);
-                    at += chunk.length;
+                catch (error) {
+                    notify({ type: "interrupted" });
+                    throw error;
                 }
-                return { bytes, container: spoken.container };
             }, { kind: "tts", streaming: port.capabilities.streams });
         },
         image: (call) => {

package/dist/main.js

@@ -1,3 +1,5 @@
+import { randomBytes } from "node:crypto";
+import { existsSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { serve } from "@hono/node-server";
 import ffmpegStatic from "ffmpeg-static";
@@ -5,11 +7,9 @@ import { buildRegistry } from "./adapter-registry.js";
 import { alignSubtitles } from "./adapters/alignment/index.js";
 import { prepareFfmpeg } from "./adapters/ffmpeg.js";
 import { nodeRunCli } from "./adapters/llm/run-cli.js";
-import { cartesiaModel } from "./adapters/tts/cartesia.js";
-import { elevenLabsModel } from "./adapters/tts/elevenlabs.js";
-import { openAiTtsModel } from "./adapters/tts/openai.js";
 import { createHub } from "./edge/events/hub.js";
 import { createApp } from "./edge/http/app.js";
+import { createAudioPreviewStore } from "./kernel/audio-preview.js";
 import { systemClock } from "./kernel/clock.js";
 import { openDb } from "./kernel/db/index.js";
 import { migrate } from "./kernel/db/migrate.js";
@@ -22,6 +22,7 @@ import { dependenciesOf } from "./kernel/runner/graph.js";
 import { createRunner } from "./kernel/runner/index.js";
 import { stageProviders } from "./kernel/runner/providers.js";
 import { readVersion } from "./kernel/version.js";
+import { modelSources } from "./model-catalog.js";
 import { claimStage, finishStage, projectById, projectPaused, stagesOf, } from "./slices/admission/repo.js";
 import { prepareProvidedArticleSegments } from "./slices/article/provided-entries.js";
 import { runArticle } from "./slices/article/run.js";
@@ -35,6 +36,12 @@ import { createFlusher } from "./slices/telemetry/flush.js";
 import { record } from "./slices/telemetry/record.js";
 import { runThumbnail } from "./slices/thumbnail/run.js";
 import { renderVideo } from "./slices/video/run.js";
+import { watchActivation } from "./updater/candidate.js";
+import { launchUpdate } from "./updater/install.js";
+import { isUpdateToken } from "./updater/model.js";
+import { npmCommand, updateCommitted } from "./updater/plan.js";
+import { publishedVersion } from "./updater/registry.js";
+import { createUpdater } from "./updater/service.js";
 // ceiling: a burst of finished stages coalesces into one delivery a second later, and the
 // collector gets ten seconds to answer before the attempt is abandoned and the events
 // stay queued.
@@ -78,25 +85,91 @@ export async function boot(config) {
             clock,
             probe: nodeCliProbe,
         });
-        const runner = wire({ db, paths, clock, ids, log, hub, telemetry, flusher, registry, ffmpeg });
+        const audioPreviews = createAudioPreviewStore();
+        const runner = wire({
+            db,
+            paths,
+            clock,
+            ids,
+            log,
+            hub,
+            telemetry,
+            flusher,
+            registry,
+            ffmpeg,
+            audioPreviews,
+        });
+        const updateDb = db;
+        const oldEntry = fileURLToPath(new URL("./edge/cli.js", import.meta.url));
+        const workerEntry = fileURLToPath(new URL("./edge/update-worker.js", import.meta.url));
+        let npm;
+        try {
+            npm = await npmCommand();
+        }
+        catch {
+            log.write("warn", "update", {
+                detail: "npm is unavailable; in-app installation is disabled.",
+            });
+        }
+        let shutdown = async () => {
+            throw new Error("The server is not ready.");
+        };
+        let listeningPort = config.port;
+        const candidateToken = process.env.SLOPIFY_UPDATE_TOKEN ?? "";
+        const pendingActivation = isUpdateToken(candidateToken) && process.env.SLOPIFY_UPDATE_PENDING === "1";
+        const updater = createUpdater({
+            ...(isUpdateToken(candidateToken)
+                ? {
+                    candidate: {
+                        token: candidateToken,
+                        pending: pendingActivation,
+                        committed: () => updateCommitted(paths.dataDir, version, candidateToken),
+                    },
+                }
+                : {}),
+            currentVersion: version,
+            previousUpdateFailed: process.env.SLOPIFY_UPDATE_FAILED === "1",
+            now: () => Date.now(),
+            latest: () => publishedVersion(globalThis.fetch),
+            unsupported: () => !existsSync(oldEntry) || !existsSync(workerEntry)
+                ? "Run Slopify from its installed package to use in-app updates."
+                : npm === undefined
+                    ? "npm is unavailable. Install Node.js with npm to use in-app updates."
+                    : undefined,
+            busy: () => updateDb.prepare("SELECT 1 FROM stages WHERE state = 'running' LIMIT 1").get() !==
+                undefined ||
+                updateDb
+                    .prepare("SELECT id FROM projects")
+                    .all()
+                    .some((row) => typeof row.id === "string" && runner.hasInflight?.(row.id) === true),
+            report: (message) => log.write("warn", "update", { detail: message }),
+            install: async (next, restarting) => {
+                if (npm === undefined)
+                    throw new Error("npm is unavailable.");
+                await launchUpdate(workerEntry, {
+                    version: next,
+                    token: randomBytes(32).toString("hex"),
+                    previousVersion: version,
+                    oldEntry,
+                    dataDir: paths.dataDir,
+                    cwd: process.cwd(),
+                    host: config.host,
+                    port: listeningPort,
+                    npm: { file: npm.file, args: [...npm.args] },
+                }, async () => {
+                    restarting();
+                    await shutdown();
+                });
+            },
+        });
         const app = createApp({
             db,
             paths,
             hub,
             runner,
-            modelsFor: (provider, family) => {
-                if (family === "llm")
-                    return registry.llm(provider).models();
-                if (family === "image")
-                    return registry.image(provider).models();
-                const models = {
-                    elevenlabs: elevenLabsModel,
-                    "openai-tts": openAiTtsModel,
-                    cartesia: cartesiaModel,
-                };
-                const id = models[provider];
-                return Promise.resolve(id === undefined ? [] : [{ id, name: id }]);
-            },
+            updater,
+            audioPreviews,
+            ...modelSources(registry),
             clock,
             ids,
             log,
@@ -106,14 +179,17 @@ export async function boot(config) {
             probe: nodeCliProbe,
         });
         const server = await listen(app, config, log);
+        listeningPort = portOf(server) ?? config.port;
         // Whatever last run left queued goes out at start. Nothing waits for
         // it, and an unreachable collector costs one refused socket.
         flusher.soon();
         const open = db;
-        return {
-            paths,
-            url: urlOf(config.host, portOf(server) ?? config.port),
-            stop: async () => {
+        let stopping;
+        let stopActivation = () => { };
+        shutdown = () => {
+            stopping ??= (async () => {
+                stopActivation();
+                audioPreviews.close();
                 try {
                     // The listener goes first. Aborting the runner while the socket still accepted
                     // requests let a Play arriving during the await start a stage under a fresh
@@ -132,8 +208,12 @@ export async function boot(config) {
                     open.close();
                     lock.release();
                 }
-            },
+            })();
+            return stopping;
         };
+        if (pendingActivation)
+            stopActivation = watchActivation(updater, candidateToken, shutdown, (message) => log.write("warn", "update", { detail: message }));
+        return { paths, url: urlOf(config.host, listeningPort), stop: shutdown };
     }
     catch (error) {
         db?.close();
@@ -141,7 +221,7 @@ export async function boot(config) {
         throw error;
     }
 }
-function wire({ db, paths, clock, ids, log, hub, telemetry, flusher, registry, ffmpeg, }) {
+function wire({ audioPreviews, db, paths, clock, ids, log, hub, telemetry, flusher, registry, ffmpeg, }) {
     // A stage counts what it did and the queue is flushed after each new event. `record`
     // swallows its own failures, so this can neither fail a stage nor widen what leaves the
     // machine - the payload allow-list is checked inside it.
@@ -177,7 +257,7 @@ function wire({ db, paths, clock, ids, log, hub, telemetry, flusher, registry, f
             audio: async (context) => {
                 const wrapped = stageProviders(providers, context);
                 await prepareProvidedArticleSegments(writing, context, wrapped);
-                await runNarration(video, context, wrapped);
+                await runNarration({ ...video, audioPreviews }, context, wrapped);
             },
             images: (context) => runImages(writing, context, stageProviders(providers, context)),
             thumbnail: (context) => runThumbnail(writing, context, stageProviders(providers, context)),