@gentbajko/slopify 2.5.0 → 3.0.1

package/dist/edge/http/channels.js

@@ -0,0 +1,128 @@
+import { randomUUID } from "node:crypto";
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { bodyLimit } from "hono/body-limit";
+import { z } from "zod";
+import { deleteCastImage, generateCastImage, uploadCastImage, } from "../../slices/channels/cast-images.js";
+import { castImageMaxBytes } from "../../slices/channels/images.js";
+import { imageBlob } from "../../slices/channels/repo.js";
+import { createCastMember, createChannel, deleteCastMember, deleteChannel, listChannels, moveTemplate, readChannel, setChannelAiDisclosure, updateCastMember, updateChannel, } from "../../slices/channels/service.js";
+import { onInvalid, problem, titleOf } from "./problem.js";
+const idParam = z.object({ id: z.uuid() });
+const memberParam = z.object({ memberId: z.uuid() });
+const imageParam = memberParam.extend({ imageId: z.uuid() });
+const pictureParam = z.object({ sha256: z.string().regex(/^[0-9a-f]{64}$/) });
+const templateParam = z.object({ templateId: z.uuid() });
+// Channels: the channels, their brand kit, series brief and cast, and which channel
+// each template belongs to. The bodies are checked by the slice, so a refusal names the field.
+export function channelRoutes(deps) {
+    const service = {
+        db: deps.db,
+        clock: deps.clock,
+        uuid: randomUUID,
+        generateImage: deps.generateCastImage,
+        log: deps.log,
+    };
+    return (new Hono()
+        .get("/", (c) => c.json({ channels: listChannels(service) }))
+        .post("/", async (c) => {
+        const result = createChannel(service, await body(c));
+        return result.ok ? c.json(result.value, 201) : refused(c, result);
+    })
+        // The pictures by content hash: they never change, so the browser may keep them.
+        .get("/pictures/:sha256", zValidator("param", pictureParam, onInvalid), (c) => {
+        const blob = imageBlob(deps.db, c.req.valid("param").sha256);
+        if (blob === undefined)
+            return refused(c, { ok: false, reason: "not-found" });
+        return c.body(new Uint8Array(blob.bytes), 200, {
+            "Content-Type": blob.mime,
+            "Cache-Control": "private, max-age=31536000, immutable",
+            "X-Content-Type-Options": "nosniff",
+        });
+    })
+        .put("/templates/:templateId", zValidator("param", templateParam, onInvalid), async (c) => {
+        const result = moveTemplate(service, c.req.valid("param").templateId, await body(c));
+        return result.ok ? c.json(result.value) : refused(c, result);
+    })
+        .put("/cast/:memberId", zValidator("param", memberParam, onInvalid), async (c) => {
+        const result = updateCastMember(service, c.req.valid("param").memberId, await body(c));
+        return result.ok ? c.json(result.value) : refused(c, result);
+    })
+        .delete("/cast/:memberId", zValidator("param", memberParam, onInvalid), (c) => {
+        const result = deleteCastMember(service, c.req.valid("param").memberId);
+        return result.ok ? c.body(null, 204) : refused(c, result);
+    })
+        // The picture's bytes are the body, as the file input read them.
+        .post("/cast/:memberId/images", zValidator("param", memberParam, onInvalid), bodyLimit({
+        maxSize: castImageMaxBytes,
+        onError: (c) => refused(c, {
+            ok: false,
+            reason: "not-an-image",
+            message: `This picture is larger than ${String(castImageMaxBytes / 1024 / 1024)} MB. Save it smaller (for example as a JPEG) and upload it again.`,
+        }),
+    }), async (c) => {
+        const bytes = new Uint8Array(await c.req.arrayBuffer());
+        const result = uploadCastImage(service, c.req.valid("param").memberId, bytes);
+        return result.ok ? c.json(result.value, 201) : refused(c, result);
+    })
+        .post("/cast/:memberId/generate", zValidator("param", memberParam, onInvalid), async (c) => {
+        const result = generateCastImage(service, c.req.valid("param").memberId, await body(c));
+        return result.ok ? c.json(result.value, 202) : refused(c, result);
+    })
+        .delete("/cast/:memberId/images/:imageId", zValidator("param", imageParam, onInvalid), (c) => {
+        const { memberId, imageId } = c.req.valid("param");
+        const result = deleteCastImage(service, memberId, imageId);
+        return result.ok ? c.body(null, 204) : refused(c, result);
+    })
+        .get("/:id", zValidator("param", idParam, onInvalid), (c) => {
+        const result = readChannel(service, c.req.valid("param").id);
+        return result.ok ? c.json(result.value) : refused(c, result);
+    })
+        .put("/:id", zValidator("param", idParam, onInvalid), async (c) => {
+        const result = updateChannel(service, c.req.valid("param").id, await body(c));
+        return result.ok ? c.json(result.value) : refused(c, result);
+    })
+        .put("/:id/ai-disclosure", zValidator("param", idParam, onInvalid), async (c) => {
+        const result = setChannelAiDisclosure(service, c.req.valid("param").id, await body(c));
+        return result.ok ? c.json(result.value) : refused(c, result);
+    })
+        .delete("/:id", zValidator("param", idParam, onInvalid), (c) => {
+        const result = deleteChannel(service, c.req.valid("param").id);
+        return result.ok ? c.body(null, 204) : refused(c, result);
+    })
+        .post("/:id/cast", zValidator("param", idParam, onInvalid), async (c) => {
+        const result = createCastMember(service, c.req.valid("param").id, await body(c));
+        return result.ok ? c.json(result.value, 201) : refused(c, result);
+    }));
+}
+async function body(c) {
+    try {
+        return await c.req.json();
+    }
+    catch {
+        return undefined;
+    }
+}
+const details = {
+    "not-found": "This channel, cast member or picture no longer exists; it may have been deleted in another tab. Go back to Channels.",
+    conflict: "This changed in another tab while you were editing. Reload the page to see the latest, then make your change again.",
+    "invalid-input": "Some of these settings are not valid. Check the highlighted fields and try again.",
+    "default-channel": "The default channel can't be deleted; projects and templates without a channel belong to it. Rename it in its Brand tab instead.",
+    "has-templates": "This channel still has templates. Move them to another channel in its Templates tab, or delete them, then delete the channel.",
+    "not-an-image": "This file is not a PNG or JPEG picture. Upload a PNG or JPEG file.",
+    "too-many-images": "This cast member already has the most pictures it can keep. Delete one first.",
+    "no-image-provider": "Slopify can't make pictures here yet. Set up an image provider in Settings → Providers, or upload a picture instead.",
+};
+function refused(c, result) {
+    const status = result.reason === "not-found"
+        ? 404
+        : result.reason === "conflict" || result.reason === "has-templates"
+            ? 409
+            : 400;
+    return problem(c, {
+        status,
+        title: titleOf(status),
+        detail: result.message ?? details[result.reason],
+        extensions: { reason: result.reason },
+    });
+}

package/dist/edge/http/diagnostics.js

@@ -11,6 +11,7 @@ export function diagnosticsRoutes(deps) {
             db: deps.db,
             probe: deps.probe,
             hostCliStatus: deps.hostCliStatus,
+            host: deps.speechHost,
         });
         const projectCount = deps.db.prepare("SELECT count(*) AS count FROM projects").get();
         const schema = deps.db.prepare("SELECT max(version) AS version FROM schema_migrations").get();

package/dist/edge/http/draft-files.js

@@ -1,6 +1,4 @@
-import { createReadStream } from "node:fs";
 import { extname } from "node:path";
-import { Readable } from "node:stream";
 import { zValidator } from "@hono/zod-validator";
 import { Hono } from "hono";
 import { z } from "zod";
@@ -9,6 +7,7 @@ import { readDraft } from "../../slices/play-drafts/service.js";
 import { uploadDraftAttachment } from "../../slices/play-drafts/uploads.js";
 import { stagingPath } from "../../slices/storage/layout.js";
 import { stagedFileById } from "../../slices/storage/repo.js";
+import { fileResponse } from "./byte-range.js";
 import { draftProblem } from "./draft-problem.js";
 import { readMultipart } from "./multipart.js";
 import { onInvalid, problem, titleOf } from "./problem.js";
@@ -59,9 +58,8 @@ export function draftFileRoutes(service) {
                 title: titleOf(404),
                 detail: "This attached file has not finished uploading, so it cannot be previewed yet. Wait a moment or attach it again.",
             });
-        return c.body(Readable.toWeb(createReadStream(stagingPath(deps.paths, staged.path))), 200, {
+        return fileResponse(c, stagingPath(deps.paths, staged.path), staged.bytes, {
             "content-type": contentType,
-            "content-length": String(staged.bytes),
             "x-content-type-options": "nosniff",
             "cache-control": "no-store",
         });

package/dist/edge/http/entries.js

@@ -1,12 +1,14 @@
 import { zValidator } from "@hono/zod-validator";
 import { Hono } from "hono";
 import { z } from "zod";
+import { versionsOrCurrent } from "../../slices/library/history.js";
 import { entryCategories, entryModes } from "../../slices/library/model.js";
-import { listEntries } from "../../slices/library/repo.js";
-import { createEntry, removeEntry, updateEntry } from "../../slices/library/save.js";
+import { entryById, listEntries } from "../../slices/library/repo.js";
+import { createEntry, removeEntry, restoreEntry, updateEntry } from "../../slices/library/save.js";
+import { usedBy } from "../../slices/library/used-by.js";
 import { onInvalid } from "./problem.js";
 // One rule set for prompts and entries, so one refusal mapping too.
-import { refused } from "./prompts.js";
+import { refused, versionParam } from "./prompts.js";
 const idParam = z.object({
     id: z
         .string()
@@ -33,6 +35,23 @@ export function entryRoutes(deps) {
         .put("/:id", zValidator("param", idParam, onInvalid), zValidator("json", entryBody, onInvalid), (c) => {
         const result = updateEntry(library, c.req.valid("param").id, c.req.valid("json"));
         return result.ok ? c.json(result.value) : refused(c, result, "entry");
+    })
+        .get("/:id/history", zValidator("param", idParam, onInvalid), (c) => {
+        const entry = entryById(deps.db, c.req.valid("param").id);
+        return entry === undefined
+            ? refused(c, { ok: false, reason: "not-found" }, "entry")
+            : c.json({ versions: versionsOrCurrent(deps.db, "entry", entry) });
+    })
+        .post("/:id/history/:version/restore", zValidator("param", versionParam, onInvalid), (c) => {
+        const { id, version } = c.req.valid("param");
+        const result = restoreEntry(library, id, version);
+        return result.ok ? c.json(result.value) : refused(c, result, "entry");
+    })
+        .get("/:id/used-by", zValidator("param", idParam, onInvalid), (c) => {
+        const entry = entryById(deps.db, c.req.valid("param").id);
+        return entry === undefined
+            ? refused(c, { ok: false, reason: "not-found" }, "entry")
+            : c.json(usedBy(deps.db, { item: "entry", category: entry.category, name: entry.name }));
     })
         .delete("/:id", zValidator("param", idParam, onInvalid), (c) => {
         const result = removeEntry(library, c.req.valid("param").id);

package/dist/edge/http/files.js

@@ -1,9 +1,8 @@
-import { createReadStream } from "node:fs";
-import { Readable } from "node:stream";
 import { zValidator } from "@hono/zod-validator";
 import { Hono } from "hono";
 import { z } from "zod";
 import { findDownload, imagesZip } from "../../slices/storage/downloads.js";
+import { fileResponse } from "./byte-range.js";
 import { onInvalid, problem, titleOf } from "./problem.js";
 const projectParam = z.object({
     projectId: z
@@ -42,11 +41,16 @@ export function fileRoutes(deps) {
             return missing(c, result.reason);
         }
         const { download } = result;
-        // ceiling: whole-file responses only. Seeking inside the finished video would
-        // need a Range handler answering 206 with the requested slice.
-        return c.body(Readable.toWeb(createReadStream(download.path)), 200, {
+        // The YouTube description and tags as the page shows them, edits and links in.
+        if (download.text !== undefined)
+            return c.body(download.text, 200, {
+                "content-type": download.contentType,
+                "content-length": String(download.text.byteLength),
+                "content-disposition": disposition(download.filename),
+            });
+        // Byte ranges, so the players can jump to any time in the video or narration.
+        return fileResponse(c, download.path, download.bytes, {
             "content-type": download.contentType,
-            "content-length": String(download.bytes),
             "content-disposition": disposition(download.filename),
         });
     }));
@@ -60,7 +64,7 @@ function missing(c, reason) {
     const details = {
         "unknown-project": "This project no longer exists. Go back to Projects to pick another.",
         "unknown-asset": "This project has no file by that name. Reload the page to see its current files.",
-        "missing-file": "This file was deleted or moved from the project folder. Use Re-run section on the project page to make it again.",
+        "missing-file": "This file was deleted or moved from the project folder. Use More → make it again in its section on the project page to make it again.",
         "no-images": "This project has no images or thumbnail yet. Wait for the Images step to finish, then try again.",
     };
     return problem(c, { status: 404, title: titleOf(404), detail: details[reason] });

package/dist/edge/http/folder-location.js

@@ -46,7 +46,7 @@ export async function replyForFolder(c, deps, projectId, file) {
             return problem(c, {
                 status: 404,
                 title: titleOf(404),
-                detail: "This output's folder was deleted or moved. Use Re-run section on the project page to make the file again.",
+                detail: "This output's folder was deleted or moved. Use More → make it again in its section on the project page to make the file again.",
             });
         }
     }

package/dist/edge/http/home.js

@@ -0,0 +1,39 @@
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { z } from "zod";
+import { weekSummary } from "../../slices/run-cost/week.js";
+import { markUploaded } from "../../slices/uploads/repo.js";
+import { onInvalid, problem, titleOf } from "./problem.js";
+const weekQuery = z.object({
+    since: z.iso.datetime({ offset: true }),
+    channelId: z.string().min(1).max(64).optional(),
+});
+// Home's "This week": videos made, spend and the API equivalent since `since` (the browser's
+// own Monday), for one channel or all of them, and where each CLI plan's windows stand.
+export function homeRoutes(deps) {
+    return new Hono().get("/week", zValidator("query", weekQuery, onInvalid), (c) => {
+        const { since, channelId } = c.req.valid("query");
+        return c.json(weekSummary(deps.db, new Date(since).toISOString(), channelId));
+    });
+}
+const idParam = z.object({
+    id: z
+        .string()
+        .min(1)
+        .max(64)
+        .regex(/^[0-9A-Za-z_-]+$/),
+});
+// Home's "Mark uploaded" and its undo. Slopify never uploads, so this only records what the
+// person says they did.
+export function uploadedRoutes(deps) {
+    return new Hono().put("/:id/uploaded", zValidator("param", idParam, onInvalid), zValidator("json", z.object({ uploaded: z.boolean() }).strict(), onInvalid), (c) => {
+        const result = markUploaded(deps.db, c.req.valid("param").id, c.req.valid("json").uploaded, deps.clock.now().toISOString());
+        if (!result.ok)
+            return problem(c, {
+                status: 404,
+                title: titleOf(404),
+                detail: "This project no longer exists. Go back to Projects to pick another.",
+            });
+        return c.json({ uploadedAt: result.uploadedAt });
+    });
+}

package/dist/edge/http/host-cli.js

@@ -5,7 +5,7 @@ import { stream } from "hono/streaming";
 import { z } from "zod";
 import { sniffImage } from "../../adapters/image/bytes.js";
 import { redact } from "../../kernel/log.js";
-import { bridgeLimits, HostFolderRefused, hostCliIds, hostCliProtocol, hostFrameSchema, hostImageSchema, hostLlmIds, hostLlmSchema, hostModelsSchema, hostOpenFolderSchema, hostStatusSchema, } from "../../kernel/ports/host-cli.js";
+import { bridgeLimits, encodeHostImageReport, HostFolderRefused, hostCliIds, hostCliProtocol, hostDoneFrame, hostFrameSchema, hostFramesHeader, hostImageReportHeader, hostImageSchema, hostLlmIds, hostLlmSchema, hostModelsSchema, hostOpenFolderSchema, hostStatusSchema, } from "../../kernel/ports/host-cli.js";
 import { agentImageTimeoutMs } from "../../kernel/ports/image.js";
 import { isProviderError, providerError } from "../../kernel/ports/model.js";
 export function hostGate() {
@@ -49,7 +49,7 @@ export function hostGate() {
         },
     };
 }
-const unavailable = "The AI command-line tool on your computer stopped before it finished, so this result is uncertain. Check the section's outputs on the project page, then use Retry stage.";
+const unavailable = "The AI command-line tool on your computer stopped before it finished, so this result is uncertain. Check the section's outputs on the project page, then use Try again.";
 function fault(error, token) {
     return {
         type: "error",
@@ -90,7 +90,7 @@ export function hostCliRoutes(options) {
             return c.json({
                 type: "error",
                 kind: "unavailable",
-                message: "The Slopify helper on your computer is busy or restarting. Wait a moment, then use Retry stage.",
+                message: "The Slopify helper on your computer is busy or restarting. Wait a moment, then use Try again.",
             }, 503);
         const outgoing = c.env?.outgoing;
         let responseEnded = !outgoing;
@@ -174,6 +174,8 @@ export function hostCliRoutes(options) {
         const body = hostLlmSchema.safeParse(await json(c.req.raw));
         if (!body.success)
             return invalid(c);
+        // An app that sends no header reads the original frames (version 1).
+        const frames = Number(c.req.header(hostFramesHeader) ?? 1);
         const job = c.get("job");
         job.holdStream();
         const controller = new AbortController();
@@ -191,7 +193,14 @@ export function hostCliRoutes(options) {
                     signal.throwIfAborted();
                     clearTimeout(timer);
                     timer = setTimeout(() => controller.abort(), 120_000);
-                    const parsed = hostFrameSchema.parse(event);
+                    // The cached-token count, the answering model and the plan windows cross only to
+                    // an app that asked for frame version 2; an older app rejects fields it does not
+                    // know. Typed-ahead text stays here: the bridge carries the committed answer only.
+                    const parsed = hostFrameSchema.parse(event.type === "done"
+                        ? hostDoneFrame(event, frames)
+                        : event.type === "partial"
+                            ? { type: "activity" }
+                            : event);
                     if (done || parsed.type === "error")
                         throw new Error("Slopify hit an internal error (the AI tool on your computer sent a reply Slopify could not read). Try again; if it keeps happening, use Download diagnostics in Settings and report it.");
                     const frame = `${JSON.stringify(parsed)}\n`;
@@ -229,7 +238,17 @@ export function hostCliRoutes(options) {
         const signal = AbortSignal.any([job.signal, controller.signal]);
         const timer = setTimeout(() => controller.abort(), agentImageTimeoutMs);
         try {
-            const { reference, thinking, ...rest } = body.data;
+            const { reference, thinking, cast: bridgedCast, ...rest } = body.data;
+            const cast = bridgedCast?.map((member) => ({
+                name: member.name,
+                description: member.description,
+                images: member.images.map((picture) => ({
+                    bytes: new Uint8Array(Buffer.from(picture.base64, "base64")),
+                    mime: picture.mime,
+                })),
+            }));
+            if (cast?.some((member) => member.images.some((picture) => sniffImage(picture.bytes) !== picture.mime)))
+                return invalid(c);
             const image = reference === undefined
                 ? undefined
                 : {
@@ -242,6 +261,7 @@ export function hostCliRoutes(options) {
                 ...rest,
                 ...(thinking === undefined ? {} : { thinking }),
                 ...(image === undefined ? {} : { reference: image }),
+                ...(cast === undefined ? {} : { cast }),
                 signal,
             });
             if (signal.aborted)
@@ -250,6 +270,10 @@ export function hostCliRoutes(options) {
                 throw new Error("Slopify hit an internal error (the image made on your computer was too large or not a valid image). Try again; if it keeps happening, use Download diagnostics in Settings and report it.");
             c.header("Content-Type", result.mime);
             c.header("Content-Length", String(result.bytes.byteLength));
+            // Any app may get this: one from before it ignores headers it does not know.
+            const report = encodeHostImageReport(result);
+            if (report !== undefined)
+                c.header(hostImageReportHeader, report);
             return c.body(new Uint8Array(result.bytes));
         }
         catch (error) {

package/dist/edge/http/narration-peaks.js

@@ -0,0 +1,76 @@
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { z } from "zod";
+import { narrationAudio } from "../../slices/narration/peaks.js";
+import { assetPath } from "../../slices/revisions/mutation-assets.js";
+import { currentRevisionId } from "../../slices/revisions/repo.js";
+import { getRevisionView } from "../../slices/revisions/view.js";
+import { outputPath } from "../../slices/storage/layout.js";
+import { projectTitle } from "../../slices/storage/repo.js";
+import { onInvalid, problem, titleOf } from "./problem.js";
+const projectParam = z.object({
+    projectId: z
+        .string()
+        .min(1)
+        .max(64)
+        .regex(/^[0-9A-Za-z_-]+$/),
+});
+// ceiling: a few projects' worth of pieces. An asset never changes, so a cached row is never
+// stale; the oldest goes first.
+const cachedPieces = 400;
+// The live view's waveform: the peaks of every finished narration piece of the current
+// version, fetched again each time a `narration.piece` event says one landed.
+export function narrationPeakRoutes(deps) {
+    const cache = new Map();
+    return new Hono().get("/:projectId/narration/peaks", zValidator("param", projectParam, onInvalid), async (c) => {
+        const { projectId } = c.req.valid("param");
+        if (projectTitle(deps.db, projectId) === undefined)
+            return problem(c, {
+                status: 404,
+                title: titleOf(404),
+                detail: "This project no longer exists. Go back to Projects to pick another.",
+            });
+        c.header("Cache-Control", "no-store");
+        const revisionId = currentRevisionId(deps.db, projectId);
+        const view = revisionId === undefined ? undefined : getRevisionView(deps, projectId, revisionId);
+        if (revisionId === undefined || view === undefined)
+            return c.json({
+                revisionId: null,
+                complete: false,
+                pieces: [],
+            });
+        const decode = deps.decodePeaks;
+        if (decode === undefined)
+            return problem(c, {
+                status: 503,
+                title: titleOf(503),
+                detail: "Slopify can't draw the narration waveform because ffmpeg isn't available. Restart Slopify; if it keeps happening, use Download diagnostics in Settings and report it.",
+            });
+        const audio = narrationAudio(view);
+        const pieces = [];
+        for (const piece of audio.pieces) {
+            let peaks = cache.get(piece.assetId);
+            if (peaks === undefined) {
+                try {
+                    peaks = await decode(outputPath(deps.paths, projectId, assetPath(deps, projectId, piece.assetId)), c.req.raw.signal);
+                }
+                catch (error) {
+                    deps.log.write("warn", "narration.peaks", {
+                        projectId,
+                        stage: "audio",
+                        detail: error instanceof Error ? error.message : String(error),
+                    });
+                    continue;
+                }
+                cache.set(piece.assetId, peaks);
+                while (cache.size > cachedPieces) {
+                    const oldest = cache.keys().next().value;
+                    if (oldest !== undefined)
+                        cache.delete(oldest);
+                }
+            }
+            pieces.push({ key: piece.key, seconds: peaks.seconds, peaks: peaks.peaks });
+        }
+        return c.json({ revisionId, complete: audio.complete, pieces });
+    });
+}