@gentbajko/slopify 3.2.6 → 3.2.8

package/dist/edge/http/studio.js

@@ -11,6 +11,7 @@ import { studioPlaylistMax } from "../../slices/studio/model.js";
 import { packItem, uploadPack } from "../../slices/studio/pack.js";
 import { enqueueFill, readFillQueue, removeFill, } from "../../slices/studio/queue.js";
 import { bearerToken, isExtensionOrigin, pairStudioExtension, readChannelPlaylists, readStudioPlaylists, resetStudioPairing, saveProjectPlaylists, saveRealFootage, saveStudioPlaylists, studioPairing, studioPlaylistsMax, studioPlaylistsProblem, studioRequestAllowed, } from "../../slices/studio/settings.js";
+import { forgetVideo, projectVideos, recordVideo, setAbState, videoIdOf, videoIdPattern, waitingAbTests, } from "../../slices/studio/videos.js";
 import { onInvalid, problem, titleOf } from "./problem.js";
 const id = z
     .string()
@@ -45,6 +46,20 @@ const projectPlaylistsBody = z.object({
     playlists: z.array(z.string().max(studioPlaylistMax)).max(studioPlaylistsMax).nullable(),
 });
 const realFootageBody = z.object({ realFootage: z.boolean() });
+const shortField = z.number().int().min(1).max(99).nullable().optional();
+const extVideoBody = z.object({
+    projectId: id,
+    short: shortField,
+    videoId: z.string().regex(videoIdPattern),
+});
+const abResultBody = z.object({
+    projectId: id,
+    short: shortField,
+    ok: z.boolean(),
+    message: z.string().max(2000),
+});
+const videoLinkBody = z.object({ short: shortField, link: z.string().max(500) });
+const abTestBody = z.object({ short: shortField, start: z.boolean() });
 // The extension builds the app ships (`scripts/copy-extension.mjs`), by browser.
 const extensionFiles = {
     "chrome.zip": "slopify-studio-chrome.zip",
@@ -91,6 +106,13 @@ export function studioRoutes(deps) {
         title: "Unauthorized",
         detail: "The Slopify Studio extension isn't paired with this Slopify. Copy the pairing token from Slopify's Settings → YouTube Studio into the extension's options and press Pair.",
     });
+    const extAllowed = (c) => studioRequestAllowed(deps.db, bearerToken(c.req.header("authorization")), c.req.header("origin"));
+    // An upload has an A/B test to run when it has other titles or more than one thumbnail.
+    const abTestable = (projectId, short) => {
+        const result = uploadPack(deps, projectId);
+        const item = result.ok ? packItem(result.pack, short ?? undefined) : undefined;
+        return item !== undefined && (item.titles.length > 0 || item.thumbnails.length > 1);
+    };
     return (new Hono()
         .get("/settings", (c) => {
         // The token is read only by the Slopify page, never by another origin's.
@@ -182,6 +204,52 @@ export function studioRoutes(deps) {
         return c.json({ chosen: { projectId, short: short ?? null }, queue: queueView(queue) });
     })
         // What waits for the extension, oldest first: each new upload dialog takes the first.
+        // The YouTube videos a project's uploads became, and their A/B tests.
+        .get("/videos/:projectId", zValidator("param", projectParam, onInvalid), (c) => c.json({ videos: projectVideos(deps.db, c.req.valid("param").projectId) }))
+        // A video's link pasted in Slopify, for an upload made without the extension; an empty
+        // link forgets it.
+        .put("/videos/:projectId", zValidator("param", projectParam, onInvalid), zValidator("json", videoLinkBody, onInvalid), (c) => {
+        const wrong = samePage(c);
+        if (wrong !== undefined)
+            return wrong;
+        const { projectId } = c.req.valid("param");
+        const { short, link } = c.req.valid("json");
+        if (link.trim() === "") {
+            forgetVideo(deps.db, projectId, short ?? null);
+            return c.json({ videos: projectVideos(deps.db, projectId) });
+        }
+        const videoId = videoIdOf(link);
+        if (videoId === undefined)
+            return problem(c, {
+                status: 400,
+                title: titleOf(400),
+                detail: "That isn't a YouTube video link. Copy the video's link from YouTube Studio (Details → Video link, like https://youtu.be/…) and paste it again.",
+            });
+        recordVideo(deps.db, projectId, short ?? null, videoId, deps.clock.now().toISOString());
+        return c.json({ videos: projectVideos(deps.db, projectId) });
+    })
+        // Start A/B test (or Cancel): the extension starts it once the video is public.
+        .post("/videos/:projectId/ab-test", zValidator("param", projectParam, onInvalid), zValidator("json", abTestBody, onInvalid), (c) => {
+        const wrong = samePage(c);
+        if (wrong !== undefined)
+            return wrong;
+        const { projectId } = c.req.valid("param");
+        const { short, start } = c.req.valid("json");
+        if (start && !abTestable(projectId, short ?? null))
+            return problem(c, {
+                status: 409,
+                title: titleOf(409),
+                detail: "There is nothing to A/B test: this upload has one thumbnail and no other titles. Make more thumbnails (Edit project → Thumbnail) or let the YouTube step write other titles, then try again.",
+            });
+        const set = setAbState(deps.db, projectId, short ?? null, start ? "waiting" : "none", null, deps.clock.now().toISOString());
+        if (!set)
+            return problem(c, {
+                status: 409,
+                title: titleOf(409),
+                detail: "Slopify doesn't know this upload's YouTube video yet. Paste its link (from YouTube Studio → Details → Video link) first.",
+            });
+        return c.json({ videos: projectVideos(deps.db, projectId) });
+    })
         .get("/queue", (c) => {
         const denied = samePage(c);
         if (denied !== undefined)
@@ -275,22 +343,61 @@ export function studioRoutes(deps) {
         const { projectId, short } = c.req.valid("json");
         const left = removeFill(deps.db, projectId, short ?? null, deps.clock.now());
         return c.json({ waiting: left.length });
+    })
+        // The extension read the new video's id from Studio's upload dialog. An upload with an
+        // A/B test to run (other titles, or several thumbnails) waits for its video to be public:
+        // scheduled videos are private until then, and Studio tests only public ones.
+        .post("/ext/video", zValidator("json", extVideoBody, onInvalid), (c) => {
+        allowOrigin(c, false);
+        if (!extAllowed(c))
+            return refused(c);
+        const { projectId, short, videoId } = c.req.valid("json");
+        recordVideo(deps.db, projectId, short ?? null, videoId, deps.clock.now().toISOString());
+        const testable = abTestable(projectId, short ?? null);
+        if (testable)
+            setAbState(deps.db, projectId, short ?? null, "waiting", null, deps.clock.now().toISOString());
+        return c.json({ abTest: testable });
+    })
+        // The A/B tests waiting for their videos to be public, each with its upload item (titles
+        // and thumbnails). One whose project or item is gone is dropped.
+        .get("/ext/ab-tests", (c) => {
+        allowOrigin(c, false);
+        if (!extAllowed(c))
+            return refused(c);
+        const tests = waitingAbTests(deps.db).flatMap((video) => {
+            const result = uploadPack(deps, video.projectId);
+            const item = result.ok ? packItem(result.pack, video.short ?? undefined) : undefined;
+            return item === undefined
+                ? []
+                : [{ projectId: video.projectId, short: video.short, videoId: video.videoId, item }];
+        });
+        return c.json({ tests });
+    })
+        .post("/ext/ab-tests/result", zValidator("json", abResultBody, onInvalid), (c) => {
+        allowOrigin(c, false);
+        if (!extAllowed(c))
+            return refused(c);
+        const { projectId, short, ok, message } = c.req.valid("json");
+        setAbState(deps.db, projectId, short ?? null, ok ? "started" : "failed", message, deps.clock.now().toISOString());
+        return c.json({ ok: true });
     })
         .get("/ext/files/:projectId/:asset", zValidator("param", fileParam, onInvalid), (c) => {
         allowOrigin(c, false);
         if (!studioRequestAllowed(deps.db, bearerToken(c.req.header("authorization")), c.req.header("origin")))
             return refused(c);
         const { projectId, asset } = c.req.valid("param");
-        // Only the thumbnails of a pack: the extension needs nothing else from the disk.
+        // Only a pack's own files, its videos and thumbnails: the extension puts the video into
+        // Studio's upload dialog and the thumbnails into Details, and needs nothing else.
         const result = uploadPack(deps, projectId);
         const listed = result.ok &&
-            result.pack.items.some((item) => item.thumbnails.some((thumbnail) => thumbnail.asset === asset));
+            result.pack.items.some((item) => item.video?.asset === asset ||
+                item.thumbnails.some((thumbnail) => thumbnail.asset === asset));
         const found = listed ? findDownload(deps, projectId, asset) : undefined;
         if (found === undefined || !found.ok)
             return problem(c, {
                 status: 404,
                 title: titleOf(404),
-                detail: "That thumbnail isn't in the project's upload pack any more. Reload the project in Slopify and press Fill in YouTube Studio again.",
+                detail: "That file isn't in the project's upload pack any more. Reload the project in Slopify and press Fill in YouTube Studio again.",
             });
         return c.body(Readable.toWeb(createReadStream(found.download.path)), 200, {
             "content-type": found.download.contentType,

package/dist/kernel/db/migrations/0045-youtube-videos.sql

@@ -0,0 +1,15 @@
+-- The YouTube video each upload became (the long video, short 0, or short N), as the Slopify
+-- Studio extension read it from Studio's upload dialog or the person pasted its link. With it,
+-- the video's A/B test (its other titles and thumbnails) can wait until the video is public:
+-- a scheduled video is private until then, and Studio tests only public ones. The extension
+-- checks the waiting tests, starts each once its video is public, and reports back.
+CREATE TABLE youtube_videos (
+  project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+  short INTEGER NOT NULL CHECK (short >= 0),
+  video_id TEXT NOT NULL,
+  recorded_at TEXT NOT NULL,
+  ab_state TEXT NOT NULL DEFAULT 'none' CHECK (ab_state IN ('none', 'waiting', 'started', 'failed')),
+  ab_message TEXT,
+  ab_at TEXT,
+  PRIMARY KEY (project_id, short)
+);

package/dist/patch-notes/3.2.7.md

@@ -0,0 +1,15 @@
+# Slopify 3.2.7
+
+Released 1 October 2026.
+
+3.2.7 lets the Slopify Studio extension put the video into YouTube Studio's upload dialog itself.
+
+## YouTube Studio
+
+- After **Fill in YouTube Studio**, the extension adds the video file to Studio's upload dialog as soon as it opens on Select files, then fills the details as before. Studio uploads it as a private draft, exactly as a file you drop in; nothing is published, and you still check everything and press Publish yourself.
+- If the video can't be added (Slopify isn't running, or Studio's dialog changed), the extension says so: drop the file in yourself from Open folder in Prepare upload.
+
+## Upgrading from 3.2.6
+
+- **Download the extension again** (Settings → YouTube Studio → Download) and replace the old one; it is version 0.2.0. Pairing carries over when you update it in place.
+- **Nothing becomes outdated.**

package/dist/patch-notes/3.2.8.md

@@ -0,0 +1,20 @@
+# Slopify 3.2.8
+
+Released 2 October 2026.
+
+3.2.8 starts your A/B tests once a scheduled video goes public, tests the other titles too, and lets the pinned comment and other titles be written again.
+
+## A/B tests after publishing
+
+- YouTube only A/B tests public videos, and a scheduled video is private until its time. The Slopify Studio extension now keeps each upload's YouTube link and starts its A/B test by itself once the video is public: it opens the video in a background tab, fills A/B Testing and presses **Set test**. Chrome has to be open around that time; otherwise the test starts the next time Chrome opens.
+- A/B Testing now tests the **other titles** too: **Title and thumbnail** with two or three thumbnails, **Title only** with one.
+- The project's YouTube section has **On YouTube**: each upload's link (paste one for an upload you made by hand), its A/B test's state, and **Start A/B test** to test any video after the fact.
+
+## YouTube section
+
+- **Write again** is on the pinned comment and the other titles too, not only the description. It still writes every part anew in one AI call; a part you edited keeps your text and offers the new one beside it.
+
+## Upgrading from 3.2.7
+
+- **Download the extension again** (Settings → YouTube Studio → Download), unzip it over the old one and press reload in `chrome://extensions`. It is version 0.3.0, and Chrome asks once to allow its new permissions (a 15-minute timer, and YouTube's public video check).
+- **Nothing becomes outdated.**

package/dist/patch-notes/index.json

@@ -1,4 +1,16 @@
 [
+  {
+    "id": "3.2.8",
+    "title": "Slopify 3.2.8",
+    "version": "3.2.8",
+    "date": "2026-10-02"
+  },
+  {
+    "id": "3.2.7",
+    "title": "Slopify 3.2.7",
+    "version": "3.2.7",
+    "date": "2026-10-01"
+  },
   {
     "id": "3.2.6",
     "title": "Slopify 3.2.6",

package/dist/slices/storage/backup-format.js

@@ -55,6 +55,8 @@ export const projectTables = [
     "project_recovery_requests",
     "youtube_description_edits",
     "project_uploads",
+    // Since 3.2.8: the YouTube video each upload became, and its A/B test.
+    "youtube_videos",
     // Since 2.5.0. Left out on purpose: plan_limit_waits and plan_limit_waiters (an account's
     // current wait, a lease of this install) and prompt_softening (a pending one-off request).
     // Since 3.0.8, narration_retries is left out too: the tries of a run, not of the project.

package/dist/slices/studio/videos.js

@@ -0,0 +1,60 @@
+// A YouTube video id: 11 letters, digits, `-` and `_`.
+export const videoIdPattern = /^[A-Za-z0-9_-]{11}$/;
+// The id inside a link as Studio and YouTube show it (youtu.be/ID, watch?v=ID, /shorts/ID,
+// studio's /video/ID/edit), or the bare id.
+export function videoIdOf(text) {
+    const trimmed = text.trim();
+    if (videoIdPattern.test(trimmed))
+        return trimmed;
+    const match = /(?:youtu\.be\/|[?&]v=|\/shorts\/|\/video\/|\/live\/|\/embed\/)([A-Za-z0-9_-]{11})(?![A-Za-z0-9_-])/.exec(trimmed);
+    return match?.[1];
+}
+const slot = (short) => short ?? 0;
+function rowOf(row) {
+    const short = Number(row.short);
+    return {
+        projectId: String(row.project_id),
+        short: short === 0 ? null : short,
+        videoId: String(row.video_id),
+        recordedAt: String(row.recorded_at),
+        abState: String(row.ab_state),
+        abMessage: typeof row.ab_message === "string" ? row.ab_message : null,
+        abAt: typeof row.ab_at === "string" ? row.ab_at : null,
+    };
+}
+// Records (or replaces) the video an upload became. A new video id starts its A/B test over.
+export function recordVideo(db, projectId, short, videoId, at) {
+    db.prepare(`INSERT INTO youtube_videos(project_id,short,video_id,recorded_at) VALUES (?,?,?,?)
+     ON CONFLICT(project_id,short) DO UPDATE SET
+       ab_state=CASE WHEN video_id=excluded.video_id THEN ab_state ELSE 'none' END,
+       ab_message=CASE WHEN video_id=excluded.video_id THEN ab_message ELSE NULL END,
+       ab_at=CASE WHEN video_id=excluded.video_id THEN ab_at ELSE NULL END,
+       video_id=excluded.video_id, recorded_at=excluded.recorded_at`).run(projectId, slot(short), videoId, at);
+}
+export function forgetVideo(db, projectId, short) {
+    db.prepare("DELETE FROM youtube_videos WHERE project_id=? AND short=?").run(projectId, slot(short));
+}
+export function projectVideos(db, projectId) {
+    return db
+        .prepare("SELECT * FROM youtube_videos WHERE project_id=? ORDER BY short")
+        .all(projectId)
+        .map(rowOf);
+}
+export function videoOf(db, projectId, short) {
+    const row = db
+        .prepare("SELECT * FROM youtube_videos WHERE project_id=? AND short=?")
+        .get(projectId, slot(short));
+    return row === undefined ? undefined : rowOf(row);
+}
+// Sets an A/B test's state; false when the project has no video recorded for that upload.
+export function setAbState(db, projectId, short, state, message, at) {
+    return (db
+        .prepare("UPDATE youtube_videos SET ab_state=?, ab_message=?, ab_at=? WHERE project_id=? AND short=?")
+        .run(state, message, at, projectId, slot(short)).changes > 0);
+}
+export function waitingAbTests(db) {
+    return db
+        .prepare("SELECT * FROM youtube_videos WHERE ab_state='waiting' ORDER BY recorded_at")
+        .all()
+        .map(rowOf);
+}