@gentbajko/slopify 3.25.8 → 4.0.0

package/dist/slices/template-studio/pack-import.js

@@ -0,0 +1,253 @@
+import { rmSync } from "node:fs";
+import { strFromU8, unzipSync } from "fflate";
+import { transact } from "../../kernel/db/tx.js";
+import { detectSlots } from "../admission/substitute.js";
+import { nameMax } from "../library/model.js";
+import { entryByName, insertEntry } from "../library/repo.js";
+import { renamedIn } from "../library/used-by.js";
+import { freeTemplateName, placePrompt } from "../onboarding/install.js";
+import { createTemplate } from "../project-templates/service.js";
+import { listVoices } from "../settings/repo.js";
+import { looksSecret, packFormat, packFormatVersion, packLimits, packManifestSchema, packSampleFile, } from "./pack.js";
+import { packSamplesDir, writePackSamples } from "./pack-samples.js";
+const refuse = (message) => ({
+    ok: false,
+    reason: "invalid-input",
+    message,
+});
+const notAPack = "This file isn't a template pack Slopify can read. Choose the .zip that Export pack in a template's studio made.";
+class ZipStopped extends Error {
+}
+// Every check that needs nothing written: a zip, small enough, with a manifest of this format
+// and version, no keys, and every sample it names inside it.
+export function readPack(bytes) {
+    if (bytes.byteLength > packLimits.uploadBytes)
+        return refuse(`This pack is larger than ${String(packLimits.uploadBytes / 1024 / 1024)} MB, more than a template pack ever is. Export it again from the template's studio, or ask whoever made it to.`);
+    let oversized;
+    let unexpected;
+    let twice;
+    let tooMany = false;
+    // A zip's central directory can list one compressed block many times over: entries are
+    // counted, named once each and capped in total before any of them is unpacked.
+    const maxEntries = 1 + packLimits.samples;
+    const maxTotal = packLimits.manifestBytes + packLimits.samples * packLimits.sampleBytes;
+    const seen = new Set();
+    let total = 0;
+    let entries;
+    try {
+        entries = unzipSync(bytes, {
+            filter: (file) => {
+                if (file.name.endsWith("/"))
+                    return false;
+                if (seen.has(file.name)) {
+                    twice ??= file.name;
+                    throw new ZipStopped();
+                }
+                seen.add(file.name);
+                if (seen.size > maxEntries) {
+                    tooMany = true;
+                    throw new ZipStopped();
+                }
+                const known = file.name === "manifest.json" || packSampleFile.test(file.name);
+                if (!known) {
+                    unexpected ??= file.name;
+                    return false;
+                }
+                const limit = file.name === "manifest.json" ? packLimits.manifestBytes : packLimits.sampleBytes;
+                if (file.originalSize > limit) {
+                    oversized ??= file.name;
+                    return false;
+                }
+                total += file.originalSize;
+                if (total > maxTotal) {
+                    tooMany = true;
+                    throw new ZipStopped();
+                }
+                return true;
+            },
+        });
+    }
+    catch (error) {
+        if (!(error instanceof ZipStopped))
+            return refuse(notAPack);
+        entries = {};
+    }
+    if (tooMany)
+        return refuse(`This pack holds more files than a template pack ever has (a manifest and at most ${String(packLimits.samples)} samples), so nothing was imported. Export the pack again from the template's studio.`);
+    if (twice !== undefined)
+        return refuse(`This pack holds ${twice.slice(0, 120)} twice, which an exported pack never does, so nothing was imported. Export the pack again from the template's studio.`);
+    if (oversized !== undefined)
+        return refuse(`This pack's ${oversized} is larger than a template pack allows, so nothing was imported. Export the pack again from the template's studio.`);
+    if (unexpected !== undefined)
+        return refuse(`This pack holds a file a template pack never has (${unexpected.slice(0, 120)}), so nothing was imported. Export the pack again from the template's studio.`);
+    const raw = entries["manifest.json"];
+    if (raw === undefined)
+        return refuse("This zip has no manifest.json, so it isn't a template pack. Choose the .zip that Export pack in a template's studio made.");
+    const text = strFromU8(raw);
+    if (looksSecret(text))
+        return refuse("This pack holds what looks like an API key or a login token, so Slopify didn't import it: keys never travel in a pack. Ask whoever made it to remove it from the template and export it again.");
+    let json;
+    try {
+        json = JSON.parse(text);
+    }
+    catch {
+        return refuse("This pack's manifest.json isn't readable JSON; the file may be damaged. Export the pack again from the template's studio.");
+    }
+    const head = json;
+    if (typeof json !== "object" || json === null || head.format !== packFormat)
+        return refuse(notAPack);
+    if (typeof head.formatVersion === "number" && head.formatVersion > packFormatVersion)
+        return refuse(`This pack was made by a newer Slopify (pack format ${String(head.formatVersion)}). Update Slopify in Settings → About, then import it again.`);
+    const parsed = packManifestSchema.safeParse(json);
+    if (!parsed.success) {
+        const issue = parsed.error.issues[0];
+        const where = issue === undefined ? "" : ` (${issue.path.join(".") || "manifest"}: ${issue.message})`;
+        return refuse(`This pack's manifest isn't one Slopify can use${where.slice(0, 300)}. It may be damaged or edited by hand; export it again from the template's studio.`);
+    }
+    const files = new Map();
+    for (const sample of parsed.data.samples) {
+        const file = entries[sample.file];
+        if (file === undefined)
+            return refuse(`This pack names a sample (${sample.file}) it doesn't hold; the file may be damaged. Export the pack again from the template's studio.`);
+        files.set(sample.file, file);
+    }
+    return { ok: true, value: { manifest: parsed.data, files } };
+}
+function placeEntry(deps, row, at) {
+    for (let n = 1;; n += 1) {
+        const suffix = n === 1 ? "" : ` (${String(n)})`;
+        const candidate = `${row.name.slice(0, nameMax - suffix.length).trimEnd()}${suffix}`;
+        const taken = entryByName(deps.db, row.category, candidate);
+        if (taken?.body === row.body)
+            return { name: taken.name, added: false };
+        if (taken !== undefined)
+            continue;
+        const entry = {
+            id: deps.ids.next(),
+            category: row.category,
+            mode: row.mode,
+            name: candidate,
+            body: row.body,
+            slots: detectSlots(row.body).names,
+            updatedAt: at,
+        };
+        insertEntry(deps.db, entry);
+        return { name: candidate, added: true };
+    }
+}
+// The pack's Library items placed in this Library, and the document naming each by the name it
+// has here.
+function placeLibrary(deps, document, at) {
+    const snapshot = document.librarySnapshot ?? { prompts: [], entries: [] };
+    let form = document.form;
+    let added = 0;
+    const renamed = [];
+    const prompts = [];
+    for (const row of snapshot.prompts) {
+        const placed = placePrompt(deps, row.kind, row.name, row.body, at);
+        if (placed.added)
+            added += 1;
+        if (placed.prompt.name !== row.name) {
+            renamed.push({ from: row.name, to: placed.prompt.name });
+            form =
+                renamedIn(form, { item: "prompt", kind: row.kind, name: row.name }, placed.prompt.name) ??
+                    form;
+        }
+        prompts.push({ ...row, id: placed.prompt.id, name: placed.prompt.name });
+    }
+    const entries = [];
+    for (const row of snapshot.entries) {
+        const placed = placeEntry(deps, row, at);
+        if (placed.added)
+            added += 1;
+        if (placed.name !== row.name) {
+            renamed.push({ from: row.name, to: placed.name });
+            form =
+                renamedIn(form, { item: "entry", category: row.category, name: row.name }, placed.name) ??
+                    form;
+        }
+        entries.push({ ...row, name: placed.name });
+    }
+    return {
+        document: {
+            ...document,
+            form: form,
+            librarySnapshot: { prompts, entries },
+        },
+        added,
+        renamed,
+    };
+}
+export function importPack(deps, bytes) {
+    const read = readPack(bytes);
+    if (!read.ok)
+        return read;
+    const { manifest, files } = read.value;
+    const templateId = deps.uuid();
+    const at = deps.clock.now().toISOString();
+    let made;
+    try {
+        made = transact(deps.db, () => {
+            const placed = placeLibrary(deps, manifest.template.document, at);
+            const { channelId: _channel, templateSource: _source, ...document } = placed.document;
+            const name = freeTemplateName(deps, manifest.template.name);
+            const created = createTemplate(deps, {
+                id: templateId,
+                name,
+                document: { ...document, fontUpload: null },
+            });
+            if (!created.ok)
+                throw new PackRefused(created.reason === "missing-prompt"
+                    ? "This pack's template names a prompt or intro/outro the pack doesn't carry, so it can't be made here. Ask whoever made it to export it again."
+                    : "Slopify couldn't make a template from this pack. Import it again; if it fails again, use Download diagnostics in Settings and report it.");
+            const audio = created.value.document.form.audio;
+            const voiceKnown = audio.voice === "" ||
+                listVoices(deps.db).some((voice) => voice.provider === audio.provider && voice.voiceId === audio.voice);
+            return {
+                ok: true,
+                value: {
+                    templateId,
+                    name,
+                    added: placed.added,
+                    renamed: placed.renamed,
+                    voiceKnown,
+                    samples: manifest.samples.length,
+                },
+            };
+        });
+    }
+    catch (error) {
+        if (error instanceof PackRefused)
+            return refuse(error.message);
+        throw error;
+    }
+    if (!made.ok)
+        return made;
+    // The samples are only to look at: written once the template is in, a failure to write them
+    // leaves the template as it is, without them.
+    try {
+        writePackSamples(deps.paths, templateId, manifest.samples.flatMap((sample) => {
+            const body = files.get(sample.file);
+            return body === undefined
+                ? []
+                : [
+                    {
+                        file: sample.file.slice("samples/".length),
+                        role: sample.role,
+                        name: sample.name,
+                        body,
+                    },
+                ];
+        }));
+    }
+    catch (error) {
+        rmSync(packSamplesDir(deps.paths, templateId), { recursive: true, force: true });
+        deps.log.write("warn", "template-studio.pack", {
+            detail: `The samples of the imported pack ${templateId} weren't kept: ${error instanceof Error ? error.message : String(error)}`,
+        });
+        return { ok: true, value: { ...made.value, samples: 0 } };
+    }
+    return made;
+}
+class PackRefused extends Error {
+}

package/dist/slices/template-studio/pack-samples.js

@@ -0,0 +1,60 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
+import { join } from "node:path";
+import { z } from "zod";
+import { packSampleRoles, packSampleType } from "./pack.js";
+// The samples an imported pack came with, kept beside the data dir's studio files so the studio
+// shows them until the template makes its own: `template-studio/packs/<template id>/`, with a
+// samples.json naming each file and what it is.
+export function packSamplesDir(paths, templateId) {
+    return join(paths.dataDir, "template-studio", "packs", templateId);
+}
+const fileName = /^[a-z0-9-]{1,40}\.(png|jpg|jpeg|webp|mp3|m4a|wav)$/;
+const listSchema = z.array(z
+    .object({
+    file: z.string().regex(fileName),
+    role: z.enum(packSampleRoles),
+    name: z.string().max(200),
+})
+    .strict());
+// Written to a folder of its own first and moved into place, so a half-written set is never
+// shown.
+export function writePackSamples(paths, templateId, samples) {
+    if (samples.length === 0)
+        return;
+    const target = packSamplesDir(paths, templateId);
+    const staging = `${target}.part`;
+    rmSync(staging, { recursive: true, force: true });
+    mkdirSync(staging, { recursive: true, mode: 0o700 });
+    for (const sample of samples) {
+        if (!fileName.test(sample.file))
+            continue;
+        writeFileSync(join(staging, sample.file), sample.body, { mode: 0o600 });
+    }
+    writeFileSync(join(staging, "samples.json"), JSON.stringify(samples.map(({ file, role, name }) => ({ file, role, name }))), { mode: 0o600 });
+    rmSync(target, { recursive: true, force: true });
+    renameSync(staging, target);
+}
+export function packSamples(paths, templateId) {
+    const list = join(packSamplesDir(paths, templateId), "samples.json");
+    if (!existsSync(list))
+        return [];
+    try {
+        const parsed = listSchema.safeParse(JSON.parse(readFileSync(list, "utf8")));
+        return parsed.success ? parsed.data : [];
+    }
+    catch {
+        return [];
+    }
+}
+// One kept sample's file, or undefined when the template has no such sample.
+export function packSampleFileOf(paths, templateId, file) {
+    if (!packSamples(paths, templateId).some((sample) => sample.file === file))
+        return undefined;
+    const path = join(packSamplesDir(paths, templateId), file);
+    const type = packSampleType(`samples/${file}`);
+    const stat = statSync(path, { throwIfNoEntry: false });
+    return stat === undefined || type === undefined ? undefined : { path, bytes: stat.size, type };
+}
+export function removePackSamples(paths, templateId) {
+    rmSync(packSamplesDir(paths, templateId), { recursive: true, force: true });
+}

package/dist/slices/template-studio/pack.js

@@ -0,0 +1,205 @@
+import { readFile } from "node:fs/promises";
+import { strToU8, zipSync } from "fflate";
+import { z } from "zod";
+import { redact } from "../../kernel/log.js";
+import { projectExists } from "../admission/repo.js";
+import { playDraftDocumentSchema } from "../play-drafts/schema.js";
+import { templateById } from "../project-templates/repo.js";
+import { templateNameMax } from "../project-templates/schema.js";
+import { templateSetup } from "../project-templates/setup.js";
+import { findRevisionDownload } from "../revisions/downloads.js";
+import { currentRevisionId } from "../revisions/repo.js";
+import { getRevisionView } from "../revisions/view.js";
+import { listVoices } from "../settings/repo.js";
+import { checkedVersion } from "./gate.js";
+import { gatesOf, sampleOf } from "./repo.js";
+// A template pack: a template set up in the studio, as one zip someone else imports and looks
+// at before using it. It carries the version marked ready (its prompts' and intros' text, the
+// voice it picks, the Look, the PDF theme) and a few of its sample's files. Never a key, a
+// login or anything else of this computer's: a pack is made to be shared.
+export const packFormat = "slopify-template-pack";
+export const packFormatVersion = 1;
+// ceiling: a pack is a few sample files and a manifest; a bigger upload is refused before it is
+// read, and each entry is refused by its stated size before it is unpacked.
+export const packLimits = {
+    uploadBytes: 30 * 1024 * 1024,
+    manifestBytes: 2 * 1024 * 1024,
+    sampleBytes: 6 * 1024 * 1024,
+    samples: 6,
+    pictures: 4,
+};
+export const packSampleRoles = ["thumbnail", "picture", "narration"];
+const sampleTypes = {
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    webp: "image/webp",
+    mp3: "audio/mpeg",
+    m4a: "audio/mp4",
+    wav: "audio/wav",
+};
+export const packSampleFile = /^samples\/([a-z0-9-]{1,40})\.(png|jpg|jpeg|webp|mp3|m4a|wav)$/;
+export function packSampleType(file) {
+    const extension = packSampleFile.exec(file)?.[2];
+    return extension === undefined ? undefined : sampleTypes[extension];
+}
+export const packManifestSchema = z
+    .object({
+    format: z.literal(packFormat),
+    formatVersion: z.literal(packFormatVersion),
+    exportedAt: z.string().max(40),
+    slopifyVersion: z.string().max(40),
+    template: z
+        .object({
+        name: z.string().trim().min(1).max(templateNameMax),
+        version: z.number().int().positive(),
+        document: playDraftDocumentSchema,
+    })
+        .strict(),
+    // The voice the template picks, as the exporter's Settings → Voices names it.
+    voice: z
+        .object({
+        provider: z.string().min(1).max(100),
+        voiceId: z.string().min(1).max(200),
+        name: z.string().max(200),
+    })
+        .strict()
+        .nullable(),
+    samples: z
+        .array(z
+        .object({
+        file: z.string().regex(packSampleFile),
+        role: z.enum(packSampleRoles),
+        name: z.string().max(200),
+    })
+        .strict())
+        .max(packLimits.samples),
+})
+    .strict();
+// Whether text holds what looks like an API key or a bearer token (`kernel/log.ts`'s filter).
+export function looksSecret(text) {
+    return redact(text) !== text;
+}
+const extensionOf = (path) => {
+    const extension = path.split(".").pop()?.toLowerCase();
+    return extension !== undefined && Object.hasOwn(sampleTypes, extension)
+        ? extension
+        : undefined;
+};
+// The sample's thumbnail, up to four pictures and its narration, as its project holds them now.
+// A file too big for a pack is left out.
+export function sampleFilesOf(deps, templateId) {
+    const sample = sampleOf(deps.db, templateId);
+    if (sample === undefined || !projectExists(deps.db, sample.projectId))
+        return [];
+    const revisionId = currentRevisionId(deps.db, sample.projectId);
+    if (revisionId === undefined)
+        return [];
+    const view = getRevisionView({ ...deps, ids: { next: () => "" }, clock: { now: deps.clock.now, sleep: async () => { } } }, sample.projectId, revisionId);
+    if (view === undefined)
+        return [];
+    const wanted = [
+        { role: "thumbnail", roles: ["thumbnail"] },
+        { role: "picture", roles: ["image"] },
+        { role: "narration", roles: ["audio_export", "audio_mp3", "audio_body"] },
+    ];
+    const files = [];
+    for (const { role, roles } of wanted) {
+        const limit = role === "picture" ? packLimits.pictures : 1;
+        let taken = 0;
+        for (const wantedRole of roles)
+            for (const row of view.outputs) {
+                if (taken >= limit)
+                    break;
+                if (!row.selected || !row.available || row.state !== "ready")
+                    continue;
+                if (row.output.role !== wantedRole)
+                    continue;
+                const found = findRevisionDownload(deps, sample.projectId, revisionId, row.recordId);
+                if (!found.ok)
+                    continue;
+                const extension = extensionOf(found.download.path);
+                if (extension === undefined || found.download.bytes > packLimits.sampleBytes)
+                    continue;
+                taken += 1;
+                files.push({
+                    role,
+                    name: row.output.path.split("/").pop() ?? `${role}.${extension}`,
+                    path: found.download.path,
+                    bytes: found.download.bytes,
+                    extension,
+                });
+            }
+    }
+    return files;
+}
+const slug = (name) => name
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 60) || "template";
+// Export pack: the newest version its schedules may run (marked ready, carried, or saved
+// before the studio), with the Library's text of each prompt it names as it is now.
+export async function exportPack(deps, templateId, samples = (id) => sampleFilesOf(deps, id)) {
+    const head = templateById(deps.db, templateId);
+    if (head === undefined)
+        return {
+            ok: false,
+            reason: "not-found",
+            message: "This template no longer exists; it may have been deleted. Go to Library → Templates to see your templates.",
+        };
+    const runs = checkedVersion(gatesOf(deps.db, templateId), head.version);
+    const template = runs === undefined ? undefined : templateById(deps.db, templateId, runs);
+    if (template === undefined)
+        return {
+            ok: false,
+            reason: "not-ready",
+            message: "No version of this template is marked ready, so there is nothing to put in a pack: a pack carries what you checked. Press Mark ready in the studio, then Export pack.",
+        };
+    const setup = templateSetup(deps, template.document);
+    if (!setup.ok)
+        return {
+            ok: false,
+            reason: "invalid-input",
+            message: `Version ${String(template.version)} names a prompt or intro/outro that was deleted, so its text can't go into the pack. Choose another in the studio, Save, Mark ready, then Export pack.`,
+        };
+    const document = setup.value;
+    const { audio } = document.form;
+    const saved = listVoices(deps.db).find((voice) => voice.provider === audio.provider && voice.voiceId === audio.voice);
+    const files = samples(templateId);
+    const named = files.map((file, index) => ({
+        ...file,
+        entry: `samples/${file.role}-${String(index + 1)}.${file.extension}`,
+    }));
+    const manifest = {
+        format: packFormat,
+        formatVersion: packFormatVersion,
+        exportedAt: deps.clock.now().toISOString(),
+        slopifyVersion: deps.version.slice(0, 40),
+        template: { name: template.name, version: template.version, document },
+        voice: audio.provider === "" || audio.voice === ""
+            ? null
+            : { provider: audio.provider, voiceId: audio.voice, name: saved?.name ?? audio.voice },
+        samples: named.map((file) => ({ file: file.entry, role: file.role, name: file.name })),
+    };
+    const json = JSON.stringify(manifest, null, 2);
+    if (looksSecret(json))
+        return {
+            ok: false,
+            reason: "invalid-input",
+            message: "Something in this template looks like an API key or a login token (a keyword's value or a prompt's text), so no pack was made: a pack is meant to be shared. Remove it in the studio, Save, Mark ready, then press Export pack again.",
+        };
+    const entries = { "manifest.json": [strToU8(json), { level: 6 }] };
+    for (const file of named) {
+        // Pictures and audio are compressed already: stored as they are.
+        entries[file.entry] = [new Uint8Array(await readFile(file.path)), { level: 0 }];
+    }
+    return {
+        ok: true,
+        value: {
+            filename: `${slug(template.name)}.slopify-pack.zip`,
+            bytes: zipSync(entries),
+            version: template.version,
+        },
+    };
+}

package/dist/slices/template-studio/paid-view.js

@@ -0,0 +1,66 @@
+import { projectExists } from "../admission/repo.js";
+import { templateById } from "../project-templates/repo.js";
+import { currentRevisionId } from "../revisions/repo.js";
+import { getRevisionView } from "../revisions/view.js";
+import { runningJob } from "./jobs.js";
+import { sampleOf, sampleVersions } from "./repo.js";
+import { sectionOfWork } from "./sections.js";
+import { paidStatuses } from "./status.js";
+export function paidView(deps, templateId, head) {
+    const versions = sampleVersions(deps.db, templateId);
+    const row = versions.find((one) => one.templateVersion === head.version);
+    const sample = sampleOf(deps.db, templateId);
+    const projectId = sample !== undefined && projectExists(deps.db, sample.projectId) ? sample.projectId : null;
+    const revisionId = projectId === null ? null : (currentRevisionId(deps.db, projectId) ?? null);
+    const revision = projectId === null || revisionId === null
+        ? undefined
+        : getRevisionView({
+            db: deps.db,
+            paths: deps.paths,
+            log: deps.log,
+            ids: { next: () => "" },
+            clock: { now: () => new Date(), sleep: async () => undefined },
+        }, projectId, revisionId);
+    const outputs = revision === undefined || projectId === null || revisionId === null
+        ? []
+        : revision.outputs.flatMap((row) => {
+            const section = sectionOfWork(row.workKey);
+            if (!row.selected || !row.available || row.state !== "ready" || section === undefined)
+                return [];
+            return [
+                {
+                    section,
+                    role: row.output.role,
+                    url: `/files/${encodeURIComponent(projectId)}/revisions/${encodeURIComponent(revisionId)}/${encodeURIComponent(row.recordId)}`,
+                    name: row.output.path.split("/").pop() ?? row.output.path,
+                },
+            ];
+        });
+    const running = runningJob(deps.db);
+    return {
+        view: {
+            projectId,
+            revisionId,
+            state: row?.state ?? null,
+            sentence: row?.heldReason ?? null,
+            quotedHigh: row?.quotedHigh ?? null,
+            article: revision?.articleMarkdown ?? null,
+            outputs,
+            versions: versions.map((one) => ({
+                version: one.templateVersion,
+                state: one.state,
+                updatedAt: one.updatedAt,
+            })),
+        },
+        statuses: paidStatuses({
+            headVersion: head.version,
+            headDocument: head.document,
+            versions,
+            documentOf: (version) => templateById(deps.db, templateId, version)?.document,
+            running: running?.templateId === templateId &&
+                running.templateVersion === head.version &&
+                running.kind !== "free",
+            busyElsewhere: running !== undefined && running.templateId !== templateId,
+        }),
+    };
+}