@gentbajko/slopify 2.5.0 → 3.0.1

package/dist/slices/studio/pack.js

@@ -0,0 +1,211 @@
+import { readFileSync, statSync } from "node:fs";
+import { z } from "zod";
+import { thumbnailCountOf } from "../admission/model.js";
+import { projectById } from "../admission/repo.js";
+import { channelById, projectChannelId } from "../channels/repo.js";
+import { namesPhotorealisticPrompt } from "../library/photorealistic.js";
+import { isClipPath } from "../rebuild/runtime-export-edit.js";
+import { listVoices } from "../settings/repo.js";
+import { realPersonVoiceIds } from "../settings/voices.js";
+import { fullVideoLine } from "../shorts/model.js";
+import { assetOf } from "../storage/asset-name.js";
+import { contentTypeOf, downloadName, slugOf } from "../storage/downloads.js";
+import { outputPath } from "../storage/layout.js";
+import { outputsOf } from "../storage/repo.js";
+import { videoEditOf } from "../video/edit-settings.js";
+import { usesVoices } from "../voices/model.js";
+import { effectiveDescription } from "../youtube/edits-repo.js";
+import { aiDisclosureOf } from "./disclosure.js";
+import { studioAudience, studioTitleMax, } from "./model.js";
+import { readRealFootage, readStudioPlaylist } from "./settings.js";
+// What `shorts.json` holds for each picked clip; only what the pack uses.
+const clipsSchema = z.object({
+    shorts: z.array(z.object({
+        number: z.number(),
+        first: z.number().optional(),
+        last: z.number().optional(),
+        title: z.string(),
+        description: z.string(),
+        hashtags: z.array(z.string()),
+    })),
+});
+// Builds the pack from the project's current outputs: the video, the YouTube description and
+// tags, the thumbnails and each short. Nothing is generated here; a part that isn't made yet
+// is left empty and named in `missing` with what to do about it.
+export function uploadPack(deps, projectId) {
+    const project = projectById(deps.db, projectId);
+    if (project === undefined)
+        return { ok: false, reason: "unknown-project" };
+    const config = project.config;
+    const outputs = outputsOf(deps.db, projectId).filter((output) => available(deps, projectId, output));
+    const slug = slugOf(project.title);
+    const file = (output) => ({
+        url: `/files/${projectId}/${assetOf(output)}`,
+        asset: assetOf(output),
+        filename: downloadName(slug, output),
+        contentType: contentTypeOf(output.path),
+        bytes: output.bytes,
+    });
+    const text = (output) => output === undefined
+        ? undefined
+        : readFileSync(outputPath(deps.paths, projectId, output.path), "utf8").trim();
+    const channelId = projectChannelId(deps.db, projectId);
+    // The channel's own playlist, else the default (Settings → YouTube Studio).
+    const playlist = readStudioPlaylist(deps.db, channelId);
+    const missing = [];
+    // The channel's setting, then what the project narrates and shows (`disclosure.ts`).
+    const setting = channelById(deps.db, channelId)?.aiDisclosure ?? "auto";
+    const realPersonVoices = realPersonVoicesOf(deps, config);
+    const uploadedClips = config.sources.images === "provide"
+        ? outputs.filter((output) => output.role === "image" && isClipPath(output.path)).length
+        : 0;
+    const realFootage = uploadedClips > 0 && readRealFootage(deps.db, projectId);
+    const atmosphere = videoEditOf(config).atmosphere;
+    const disclosure = (kind) => aiDisclosureOf({
+        setting,
+        kind,
+        realPersonVoices,
+        // A short's pictures are always drawn anew, never the uploaded clips.
+        realFootage: kind === "video" && realFootage,
+        footageOverlay: atmosphere === "none" ? undefined : atmosphere,
+        photorealistic: kind === "short"
+            ? namesPhotorealisticPrompt(deps.db, config.shorts?.imagePrompt)
+            : config.sources.images === "generate" &&
+                config.imagePrompts.some((prompt) => namesPhotorealisticPrompt(deps.db, prompt.name)),
+    });
+    const video = outputs.find((output) => output.role === "video");
+    if (video === undefined)
+        missing.push("The video isn't made yet. Let the Video stage finish (or use Continue the run on the project page), then open Prepare upload again.");
+    const written = text(outputs.find((output) => output.role === "youtube_description"));
+    const writtenTags = text(outputs.find((output) => output.role === "youtube_tags"));
+    // As the project page shows it: the user's edits, and channel links filled in.
+    const edited = written === undefined
+        ? undefined
+        : effectiveDescription(deps.db, projectId, {
+            description: written,
+            tags: writtenTags ?? "",
+            // The last chapter is checked against the video's own length when it is known.
+            durationSeconds: video?.durationMs === null || video?.durationMs === undefined
+                ? undefined
+                : video.durationMs / 1000,
+        });
+    const tagsFile = edited?.tags ?? writtenTags;
+    const description = edited?.description;
+    if (description === undefined)
+        missing.push(config.youtubeDescription === true
+            ? "The YouTube description isn't written yet. It is written after the video's subtitle timing; wait for the Video stage to finish."
+            : "No YouTube description is written for this project. Turn on YouTube description in Edit project → Prompts to have one written with chapters and tags.");
+    const count = thumbnailCountOf(config);
+    // The first thumbnail, then the second and third, and never one left from when the project
+    // made three and now makes one.
+    const thumbnails = outputs
+        .filter((output) => output.role === "thumbnail" && (output.meta.index ?? 1) <= count)
+        .sort((a, b) => (a.meta.index ?? 1) - (b.meta.index ?? 1));
+    if (thumbnails.length === 0)
+        missing.push(config.sources.thumbnail === "off"
+            ? "This project makes no thumbnail, so YouTube will pick a frame. Set Thumbnail in Edit project to make or upload one."
+            : "The thumbnail isn't made yet. Let the Thumbnail stage finish, then open Prepare upload again.");
+    else if (thumbnails.length < count)
+        missing.push(`Only ${String(thumbnails.length)} of the ${String(count)} thumbnails are made. Regenerate the missing ones in the project's Images section.`);
+    if (playlist === null)
+        missing.push("No playlist is set for this project's channel, so the playlist step is left to you. Set one in Settings → YouTube Studio → Playlist.");
+    const items = [
+        {
+            kind: "video",
+            video: video === undefined ? null : file(video),
+            title: project.title.slice(0, studioTitleMax),
+            description: description ?? "",
+            tags: tagsOf(tagsFile),
+            thumbnails: thumbnails.map(file),
+            audience: studioAudience,
+            alteredContent: disclosure("video"),
+            playlist,
+            ...(edited?.chapterNotice === undefined ? {} : { chapterNotice: edited.chapterNotice }),
+        },
+    ];
+    const clips = clipsOf(text(outputs.find((output) => output.role === "shorts")));
+    const shortVideos = outputs.filter((output) => output.role === "short_video");
+    for (const clip of clips) {
+        // The clip's own render: the one cut from the same sentences, else the newest for its
+        // number (a list written before the sentences were kept).
+        const mine = shortVideos.filter((output) => output.meta.short === clip.number);
+        const exact = mine.find((output) => clip.first !== undefined &&
+            output.meta.sentences?.[0] === clip.first &&
+            output.meta.sentences?.[1] === clip.last);
+        const render = exact ?? mine.at(-1);
+        if (render === undefined)
+            missing.push(`Short ${String(clip.number)} isn't rendered yet. Let the Video stage finish, then open Prepare upload again.`);
+        items.push({
+            kind: "short",
+            short: clip.number,
+            video: render === undefined ? null : file(render),
+            title: clip.title.slice(0, studioTitleMax),
+            description: [
+                clip.description,
+                fullVideoLine(config.shorts?.fullVideoLink),
+                "",
+                clip.hashtags.join(" "),
+            ].join("\n"),
+            // The hashtags without their #, as search tags.
+            tags: clip.hashtags.map((tag) => tag.replace(/^#+/, "").trim()).filter((tag) => tag !== ""),
+            // Studio shows a frame of a short; a custom thumbnail isn't offered in its upload dialog.
+            thumbnails: [],
+            audience: studioAudience,
+            alteredContent: disclosure("short"),
+            playlist,
+        });
+    }
+    return {
+        ok: true,
+        pack: {
+            projectId,
+            projectTitle: project.title,
+            items,
+            missing,
+            ...(uploadedClips > 0 ? { footage: { clips: uploadedClips, real: realFootage } } : {}),
+        },
+    };
+}
+// The saved voices marked "Imitates a real person" that narrate the project: its one narration
+// voice, or every speaker's of a multi-voice run. None when the narration isn't an AI voice.
+function realPersonVoicesOf(deps, config) {
+    if (config.sources.audio !== "generate")
+        return [];
+    const narrating = usesVoices(config)
+        ? (config.voices?.speakers ?? []).map((speaker) => speaker.voice)
+        : config.audio === undefined
+            ? []
+            : [config.audio];
+    const flagged = realPersonVoiceIds(deps.db);
+    const names = listVoices(deps.db)
+        .filter((voice) => flagged.has(voice.id) &&
+        narrating.some((one) => one.provider === voice.provider && one.voice === voice.voiceId))
+        .map((voice) => voice.name);
+    return [...new Set(names)];
+}
+// The item the person chose: the long video, or short `short`.
+export function packItem(pack, short) {
+    return pack.items.find((item) => short === undefined ? item.kind === "video" : item.kind === "short" && item.short === short);
+}
+function tagsOf(line) {
+    return (line ?? "")
+        .split(",")
+        .map((tag) => tag.trim())
+        .filter((tag) => tag !== "");
+}
+function clipsOf(text) {
+    if (text === undefined)
+        return [];
+    try {
+        const parsed = clipsSchema.safeParse(JSON.parse(text));
+        return parsed.success ? parsed.data.shorts : [];
+    }
+    catch {
+        return [];
+    }
+}
+function available(deps, projectId, output) {
+    return (statSync(outputPath(deps.paths, projectId, output.path), {
+        throwIfNoEntry: false,
+    })?.isFile() === true);
+}

package/dist/slices/studio/queue.js

@@ -0,0 +1,69 @@
+import { createHash } from "node:crypto";
+import { z } from "zod";
+import { readSetting, writeSetting } from "../settings/repo.js";
+import { studioFillQueuePrefix, studioPairing } from "./settings.js";
+// What Fill in YouTube Studio chose, waiting for the extension: one entry per video or short,
+// oldest first. Each new upload dialog in Studio is filled from the first entry, which then
+// leaves the queue, so preparing several shorts in a row fills them one upload at a time.
+// Kept in the settings table under the current pairing (`studio.fillQueue.<token hash>`), so a
+// restart keeps it and a new pairing token starts with nothing waiting. An entry older than
+// `fillQueueMs` is dropped as stale.
+export const fillQueueMs = 24 * 60 * 60 * 1000;
+// More would be a list nobody works through; the oldest leave first.
+export const fillQueueMax = 50;
+const entrySchema = z.object({
+    projectId: z.string().min(1).max(64),
+    short: z.number().int().min(1).max(99).nullable(),
+    at: z.string(),
+});
+function queueKey(db) {
+    const hash = createHash("sha256").update(studioPairing(db).token).digest("hex").slice(0, 16);
+    return `${studioFillQueuePrefix}${hash}`;
+}
+function write(db, key, entries) {
+    if (entries.length === 0)
+        db.prepare("DELETE FROM settings WHERE key = ?").run(key);
+    else
+        writeSetting(db, key, JSON.stringify(entries));
+}
+// The waiting entries, oldest first, without the stale ones.
+export function readFillQueue(db, now) {
+    const stored = readSetting(db, queueKey(db));
+    if (stored === undefined)
+        return [];
+    let raw;
+    try {
+        raw = JSON.parse(stored);
+    }
+    catch {
+        return [];
+    }
+    if (!Array.isArray(raw))
+        return [];
+    return raw.flatMap((one) => {
+        const parsed = entrySchema.safeParse(one);
+        if (!parsed.success)
+            return [];
+        const age = now.getTime() - Date.parse(parsed.data.at);
+        return Number.isFinite(age) && age <= fillQueueMs ? [parsed.data] : [];
+    });
+}
+const same = (entry, projectId, short) => entry.projectId === projectId && entry.short === short;
+// Adds an item at the end; one already waiting keeps its place.
+export function enqueueFill(db, projectId, short, now) {
+    const key = queueKey(db);
+    const current = readFillQueue(db, now);
+    if (current.some((entry) => same(entry, projectId, short))) {
+        write(db, key, current);
+        return current;
+    }
+    const next = [...current, { projectId, short, at: now.toISOString() }].slice(-fillQueueMax);
+    write(db, key, next);
+    return next;
+}
+// Takes an item out: filled by the extension, or removed by the person.
+export function removeFill(db, projectId, short, now) {
+    const next = readFillQueue(db, now).filter((entry) => !same(entry, projectId, short));
+    write(db, queueKey(db), next);
+    return next;
+}

package/dist/slices/studio/settings.js

@@ -0,0 +1,170 @@
+import { randomBytes, timingSafeEqual } from "node:crypto";
+import { z } from "zod";
+import { readSetting, writeSetting } from "../settings/repo.js";
+import { studioPlaylistMax } from "./model.js";
+// Two rows of the key/value `settings` table. The playlist travels with a backup; the
+// pairing stays on this machine (`slices/storage/portable.ts`): its token is what lets the
+// browser extension read a project's upload pack.
+export const studioPlaylistKey = "studio.playlist";
+export const studioPairingKey = "studio.pairing";
+const pairingSchema = z.object({
+    token: z.string().min(20),
+    origin: z.string().nullable(),
+    pairedAt: z.string().nullable(),
+});
+// A channel's own playlist is a row of its own, `studio.playlist.<channelId>`; a channel
+// without one uses the default above.
+export const studioChannelPlaylistPrefix = `${studioPlaylistKey}.`;
+function playlistKey(channelId) {
+    return channelId === undefined ? studioPlaylistKey : `${studioChannelPlaylistPrefix}${channelId}`;
+}
+// The playlist an upload pack names: the channel's own, else the default. Without a channel,
+// the default alone.
+export function readStudioPlaylist(db, channelId) {
+    if (channelId !== undefined) {
+        const own = storedPlaylist(db, playlistKey(channelId));
+        if (own !== null)
+            return own;
+    }
+    return storedPlaylist(db, studioPlaylistKey);
+}
+// Every channel's own playlist, by channel id.
+export function readChannelPlaylists(db) {
+    const prefix = studioChannelPlaylistPrefix;
+    const rows = db
+        .prepare("SELECT key FROM settings WHERE substr(key, 1, ?) = ? ORDER BY key")
+        .all(prefix.length, prefix);
+    const out = {};
+    for (const { key } of rows) {
+        const value = storedPlaylist(db, key);
+        if (value !== null)
+            out[key.slice(prefix.length)] = value;
+    }
+    return out;
+}
+function storedPlaylist(db, key) {
+    const stored = readSetting(db, key);
+    if (stored === undefined)
+        return null;
+    try {
+        const value = JSON.parse(stored);
+        return typeof value === "string" && value.trim() !== "" ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function studioPlaylistProblem(raw) {
+    return raw.trim().length > studioPlaylistMax
+        ? `The playlist name is longer than YouTube allows (${String(studioPlaylistMax)} characters). Shorten it in Settings → YouTube Studio.`
+        : undefined;
+}
+// Saves the default playlist, or a channel's own; empty clears it (the channel then uses the
+// default again).
+export function saveStudioPlaylist(db, raw, channelId) {
+    const value = raw.trim();
+    const key = playlistKey(channelId);
+    if (value === "") {
+        db.prepare("DELETE FROM settings WHERE key = ?").run(key);
+        return null;
+    }
+    writeSetting(db, key, JSON.stringify(value));
+    return value;
+}
+// The projects whose uploaded clips are real footage (filmed, not generated): ticked in the
+// project's Prepare upload, under AI use. One row holding their ids; YouTube's second AI use
+// case is footage of a real event or place altered by AI (`disclosure.ts`).
+export const studioRealFootageKey = "studio.realFootage";
+function realFootageIds(db) {
+    const stored = readSetting(db, studioRealFootageKey);
+    if (stored === undefined)
+        return [];
+    try {
+        const value = JSON.parse(stored);
+        return Array.isArray(value)
+            ? value.filter((one) => typeof one === "string")
+            : [];
+    }
+    catch {
+        return [];
+    }
+}
+export function readRealFootage(db, projectId) {
+    return realFootageIds(db).includes(projectId);
+}
+export function saveRealFootage(db, projectId, on) {
+    const others = realFootageIds(db).filter((one) => one !== projectId);
+    const next = on ? [...others, projectId].sort() : others;
+    if (next.length === 0)
+        db.prepare("DELETE FROM settings WHERE key = ?").run(studioRealFootageKey);
+    else
+        writeSetting(db, studioRealFootageKey, JSON.stringify(next));
+}
+// The pairing token, made on first read. One per install: a new one (Settings → YouTube
+// Studio → New pairing token) forgets the extension that used the old one.
+export function studioPairing(db) {
+    const stored = readSetting(db, studioPairingKey);
+    if (stored !== undefined) {
+        try {
+            const parsed = pairingSchema.safeParse(JSON.parse(stored));
+            if (parsed.success)
+                return parsed.data;
+        }
+        catch {
+            // A damaged row is replaced below.
+        }
+    }
+    return resetStudioPairing(db);
+}
+// What is waiting to be filled in Studio is kept per pairing (`queue.ts`): one row,
+// `studio.fillQueue.<token hash>`, so a new token starts with nothing waiting.
+export const studioFillQueuePrefix = "studio.fillQueue.";
+export function resetStudioPairing(db) {
+    const pairing = {
+        token: randomBytes(24).toString("base64url"),
+        origin: null,
+        pairedAt: null,
+    };
+    db.prepare("DELETE FROM settings WHERE substr(key, 1, ?) = ?").run(studioFillQueuePrefix.length, studioFillQueuePrefix);
+    writeSetting(db, studioPairingKey, JSON.stringify(pairing));
+    return pairing;
+}
+// A browser extension's own origin: Chrome's and Firefox's. Web pages never match.
+export function isExtensionOrigin(origin) {
+    return (origin !== undefined && /^(chrome-extension|moz-extension):\/\/[a-z0-9-]{1,64}$/.test(origin));
+}
+export function tokenMatches(pairing, given) {
+    if (given === undefined)
+        return false;
+    const a = Buffer.from(pairing.token);
+    const b = Buffer.from(given);
+    return a.length === b.length && timingSafeEqual(a, b);
+}
+// The token from an `Authorization: Bearer <token>` header.
+export function bearerToken(header) {
+    const match = /^Bearer\s+(\S+)$/.exec(header ?? "");
+    return match?.[1];
+}
+// The extension pairs by sending the token from its own origin; that origin is then the only
+// one the app answers across origins, until a new token is made.
+export function pairStudioExtension(db, token, origin, now) {
+    const pairing = studioPairing(db);
+    if (!tokenMatches(pairing, token))
+        return { ok: false, reason: "bad-token" };
+    if (!isExtensionOrigin(origin))
+        return { ok: false, reason: "not-an-extension" };
+    const next = { ...pairing, origin, pairedAt: now.toISOString() };
+    writeSetting(db, studioPairingKey, JSON.stringify(next));
+    return { ok: true, pairing: next };
+}
+// Whether a request may read upload packs: the right token, and, when the browser names its
+// origin, the paired extension's. A request with no Origin (not from a web page at all) is
+// judged on the token alone.
+export function studioRequestAllowed(db, token, origin) {
+    const pairing = studioPairing(db);
+    if (!tokenMatches(pairing, token))
+        return false;
+    if (origin === undefined)
+        return true;
+    return pairing.origin !== null && origin === pairing.origin;
+}

package/dist/slices/style-preview/images.js

@@ -0,0 +1,61 @@
+import { createHash } from "node:crypto";
+import { readFileSync, statSync } from "node:fs";
+import { imageBlob } from "../channels/repo.js";
+import { outputPath, stagingPath } from "../storage/layout.js";
+import { outputById, stagedFileById } from "../storage/repo.js";
+// ceiling: a provider's image or an upload is a few MB; anything this large is not a picture
+// worth reading into memory for a 270-pixel preview.
+const maxBytes = 40 * 1024 * 1024;
+// Roles whose file is a single still picture.
+const pictureRoles = new Set(["reference", "image", "thumbnail", "short_image"]);
+export function previewPictures(deps) {
+    return (image) => {
+        try {
+            const bytes = read(deps, image);
+            if (bytes === undefined)
+                return undefined;
+            const extension = pictureExtension(bytes);
+            if (extension === undefined)
+                return undefined;
+            return { bytes, extension, sha256: createHash("sha256").update(bytes).digest("hex") };
+        }
+        catch {
+            return undefined;
+        }
+    };
+}
+function read(deps, image) {
+    switch (image.kind) {
+        case "picture":
+            return imageBlob(deps.db, image.sha256)?.bytes;
+        case "upload": {
+            const staged = stagedFileById(deps.db, image.stagedFileId);
+            if (staged === undefined || staged.state !== "staged")
+                return undefined;
+            return readSmall(stagingPath(deps.paths, staged.id));
+        }
+        case "output": {
+            const output = outputById(deps.db, image.outputId);
+            if (output === undefined || !pictureRoles.has(output.role))
+                return undefined;
+            return readSmall(outputPath(deps.paths, output.projectId, output.path));
+        }
+    }
+}
+function readSmall(path) {
+    const size = statSync(path).size;
+    if (size === 0 || size > maxBytes)
+        return undefined;
+    return new Uint8Array(readFileSync(path));
+}
+export function pictureExtension(bytes) {
+    const starts = (...values) => values.every((value, at) => bytes[at] === value);
+    if (starts(0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a))
+        return ".png";
+    if (starts(0xff, 0xd8, 0xff))
+        return ".jpg";
+    const ascii = (from, to) => String.fromCharCode(...bytes.subarray(from, to));
+    if (ascii(0, 4) === "RIFF" && ascii(8, 12) === "WEBP")
+        return ".webp";
+    return undefined;
+}

package/dist/slices/style-preview/narration.js

@@ -0,0 +1,33 @@
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+// The sample a preview is made of: six seconds of the bundled sample project's narration
+// ("The Library of Alexandria", `assets/sample/sample-project.tar`) with the word timing its
+// alignment found, and three of its images in each shape. Taken once, offline, from the body
+// narration at 3.4 s (the video's 4.4 s, after its one second of edge silence); the words are
+// on the clip's own timeline. Nothing here is generated at preview time.
+export const sampleNarrationSeconds = 6;
+export const sampleNarrationWords = [
+    { text: "Around", start: 0.5, end: 0.88 },
+    { text: "three", start: 1.14, end: 1.36 },
+    { text: "hundred", start: 1.46, end: 1.78 },
+    { text: "years", start: 1.88, end: 2.26 },
+    { text: "before", start: 2.4, end: 2.78 },
+    { text: "our", start: 2.92, end: 3.02 },
+    { text: "era,", start: 3.22, end: 3.4 },
+    { text: "on", start: 4.18, end: 4.22 },
+    { text: "the", start: 4.3, end: 4.36 },
+    { text: "coast", start: 4.44, end: 4.72 },
+    { text: "of", start: 4.84, end: 4.88 },
+    { text: "Egypt,", start: 5.06, end: 5.4 },
+];
+export const sampleNarrationText = sampleNarrationWords.map((word) => word.text).join(" ");
+// The sample project's title, the headline a Shorts preview shows when none is given.
+export const sampleShortTitle = "The Library of Alexandria";
+export function bundledSampleAssets(dir = fileURLToPath(new URL("../../assets/style-preview/", import.meta.url))) {
+    const at = (name) => join(dir, name);
+    return {
+        narration: at("narration.mp3"),
+        wide: [1, 2, 3].map((n) => at(`wide-${String(n)}.jpg`)),
+        tall: [1, 2, 3].map((n) => at(`tall-${String(n)}.jpg`)),
+    };
+}