@gentbajko/slopify 2.4.0 → 3.0.0

package/dist/slices/youtube/chapters.js

@@ -0,0 +1,126 @@
+// Chapters as YouTube takes them. YouTube turns the timestamps of a description into chapters
+// only when the first is at 0:00, there are at least three, each lasts at least ten seconds and
+// they go up in time; otherwise it ignores the whole list. The step's answer is checked against
+// those rules when it is written (`answer.ts`), but a hand edit, or a video cut again to another
+// length after the description was written, can break them. So the chapters are fitted when the
+// description is shown or copied, never stored: the generated file, the user's edit and every
+// fingerprint stay as they were, and the page says what was changed. Pure and browser-safe.
+import { minChapterSeconds, minChapters } from "./model.js";
+import { parseTimestamp, youtubeTimestamp } from "./timestamps.js";
+// "M:SS Title": a time YouTube reads, then a title.
+function chapterLine(line) {
+    const trimmed = line.trim();
+    const match = /^(\S+)\s+(.+)$/u.exec(trimmed);
+    if (match === null)
+        return undefined;
+    const start = parseTimestamp(match[1] ?? "");
+    const title = (match[2] ?? "").trim();
+    return start === undefined || title === "" ? undefined : { start, title };
+}
+// Fits one chapters field (one "M:SS Title" per line) to YouTube's rules, in this order:
+// 1. chapters out of time order are put in order, and of two at the same time the one listed
+//    first stays;
+// 2. with the video's length known, a chapter starting at or after its end is removed;
+// 3. the first chapter moves to 0:00;
+// 4. the first chapter shorter than ten seconds is merged into its neighbour, again until none
+//    is: into the one before it (whose title stays), or, for the first chapter, into the one
+//    after it, which then starts at 0:00. The last chapter's length is only known with the
+//    video's length;
+// 5. with fewer than three chapters left, the list is dropped, since YouTube would ignore it.
+// Other lines in the field (a note the user typed) stay where they were. When anything changed,
+// the chapter lines are rewritten in YouTube's M:SS form.
+export function fitChapters(text, durationSeconds) {
+    const lines = text.replace(/\r\n?/gu, "\n").split("\n");
+    const slots = [];
+    const found = [];
+    for (const [index, line] of lines.entries()) {
+        const chapter = chapterLine(line);
+        if (chapter === undefined)
+            continue;
+        slots.push(index);
+        found.push(chapter);
+    }
+    if (found.length === 0)
+        return { text, adjustments: [] };
+    const adjustments = [];
+    const quoted = (chapter) => `"${chapter.title}"`;
+    let chapters = [...found].sort((a, b) => a.start - b.start);
+    if (chapters.some((chapter, index) => chapter !== found[index]))
+        adjustments.push("put the chapters in time order");
+    // Two chapters at the same time: the one listed first keeps it.
+    const distinct = [];
+    for (const chapter of chapters) {
+        const previous = distinct.at(-1);
+        if (previous !== undefined && previous.start === chapter.start)
+            adjustments.push(`merged ${quoted(chapter)} (0 s) into ${quoted(previous)}`);
+        else
+            distinct.push(chapter);
+    }
+    chapters = distinct;
+    const end = durationSeconds !== undefined && Number.isFinite(durationSeconds) && durationSeconds > 0
+        ? durationSeconds
+        : undefined;
+    if (end !== undefined) {
+        const after = chapters.filter((chapter, index) => index > 0 && chapter.start >= end);
+        for (const chapter of after)
+            adjustments.push(`removed ${quoted(chapter)} (${youtubeTimestamp(chapter.start)}), which starts after the video ends at ${youtubeTimestamp(end)}`);
+        chapters = chapters.filter((chapter) => !after.includes(chapter));
+    }
+    const first = chapters[0];
+    if (first !== undefined && first.start !== 0) {
+        adjustments.push(`moved the first, ${quoted(first)}, from ${youtubeTimestamp(first.start)} to 0:00`);
+        chapters = [{ start: 0, title: first.title }, ...chapters.slice(1)];
+    }
+    const length = (index) => {
+        const next = chapters[index + 1];
+        const start = chapters[index]?.start ?? 0;
+        if (next !== undefined)
+            return next.start - start;
+        return end === undefined ? Number.POSITIVE_INFINITY : end - start;
+    };
+    const seconds = (value) => `${String(Math.max(0, Math.floor(value)))} s`;
+    while (chapters.length > 1) {
+        const short = chapters.findIndex((_, index) => length(index) < minChapterSeconds);
+        if (short === -1)
+            break;
+        const chapter = chapters[short];
+        if (chapter === undefined)
+            break;
+        const lasted = seconds(length(short));
+        if (short === 0) {
+            const next = chapters[1];
+            if (next === undefined)
+                break;
+            adjustments.push(`merged ${quoted(chapter)} (${lasted}) into ${quoted(next)}`);
+            chapters = [{ start: 0, title: next.title }, ...chapters.slice(2)];
+        }
+        else {
+            const previous = chapters[short - 1];
+            if (previous === undefined)
+                break;
+            adjustments.push(`merged ${quoted(chapter)} (${lasted}) into ${quoted(previous)}`);
+            chapters = chapters.filter((_, index) => index !== short);
+        }
+    }
+    if (chapters.length < minChapters) {
+        adjustments.push(`left the chapter list out, since YouTube needs at least ${String(minChapters)} chapters of ${String(minChapterSeconds)} s or more and only ${String(chapters.length)} ${chapters.length === 1 ? "is" : "are"} left`);
+        chapters = [];
+    }
+    if (adjustments.length === 0)
+        return { text, adjustments };
+    // The chapters go back into the first slots in order; the slots left over are removed.
+    const bySlot = new Map(slots.map((slot, index) => [slot, chapters[index]]));
+    const rewritten = lines.flatMap((line, index) => {
+        if (!bySlot.has(index))
+            return [line];
+        const chapter = bySlot.get(index);
+        return chapter === undefined ? [] : [`${youtubeTimestamp(chapter.start)} ${chapter.title}`];
+    });
+    return { text: rewritten.join("\n").trim(), adjustments };
+}
+// The sentence shown beside the description; undefined when nothing was changed.
+export function chapterNotice(adjustments) {
+    return adjustments.length === 0
+        ? undefined
+        : `Chapters adjusted for YouTube: ${adjustments.join("; ")}.`;
+}

package/dist/slices/youtube/edits-repo.js

@@ -0,0 +1,69 @@
+// Where the hand edits and the channel links are kept: the edits per project in
+// `youtube_description_edits`, the Settings list of links as one `settings` row.
+import { z } from "zod";
+import { readSetting, writeSetting } from "../settings/repo.js";
+import { chapterNotice, fitChapters } from "./chapters.js";
+import { composeDescription, descriptionFields, resolveFields, shownFields, splitDescription, } from "./edits.js";
+import { fillPlaceholders, mergeLinks } from "./placeholders.js";
+export const channelLinksKey = "channel_links";
+const fieldEdit = z.object({ base: z.string(), text: z.string() }).strict();
+const editsSchema = z
+    .object(Object.fromEntries(descriptionFields.map((field) => [field, fieldEdit.optional()])))
+    .strict();
+const linksSchema = z.array(z.object({ name: z.string(), url: z.string() }).strict());
+const none = { fields: {}, links: [] };
+export function readDescriptionEdits(db, projectId) {
+    const row = db
+        .prepare("SELECT fields_json,links_json FROM youtube_description_edits WHERE project_id=?")
+        .get(projectId);
+    if (row === undefined)
+        return none;
+    const parsed = z.object({ fields_json: z.string(), links_json: z.string() }).parse(row);
+    return {
+        fields: editsSchema.parse(JSON.parse(parsed.fields_json)),
+        links: linksSchema.parse(JSON.parse(parsed.links_json)),
+    };
+}
+export function writeDescriptionEdits(db, projectId, edits, updatedAt) {
+    if (Object.keys(edits.fields).length === 0 && edits.links.length === 0) {
+        db.prepare("DELETE FROM youtube_description_edits WHERE project_id=?").run(projectId);
+        return;
+    }
+    db.prepare(`INSERT INTO youtube_description_edits (project_id,fields_json,links_json,updated_at) VALUES (?,?,?,?)
+     ON CONFLICT(project_id) DO UPDATE SET fields_json=excluded.fields_json,links_json=excluded.links_json,updated_at=excluded.updated_at`).run(projectId, JSON.stringify(edits.fields), JSON.stringify(edits.links), updatedAt);
+}
+export function readChannelLinks(db) {
+    const value = readSetting(db, channelLinksKey);
+    if (value === undefined)
+        return [];
+    // A hand-edited row that no longer parses reads as no links rather than breaking the page;
+    // saving the list in Settings writes a good one again.
+    try {
+        const parsed = linksSchema.safeParse(JSON.parse(value));
+        return parsed.success ? parsed.data : [];
+    }
+    catch {
+        return [];
+    }
+}
+export function writeChannelLinks(db, links) {
+    writeSetting(db, channelLinksKey, JSON.stringify(links.map((link) => ({ name: link.name.trim(), url: link.url.trim() }))));
+}
+// The description and tags as the project page shows and copies them: the user's edits over
+// the generated text, the chapters fitted to YouTube's rules (`chapters.ts`; the last one's
+// length only checked when the video's length is given), placeholders filled from the
+// project's and Settings' links (one with no link stays as typed). For anything that hands the
+// description on, such as Prepare upload. `chapterNotice` says what the fitting changed.
+export function effectiveDescription(db, projectId, generated) {
+    const edits = readDescriptionEdits(db, projectId);
+    const shown = shownFields(resolveFields(splitDescription(generated.description, generated.tags), edits.fields));
+    const fitted = fitChapters(shown.chapters, generated.durationSeconds);
+    const notice = chapterNotice(fitted.adjustments);
+    const links = mergeLinks(readChannelLinks(db), edits.links);
+    return {
+        description: fillPlaceholders(composeDescription({ ...shown, chapters: fitted.text }), links)
+            .text,
+        tags: fillPlaceholders(shown.tags, links).text,
+        ...(notice === undefined ? {} : { chapterNotice: notice }),
+    };
+}

package/dist/slices/youtube/edits.js

@@ -0,0 +1,89 @@
+// Hand edits to the YouTube description. The project page lets the user edit the summary,
+// the chapters, the hashtags and the tags in place; each edit is saved with the generated
+// text it was made from (`base`), so when the description is written again the page can tell
+// a field the user changed from one they left alone. Browser-safe: the project page applies
+// these rules to what it shows, and the server only stores the edits.
+import { parseTimestamp } from "./timestamps.js";
+export const descriptionFields = ["summary", "chapters", "hashtags", "tags"];
+// Splits a written description back into its three parts. `assembleDescription` (answer.ts) lays it out as
+// the summary, a blank line, one chapter per line, a blank line and the hashtags; reading it
+// from the end keeps a summary with blank lines of its own whole.
+export function splitDescription(description, tags) {
+    const lines = description.replace(/\r\n?/gu, "\n").split("\n");
+    while (lines.length > 0 && lines.at(-1)?.trim() === "")
+        lines.pop();
+    let hashtags = "";
+    const last = lines.at(-1)?.trim() ?? "";
+    if (last !== "" && last.split(/\s+/u).every((word) => /^#[\p{L}\p{N}_]+$/u.test(word))) {
+        hashtags = last;
+        lines.pop();
+    }
+    while (lines.length > 0 && lines.at(-1)?.trim() === "")
+        lines.pop();
+    const chapters = [];
+    while (lines.length > 0 && isChapterLine(lines.at(-1) ?? "")) {
+        chapters.unshift((lines.pop() ?? "").trim());
+    }
+    return {
+        summary: lines.join("\n").trim(),
+        chapters: chapters.join("\n"),
+        hashtags,
+        tags: tags.trim(),
+    };
+}
+function isChapterLine(line) {
+    const [time = "", ...title] = line.trim().split(/\s+/u);
+    return parseTimestamp(time) !== undefined && title.length > 0;
+}
+// The description as YouTube takes it, from the fields as shown: the same layout
+// `assembleDescription` writes, leaving out a part the user emptied.
+export function composeDescription(fields) {
+    return [fields.summary.trim(), fields.chapters.trim(), fields.hashtags.trim()]
+        .filter((part) => part !== "")
+        .join("\n\n");
+}
+// The rules for one field:
+// - never edited: the generated text;
+// - edited, and the generated text is still the one the edit started from: the user's text;
+// - edited, and the generated text changed since: the user's text, with the new generated text
+//   pending for the user to take or dismiss - unless the two now agree, and then there is
+//   nothing to choose;
+// - not written yet: the user's text if there is one, otherwise nothing.
+export function resolveField(generated, edit) {
+    if (edit === undefined)
+        return { text: generated ?? "", edited: false };
+    if (generated === undefined || edit.base === generated)
+        return { text: edit.text, edited: true };
+    if (edit.text === generated)
+        return { text: generated, edited: false };
+    return { text: edit.text, edited: true, pending: generated };
+}
+export function resolveFields(generated, edits) {
+    const one = (field) => resolveField(generated?.[field], edits[field]);
+    return {
+        summary: one("summary"),
+        chapters: one("chapters"),
+        hashtags: one("hashtags"),
+        tags: one("tags"),
+    };
+}
+export function shownFields(resolved) {
+    return {
+        summary: resolved.summary.text,
+        chapters: resolved.chapters.text,
+        hashtags: resolved.hashtags.text,
+        tags: resolved.tags.text,
+    };
+}
+// Saving an edit: text equal to the generated text is no edit at all, so the field follows the
+// next regeneration again.
+export function withEdit(edits, field, text, generated) {
+    if (text === generated)
+        return withoutEdit(edits, field);
+    return { ...edits, [field]: { base: generated, text } };
+}
+// "Use it": the field follows the generated text again.
+export function withoutEdit(edits, field) {
+    const { [field]: _dropped, ...rest } = edits;
+    return rest;
+}

package/dist/slices/youtube/placeholders.js

@@ -0,0 +1,98 @@
+// Channel links and the placeholders that use them. A description (the generated one, the
+// user's edit, or what a Description prompt told the model to write) can hold `{{Patreon}}` or
+// `{{Previous video}}`; they are filled from the saved links when the description is shown or
+// copied, never when it is written, so changing a link changes every description at once.
+// A placeholder with no link of that name stays in the text as typed and is marked, never
+// silently dropped. Browser-safe.
+// The link YouTube descriptions most often point at, and the one that changes per project:
+// the project page offers it by name, and a project's own value wins over the Settings list.
+export const previousVideoLink = "Previous video";
+export const channelLinkNameMax = 60;
+export const channelLinkUrlMax = 2000;
+export const channelLinksMax = 50;
+const placeholder = /\{\{([^{}\n]{1,80})\}\}/gu;
+// Names match without regard to case or repeated spaces: `{{previous  video}}` is the
+// "Previous video" link.
+export function linkKey(name) {
+    return name.trim().replace(/\s+/gu, " ").toLowerCase();
+}
+// The project's own links first, so one of the same name replaces the Settings one.
+export function mergeLinks(settings, project) {
+    const seen = new Set();
+    const merged = [];
+    for (const link of [...project, ...settings]) {
+        const key = linkKey(link.name);
+        if (seen.has(key) || link.url.trim() === "")
+            continue;
+        seen.add(key);
+        merged.push(link);
+    }
+    return merged;
+}
+export function placeholderParts(text, links) {
+    const byName = new Map(links.map((link) => [linkKey(link.name), link.url]));
+    const parts = [];
+    let at = 0;
+    for (const match of text.matchAll(placeholder)) {
+        const index = match.index;
+        if (index > at)
+            parts.push({ kind: "text", text: text.slice(at, index) });
+        const name = (match[1] ?? "").trim();
+        parts.push({ kind: "placeholder", raw: match[0], name, url: byName.get(linkKey(name)) });
+        at = index + match[0].length;
+    }
+    if (at < text.length)
+        parts.push({ kind: "text", text: text.slice(at) });
+    return parts;
+}
+export function fillPlaceholders(text, links) {
+    const unknown = [];
+    const filled = placeholderParts(text, links)
+        .map((part) => {
+        if (part.kind === "text")
+            return part.text;
+        if (part.url !== undefined)
+            return part.url;
+        if (!unknown.some((name) => linkKey(name) === linkKey(part.name)))
+            unknown.push(part.name);
+        return part.raw;
+    })
+        .join("");
+    return { text: filled, unknown };
+}
+// Why a list of links cannot be saved, in the words Settings shows; undefined when it can.
+export function channelLinksProblem(links) {
+    if (links.length > channelLinksMax)
+        return `Keep at most ${String(channelLinksMax)} channel links. Remove some in Settings → Channel links.`;
+    const seen = new Set();
+    for (const [index, link] of links.entries()) {
+        const row = `Link ${String(index + 1)}`;
+        const name = link.name.trim();
+        if (name === "")
+            return `${row} has no name. Give it one, such as Patreon.`;
+        if (name.length > channelLinkNameMax)
+            return `${row}'s name is over ${String(channelLinkNameMax)} characters. Shorten it.`;
+        if (/[{}]/u.test(name))
+            return `${row}'s name contains { or }. Use the name alone; the description writes it as {{${name.replace(/[{}]/gu, "")}}}.`;
+        if (seen.has(linkKey(name)))
+            return `Two links are named "${name}". Rename one, since {{${name}}} can only fill with one.`;
+        seen.add(linkKey(name));
+        const url = link.url.trim();
+        if (url.length > channelLinkUrlMax)
+            return `The "${name}" link is over ${String(channelLinkUrlMax)} characters. Use a shorter address.`;
+        if (url === "")
+            return `The "${name}" link has no address. Paste it, starting with https://.`;
+        if (!isWebAddress(url))
+            return `The "${name}" link is not a web address. Paste the full address, starting with https://.`;
+    }
+    return undefined;
+}
+function isWebAddress(url) {
+    try {
+        const parsed = new URL(url);
+        return parsed.protocol === "https:" || parsed.protocol === "http:";
+    }
+    catch {
+        return false;
+    }
+}

package/dist/slices/youtube/transcript.js

@@ -51,7 +51,9 @@ const sentenceLongestSeconds = 30;
 // The narration as numbered sentences, for the Shorts step: the model picks clips by
 // sentence number and Slopify cuts at the sentences' own word times, so a clip never starts
 // or ends mid-word. A sentence closes at its full stop, question or exclamation mark, at a
-// pause of 1.5 s (the gap between intro, body and outro), or after 30 s.
+// pause of 1.5 s (the gap between intro, body and outro), or after 30 s. On a multi-voice run
+// it also closes where one speaker's turn ends, so a clip always starts and ends on a turn's
+// sentence and never cuts a speaker off mid-line.
 export function transcriptSentences(words) {
     const sentences = [];
     let first = -1;
@@ -73,6 +75,7 @@ export function transcriptSentences(words) {
                 text,
                 firstWord: first,
                 lastWord: last,
+                ...(opening.speaker === undefined ? {} : { speaker: opening.speaker }),
             });
         first = -1;
     };
@@ -82,6 +85,7 @@ export function transcriptSentences(words) {
         if (opening !== undefined &&
             previous !== undefined &&
             (word.start - previous.end >= pauseSeconds ||
+                word.turn !== previous.turn ||
                 word.end - opening.start > sentenceLongestSeconds))
             flush(index - 1);
         if (first < 0)
@@ -93,9 +97,12 @@ export function transcriptSentences(words) {
     return sentences;
 }
 // One sentence per line, led by its number and its span in the video, which is what the
-// model picks from.
-export function sentencesText(sentences) {
+// model picks from; on a multi-voice run, with the speaker's name before the words.
+export function sentencesText(sentences, names) {
     return sentences
-        .map((sentence) => `[${String(sentence.number)}] (${youtubeTimestamp(sentence.start)}-${youtubeTimestamp(sentence.end)}) ${sentence.text}`)
+        .map((sentence) => {
+        const name = sentence.speaker === undefined ? undefined : names?.[sentence.speaker];
+        return `[${String(sentence.number)}] (${youtubeTimestamp(sentence.start)}-${youtubeTimestamp(sentence.end)}) ${name === undefined ? "" : `${name}: `}${sentence.text}`;
+    })
         .join("\n");
 }

package/dist/updater/service.js

@@ -1,6 +1,7 @@
 import { timingSafeEqual } from "node:crypto";
 import { setImmediate } from "node:timers";
 import { isStableVersion, isUpdateToken, newerVersion } from "./model.js";
+const waitCheckMs = 5_000;
 export function createUpdater(deps) {
     let latestVersion = null;
     let checkedAt = -Infinity;
@@ -13,17 +14,30 @@ export function createUpdater(deps) {
     let checking;
     let settling;
     let mutations = 0;
+    // The version a `waiting` update will install, and the stop of the timer watching for idle.
+    let pending;
+    let stopWatching;
+    const every = deps.every ??
+        ((callback, ms) => {
+            const timer = setInterval(callback, ms);
+            timer.unref();
+            return () => clearInterval(timer);
+        });
     const busyNow = () => deps.busy() || mutations > 0;
     const locked = () => status === "installing" || status === "restarting";
+    // A function, not a comparison, because an await in between may have changed it.
+    const waiting = () => status === "waiting";
     function info() {
         const busy = busyNow();
         const available = latestVersion !== null && newerVersion(latestVersion, deps.currentVersion);
+        // Running work no longer blocks an update: it waits for the work (`waiting`).
         const blockedReason = deps.unsupported() ??
-            (busy
-                ? "Pause running projects and wait for their active work to stop before updating."
-                : locked()
-                    ? "An update is already in progress."
+            (locked()
+                ? "An update is already in progress."
+                : status === "waiting"
+                    ? "An update is already waiting for running work to finish."
                     : undefined);
+        const waitingFor = busy ? deps.busyWith?.() : undefined;
         return {
             currentVersion: deps.currentVersion,
             latestVersion,
@@ -33,10 +47,41 @@ export function createUpdater(deps) {
             status,
             ...(error === undefined ? {} : { error }),
             ...(blockedReason === undefined ? {} : { blockedReason }),
+            ...(status === "waiting" && pending !== undefined ? { pendingVersion: pending } : {}),
+            ...(waitingFor === undefined ? {} : { waitingFor }),
         };
     }
+    function install(version) {
+        status = "installing";
+        error = undefined;
+        void Promise.resolve()
+            .then(() => deps.install(version, () => {
+            status = "restarting";
+        }))
+            .catch(() => {
+            status = "error";
+            error =
+                "The update could not be installed, so Slopify kept your current version. Check your internet connection and try again; the reason is in logs/updates.log inside your Slopify data folder.";
+            installError = error;
+            deps.report(error);
+        });
+    }
+    // Looks again every few seconds and installs the moment no work is running.
+    function wait(version) {
+        pending = version;
+        status = "waiting";
+        error = undefined;
+        stopWatching = every(() => {
+            if (status !== "waiting" || busyNow())
+                return;
+            stopWatching?.();
+            stopWatching = undefined;
+            pending = undefined;
+            install(version);
+        }, waitCheckMs);
+    }
     async function check(refresh = false) {
-        if (locked())
+        if (locked() || status === "waiting")
             return info();
         if (checking !== undefined) {
             await checking;
@@ -122,7 +167,7 @@ export function createUpdater(deps) {
             };
         },
         start: async () => {
-            if (locked() || busyNow())
+            if (locked() || waiting())
                 return { ok: false, code: 409, info: info() };
             installError = undefined;
             await check(true);
@@ -130,25 +175,25 @@ export function createUpdater(deps) {
             if (!current.canUpdate || latestVersion === null || current.status === "error") {
                 return {
                     ok: false,
-                    code: current.busy || locked() ? 409 : current.status === "error" ? 503 : 400,
+                    code: locked() || waiting() ? 409 : current.status === "error" ? 503 : 400,
                     info: current,
                 };
             }
-            status = "installing";
-            error = undefined;
-            const version = latestVersion;
-            void Promise.resolve()
-                .then(() => deps.install(version, () => {
-                status = "restarting";
-            }))
-                .catch(() => {
-                status = "error";
-                error =
-                    "The update could not be installed, so Slopify kept your current version. Check your internet connection and try again; the reason is in logs/updates.log inside your Slopify data folder.";
-                installError = error;
-                deps.report(error);
-            });
+            // Rechecked after the registry await: a project may have started meanwhile.
+            if (busyNow())
+                wait(latestVersion);
+            else
+                install(latestVersion);
             return { ok: true, info: info() };
         },
+        cancelWaiting: () => {
+            if (status !== "waiting")
+                return false;
+            stopWatching?.();
+            stopWatching = undefined;
+            pending = undefined;
+            status = "idle";
+            return true;
+        },
     };
 }