@gentbajko/slopify 3.25.9 → 4.0.0

package/dist/edge/http/social.js

@@ -0,0 +1,282 @@
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { z } from "zod";
+import { projectById } from "../../slices/admission/repo.js";
+import { webhookBody } from "../../slices/notifications/address.js";
+import { sendFailureText } from "../../slices/notifications/send.js";
+import { readNotificationUrl } from "../../slices/notifications/settings.js";
+import { waitsForRelease } from "../../slices/social/due.js";
+import { postingExtension, writeExtensionSites } from "../../slices/social/extension.js";
+import { platformLabels } from "../../slices/social/model.js";
+import { postReadyNotice } from "../../slices/social/notice.js";
+import { packFor, postPacks } from "../../slices/social/pack.js";
+import { readPost, writeChoice, writeReddit, writeTextEdit } from "../../slices/social/repo.js";
+import { choiceBody, linkBody, platformSchema, redditBody, resultBody, textBody, } from "../../slices/social/schema.js";
+import { serveMedia } from "../../slices/social/serve.js";
+import { duePosts, fillPost, linksToFind, nextPost, notPostingSentence, reportPost, setPostLink, } from "../../slices/social/service.js";
+import { fileResponse } from "./byte-range.js";
+import { extensionAuth } from "./extension-auth.js";
+import { idString } from "./ids.js";
+import { onInvalid, problem } from "./problem.js";
+import { fromSlopifyPage } from "./same-page.js";
+const projectParam = z.object({ projectId: idString });
+const postParam = projectParam.extend({ platform: platformSchema });
+const fileParam = projectParam.extend({
+    file: z
+        .string()
+        .min(1)
+        .max(200)
+        .regex(/^[A-Za-z0-9_-]+$/),
+});
+const nextQuery = z.object({
+    platform: platformSchema,
+    projectId: z.string().min(1).max(200).optional(),
+});
+const dueQuery = z.object({ hours: z.coerce.number().int().min(1).max(48).optional() });
+const sitesBody = z.object({ sites: z.array(platformSchema).max(6) });
+export function socialRoutes(deps) {
+    const { allowOrigin, allowed, refused } = extensionAuth(deps.db);
+    const media = {
+        db: deps.db,
+        paths: deps.paths,
+        reshaper: deps.social?.reshaper,
+        ...(deps.designs === undefined
+            ? {}
+            : {
+                renderDesign: async (designId, format, signal) => {
+                    const drawn = await deps.designs?.renderer.render(designId, format, "png", signal);
+                    return drawn?.ok === true
+                        ? { ok: true, path: drawn.value.path }
+                        : {
+                            ok: false,
+                            sentence: drawn?.message ??
+                                "The design couldn't be drawn. Open it in Library → Designs to check it, then reload Prepare upload.",
+                        };
+                },
+            }),
+    };
+    const samePage = (c) => fromSlopifyPage(c, deps.remoteAccess?.remoteHost)
+        ? undefined
+        : problem(c, {
+            status: 403,
+            detail: "For your safety, a project's posts can only be changed from the Slopify page itself. Open Slopify and try again there.",
+        });
+    const answer = (c, projectId) => {
+        const result = postPacks(deps, projectId, deps.clock.now());
+        if (!result.ok)
+            return unknownProject(c);
+        const body = {
+            ...result.packs,
+            extension: postingExtension(deps.db),
+        };
+        return c.json(body);
+    };
+    const refusal = (c, refused) => problem(c, { status: refused.status, detail: refused.sentence });
+    const posting = (c, projectId, platform) => packFor(deps, projectId, platform, deps.clock.now()) === undefined
+        ? problem(c, {
+            status: 404,
+            detail: notPostingSentence(platform),
+        })
+        : undefined;
+    // A post filled at its release time tells the Notification URL, when one is set. Never
+    // awaited: the extension's report doesn't wait on it.
+    const notify = (text, projectId) => {
+        const url = readNotificationUrl(deps.db);
+        const send = deps.sendNotification;
+        if (url === null || send === undefined)
+            return;
+        void send(url, webhookBody(text)).then((sent) => {
+            if (!sent.ok)
+                deps.log.write("warn", "social.notify", { projectId, detail: sendFailureText(sent) });
+        });
+    };
+    const changed = (projectId) => deps.hub.emit(projectId, { type: "project.updated", projectId });
+    return (new Hono()
+        .get("/packs/:projectId", zValidator("param", projectParam, onInvalid), (c) => answer(c, c.req.valid("param").projectId))
+        // The project's own pick for one site: other settings, not posting there ({off: true}),
+        // or back to the template's (null).
+        .put("/packs/:projectId/:platform/choice", zValidator("param", postParam, onInvalid), zValidator("json", choiceBody, onInvalid), (c) => {
+        const denied = samePage(c);
+        if (denied !== undefined)
+            return denied;
+        const { projectId, platform } = c.req.valid("param");
+        if (postPacks(deps, projectId, deps.clock.now()).ok === false)
+            return unknownProject(c);
+        const { choice } = c.req.valid("json");
+        const config = projectById(deps.db, projectId)?.config.social?.[platform];
+        if (choice !== null &&
+            !("off" in choice) &&
+            choice.text === "prompt" &&
+            config?.text !== "prompt")
+            return problem(c, {
+                status: 409,
+                detail: `A post written by a post prompt is a paid step, so it is picked in the template, in Template Studio → Upload pack, where Save shows its cost. For this project, pick a free text source in Prepare upload → ${platformLabels[platform]} → Settings.`,
+            });
+        writeChoice(deps.db, { projectId, platform }, choice, deps.clock.now());
+        changed(projectId);
+        return answer(c, projectId);
+    })
+        .put("/packs/:projectId/:platform/text", zValidator("param", postParam, onInvalid), zValidator("json", textBody, onInvalid), (c) => {
+        const denied = samePage(c);
+        if (denied !== undefined)
+            return denied;
+        const { projectId, platform } = c.req.valid("param");
+        const missing = posting(c, projectId, platform);
+        if (missing !== undefined)
+            return missing;
+        writeTextEdit(deps.db, { projectId, platform }, c.req.valid("json"), deps.clock.now());
+        changed(projectId);
+        return answer(c, projectId);
+    })
+        .delete("/packs/:projectId/:platform/text", zValidator("param", postParam, onInvalid), (c) => {
+        const denied = samePage(c);
+        if (denied !== undefined)
+            return denied;
+        const { projectId, platform } = c.req.valid("param");
+        const missing = posting(c, projectId, platform);
+        if (missing !== undefined)
+            return missing;
+        writeTextEdit(deps.db, { projectId, platform }, null, deps.clock.now());
+        changed(projectId);
+        return answer(c, projectId);
+    })
+        .put("/packs/:projectId/:platform/reddit", zValidator("param", postParam, onInvalid), zValidator("json", redditBody, onInvalid), (c) => {
+        const denied = samePage(c);
+        if (denied !== undefined)
+            return denied;
+        const { projectId, platform } = c.req.valid("param");
+        if (platform !== "reddit")
+            return problem(c, {
+                status: 400,
+                detail: "Only a Reddit post has a subreddit, title and flair. Open the Reddit post instead.",
+            });
+        const missing = posting(c, projectId, platform);
+        if (missing !== undefined)
+            return missing;
+        writeReddit(deps.db, { projectId, platform }, c.req.valid("json").reddit, deps.clock.now());
+        changed(projectId);
+        return answer(c, projectId);
+    })
+        // The post's link, pasted by the person (posted by hand, or the extension missed it); null
+        // removes it, so the post can be filled again.
+        .put("/packs/:projectId/:platform/link", zValidator("param", postParam, onInvalid), zValidator("json", linkBody, onInvalid), (c) => {
+        const denied = samePage(c);
+        if (denied !== undefined)
+            return denied;
+        const { projectId, platform } = c.req.valid("param");
+        const result = setPostLink(deps, projectId, platform, c.req.valid("json").url, deps.clock.now());
+        if (!result.ok)
+            return refusal(c, result);
+        changed(projectId);
+        return answer(c, projectId);
+    })
+        // Fill in <site>: never offered to agents or the assistant (`excluded-routes.ts`).
+        .post("/packs/:projectId/:platform/fill", zValidator("param", postParam, onInvalid), (c) => {
+        const denied = samePage(c);
+        if (denied !== undefined)
+            return denied;
+        const { projectId, platform } = c.req.valid("param");
+        const result = fillPost(deps, projectId, platform, deps.clock.now());
+        if (!result.ok)
+            return refusal(c, result);
+        changed(projectId);
+        return c.json({
+            pack: result.pack,
+            waitsForRelease: result.waitsForRelease,
+            url: result.pack.composeUrl,
+        });
+    })
+        .get("/media/:projectId/:file", zValidator("param", fileParam, onInvalid), async (c) => {
+        const { projectId, file } = c.req.valid("param");
+        return served(c, await serveMedia(media, projectId, file, deps.clock.now(), c.req.raw.signal));
+    })
+        // The extension's routes.
+        .options("/ext/*", (c) => {
+        allowOrigin(c, false);
+        return c.body(null, 204);
+    })
+        .get("/ext/next", zValidator("query", nextQuery, onInvalid), (c) => {
+        allowOrigin(c, false);
+        if (!allowed(c))
+            return refused(c);
+        const { platform, projectId } = c.req.valid("query");
+        const next = nextPost(deps, platform, deps.clock.now(), projectId);
+        if (next === undefined)
+            return problem(c, {
+                status: 404,
+                detail: "Nothing is waiting to be filled on this site. In Slopify, open the project, press Prepare upload, then Fill in the site's post.",
+            });
+        changed(next.pack.projectId);
+        return c.json(next);
+    })
+        .get("/ext/packs/:projectId/:platform", zValidator("param", postParam, onInvalid), (c) => {
+        allowOrigin(c, false);
+        if (!allowed(c))
+            return refused(c);
+        const { projectId, platform } = c.req.valid("param");
+        const pack = packFor(deps, projectId, platform, deps.clock.now());
+        return pack === undefined ? unknownPost(c) : c.json(pack);
+    })
+        .get("/ext/files/:projectId/:file", zValidator("param", fileParam, onInvalid), async (c) => {
+        allowOrigin(c, false);
+        if (!allowed(c))
+            return refused(c);
+        const { projectId, file } = c.req.valid("param");
+        return served(c, await serveMedia(media, projectId, file, deps.clock.now(), c.req.raw.signal));
+    })
+        .get("/ext/due", zValidator("query", dueQuery, onInvalid), (c) => {
+        allowOrigin(c, false);
+        if (!allowed(c))
+            return refused(c);
+        const hours = c.req.valid("query").hours ?? 24;
+        return c.json({ posts: duePosts(deps, deps.clock.now(), hours * 3_600_000) });
+    })
+        .post("/ext/result", zValidator("json", resultBody, onInvalid), (c) => {
+        allowOrigin(c, false);
+        if (!allowed(c))
+            return refused(c);
+        const body = c.req.valid("json");
+        const result = reportPost(deps, body, deps.clock.now());
+        if (!result.ok)
+            return refusal(c, result);
+        changed(body.projectId);
+        if (body.state === "filled" && waitsForRelease(body.platform) && result.pack !== undefined)
+            notify(postReadyNotice(result.pack), body.projectId);
+        return c.json({ status: readPost(deps.db, body).state });
+    })
+        .get("/ext/find-links", (c) => {
+        allowOrigin(c, false);
+        if (!allowed(c))
+            return refused(c);
+        return c.json({ posts: linksToFind(deps, deps.clock.now()) });
+    })
+        // Which sites the extension may post on, as its options last granted them.
+        .post("/ext/sites", zValidator("json", sitesBody, onInvalid), (c) => {
+        allowOrigin(c, false);
+        if (!allowed(c))
+            return refused(c);
+        writeExtensionSites(deps.db, c.req.valid("json").sites, deps.clock.now());
+        return c.json(postingExtension(deps.db));
+    }));
+}
+function served(c, result) {
+    if (!result.ok)
+        return problem(c, { status: result.status, detail: result.sentence });
+    return fileResponse(c, result.path, result.bytes, {
+        "content-type": result.contentType,
+        "content-disposition": `inline; filename="${result.filename.replace(/["\\]/g, "")}"`,
+        "x-content-type-options": "nosniff",
+    });
+}
+function unknownProject(c) {
+    return problem(c, {
+        status: 404,
+        detail: "This project no longer exists. Go back to Projects and open it again.",
+    });
+}
+function unknownPost(c) {
+    return problem(c, {
+        status: 404,
+        detail: "That project no longer posts to this site. In Slopify, open the project's Prepare upload and press Fill again.",
+    });
+}

package/dist/edge/http/staging.js

@@ -5,7 +5,7 @@ import { uploadableStageKinds } from "../../slices/storage/model.js";
 import { stagedFiles } from "../../slices/storage/repo.js";
 import { discardStagedFile, stageUpload } from "../../slices/storage/staging.js";
 import { readMultipart } from "./multipart.js";
-import { onInvalid, problem, titleOf } from "./problem.js";
+import { onInvalid, problem } from "./problem.js";
 const kindParam = z.object({ kind: z.enum(uploadableStageKinds) });
 const idParam = z.object({ id: z.string().min(1).max(64) });
 // The return type is inferred on purpose: annotating it would erase the route types the
@@ -33,12 +33,11 @@ export function stagingRoutes(deps) {
         if (result === undefined) {
             return problem(c, {
                 status: 400,
-                title: titleOf(400),
                 detail: "No file arrived with the upload. Choose the file again and retry.",
             });
         }
         if (!result.ok) {
-            return problem(c, { status: 400, title: titleOf(400), detail: detailOf(result.reason) });
+            return problem(c, { status: 400, detail: detailOf(result.reason) });
         }
         return c.json(result.file, 201);
     })
@@ -47,7 +46,6 @@ export function stagingRoutes(deps) {
         if (!result.ok) {
             return problem(c, {
                 status: result.reason === "in-use" ? 409 : 404,
-                title: titleOf(result.reason === "in-use" ? 409 : 404),
                 detail: result.reason === "in-use"
                     ? "This file is still attached to a draft in Play. Remove it from the draft first."
                     : "This uploaded file no longer exists; it may have been removed already. Reload the page.",

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

@@ -2,7 +2,9 @@ import { zValidator } from "@hono/zod-validator";
 import { Hono } from "hono";
 import { HTTPException } from "hono/http-exception";
 import { z } from "zod";
-import { onInvalid, problem, titleOf } from "./problem.js";
+import { onInvalid, problem } from "./problem.js";
+import { fromSlopifyPage } from "./same-page.js";
+export const moveFilesBody = z.object({ target: z.string().min(1).max(4096) }).strict();
 // Settings → Backup & storage → Your files: where projects and backups are, Open folder, and
 // moving them. A move copies and checks every file, so it answers at once and the screen polls.
 export function filesRoutes(deps) {
@@ -16,23 +18,20 @@ export function filesRoutes(deps) {
         c.header("Cache-Control", "no-store");
         return c.json(await files().view());
     })
-        .post("/move", zValidator("json", z.object({ target: z.string().min(1).max(4096) }).strict(), onInvalid), async (c) => {
+        .post("/move", zValidator("json", moveFilesBody, onInvalid), async (c) => {
         const started = await files().move(c.req.valid("json").target);
         if (!started.ok)
             return problem(c, {
                 status: started.status,
-                title: titleOf(started.status),
                 detail: started.detail,
                 extensions: { field: "target" },
             });
         return c.json(await files().view(), 202);
     })
         .post("/open", async (c) => {
-        const origin = c.req.header("origin");
-        if (origin !== undefined && origin !== new URL(c.req.url).origin)
+        if (!fromSlopifyPage(c, deps.remoteAccess?.remoteHost))
             return problem(c, {
                 status: 403,
-                title: titleOf(403),
                 detail: "For your safety, folders can only be opened from the Slopify page itself. Open Slopify and try again there.",
             });
         try {
@@ -42,7 +41,6 @@ export function filesRoutes(deps) {
             deps.log.write("warn", "storage.open-files", { detail: String(error) });
             return problem(c, {
                 status: 503,
-                title: titleOf(503),
                 detail: "Slopify could not open a file manager window on the computer it runs on. Make sure you are signed in to that computer's desktop, or open the folder shown in Settings → Backup & storage yourself.",
             });
         }

package/dist/edge/http/storage.js

@@ -1,20 +1,14 @@
 import { zValidator } from "@hono/zod-validator";
 import { Hono } from "hono";
-import { z } from "zod";
 import { projectExists } from "../../slices/admission/repo.js";
 import { BackupBusyError, planBackup, streamBackup, } from "../../slices/storage/backup-export.js";
 import { BackupImportRefused, importBackup } from "../../slices/storage/backup-import.js";
 import { importPortable, portableMaxArchiveBytes, storageUsage, } from "../../slices/storage/portable.js";
 import { reconcileStorage } from "../../slices/storage/reconcile.js";
 import { cleanUpAll, deleteAllOldVersions, deleteOldVersions, keepOutputsOnly, projectStorage, } from "../../slices/storage/trim.js";
-import { onInvalid, problem, titleOf } from "./problem.js";
-const idParam = z.object({
-    id: z
-        .string()
-        .min(1)
-        .max(64)
-        .regex(/^[0-9A-Za-z_-]+$/),
-});
+import { sampleOwner } from "../../slices/template-studio/repo.js";
+import { idParam } from "./ids.js";
+import { onInvalid, problem } from "./problem.js";
 const exportFailed = "Slopify could not create the backup. Check there is free disk space and try again; if it keeps failing, use Download diagnostics in Settings and report it.";
 export function storageRoutes(deps) {
     const backup = () => ({
@@ -25,6 +19,17 @@ export function storageRoutes(deps) {
         appVersion: deps.version,
         hasInflight: deps.runner.hasInflight,
     });
+    // A template's studio sample keeps its files for the studio's bake-offs and resamples.
+    const studioSample = (id) => {
+        const owner = sampleOwner(deps.db, id);
+        return owner === undefined
+            ? undefined
+            : {
+                status: 409,
+                detail: `This is the studio sample of ${owner.name}, and the studio keeps its files to make its samples again without paying twice. Change it in its studio instead: Library → Templates → ${owner.name} → Open studio.`,
+                extensions: { reason: "template-sample" },
+            };
+    };
     return (new Hono()
         .get("/", (c) => c.json(storageUsage({ db: deps.db, paths: deps.paths, hasInflight: deps.runner.hasInflight })))
         // One project's split between outputs and working files, and what Keep outputs only
@@ -34,7 +39,6 @@ export function storageRoutes(deps) {
         if (!projectExists(deps.db, id))
             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");
@@ -42,35 +46,37 @@ export function storageRoutes(deps) {
     })
         // Keep outputs only: a finished project drops its working files (`slices/storage/trim.ts`).
         .post("/projects/:id/keep-outputs", zValidator("param", idParam, onInvalid), (c) => {
+        const refused = studioSample(c.req.valid("param").id);
+        if (refused !== undefined)
+            return problem(c, refused);
         const result = keepOutputsOnly({ db: deps.db, paths: deps.paths, hasInflight: deps.runner.hasInflight }, c.req.valid("param").id);
         if (result.ok)
             return c.json(result);
         return result.reason === "no-project"
             ? problem(c, {
                 status: 404,
-                title: titleOf(404),
                 detail: "This project no longer exists. Reload Settings → Storage to see the current list.",
             })
             : problem(c, {
                 status: 409,
-                title: titleOf(409),
                 detail: "Only a finished project can drop its working files, and this one is running, waiting or has unfinished steps. Let it finish (or cancel it on its project page), then drop the working files again from the project page or Settings → Storage.",
             });
     })
         // Delete old versions: one project's History files (`slices/storage/trim.ts`).
         .post("/projects/:id/old-versions/delete", zValidator("param", idParam, onInvalid), (c) => {
+        const refused = studioSample(c.req.valid("param").id);
+        if (refused !== undefined)
+            return problem(c, refused);
         const result = deleteOldVersions({ db: deps.db, paths: deps.paths, hasInflight: deps.runner.hasInflight }, c.req.valid("param").id);
         if (result.ok)
             return c.json(result);
         return result.reason === "no-project"
             ? problem(c, {
                 status: 404,
-                title: titleOf(404),
                 detail: "This project no longer exists. Reload Settings → Backup & storage to see the current list.",
             })
             : problem(c, {
                 status: 409,
-                title: titleOf(409),
                 detail: "This project is running or has steps waiting to run, and its files stay where they are until then. Let it finish, or cancel its run on its project page, then press Delete old versions again.",
             });
     })
@@ -98,7 +104,7 @@ export function storageRoutes(deps) {
             if (error instanceof BackupBusyError)
                 return c.json({ ready: false, detail: error.message, busy: error.projects });
             deps.log.write("error", "storage.export", { detail: String(error) });
-            return problem(c, { status: 500, title: titleOf(500), detail: exportFailed });
+            return problem(c, { status: 500, detail: exportFailed });
         }
     })
         .get("/export", (c) => {
@@ -108,9 +114,9 @@ export function storageRoutes(deps) {
         }
         catch (error) {
             if (error instanceof BackupBusyError)
-                return problem(c, { status: 409, title: titleOf(409), detail: error.message });
+                return problem(c, { status: 409, detail: error.message });
             deps.log.write("error", "storage.export", { detail: String(error) });
-            return problem(c, { status: 500, title: titleOf(500), detail: exportFailed });
+            return problem(c, { status: 500, detail: exportFailed });
         }
         // Pulled one chunk at a time, so a slow download reads files no faster than it sends.
         const chunks = streamBackup(plan);
@@ -145,14 +151,12 @@ export function storageRoutes(deps) {
         if (!contentType.includes("application/zip"))
             return problem(c, {
                 status: 415,
-                title: titleOf(415),
                 detail: "Choose a Slopify backup file: a .tar made with Export everything, or an older .zip made with Export backup, both in Settings → Backup & storage.",
             });
         const upload = await readPortableUpload(c.req.raw);
         if (!upload.ok)
             return problem(c, {
                 status: 413,
-                title: titleOf(413),
                 detail: "This backup file is empty or larger than 100 MB. Choose a Slopify backup file under 100 MB.",
             });
         try {
@@ -167,7 +171,6 @@ export function storageRoutes(deps) {
         catch {
             return problem(c, {
                 status: 400,
-                title: titleOf(400),
                 detail: "This file is not a complete Slopify backup; it may be damaged or a different kind of ZIP. Choose a backup made with Backup & storage in Settings.",
             });
         }
@@ -175,7 +178,6 @@ export function storageRoutes(deps) {
             if (request.body === null)
                 return problem(c, {
                     status: 400,
-                    title: titleOf(400),
                     detail: "The backup file arrived empty. Choose the .tar made with Export everything and import it again.",
                 });
             const reader = request.body.getReader();
@@ -186,13 +188,11 @@ export function storageRoutes(deps) {
                 if (error instanceof BackupImportRefused)
                     return problem(c, {
                         status: error.status,
-                        title: titleOf(error.status),
                         detail: error.message,
                     });
                 deps.log.write("error", "storage.import", { detail: String(error) });
                 return problem(c, {
                     status: 500,
-                    title: titleOf(500),
                     detail: "The backup wasn't imported and nothing in this install changed. Try again; if it keeps failing, use Download diagnostics in Settings and report it.",
                 });
             }