@gentbajko/slopify 2.5.0 → 3.0.0

package/dist/slices/onboarding/quick-short.js

@@ -0,0 +1,129 @@
+import { titleMax } from "../admission/rules.js";
+import { defaultSentencePauseSeconds } from "../narration/pauses-model.js";
+const textClis = ["claude-code", "codex", "gemini"];
+const keyedImages = ["openai-image", "google-image", "fal", "replicate"];
+const keyedVoices = ["openai-tts", "elevenlabs", "cartesia", "inworld"];
+// The first model of these providers is the one a first short uses, unless one of these is
+// listed: a fast, capable default rather than the slowest or the smallest.
+const preferred = {
+    "claude-code": /sonnet/i,
+    "openai-tts": /^gpt-4o-mini-tts$/,
+};
+function ready(status) {
+    if (status === undefined)
+        return false;
+    const readiness = status.readiness;
+    return readiness.kind === "cli"
+        ? readiness.installed && readiness.issue === undefined
+        : readiness.hasKey;
+}
+async function firstModel(modelsFor, provider, family) {
+    let models;
+    try {
+        models = await modelsFor(provider, family);
+    }
+    catch {
+        return undefined;
+    }
+    const liked = preferred[provider];
+    return ((liked === undefined ? undefined : models.find((model) => liked.test(model.id)))?.id ??
+        models[0]?.id);
+}
+export async function planShortProviders(input) {
+    const status = (id) => input.statuses.find((row) => row.id === id);
+    const gaps = [];
+    let llm;
+    for (const id of [...textClis, "openrouter"]) {
+        if (!ready(status(id)))
+            continue;
+        const model = await firstModel(input.modelsFor, id, "llm");
+        if (model !== undefined) {
+            llm = { provider: id, model };
+            break;
+        }
+    }
+    if (llm === undefined)
+        gaps.push({
+            need: "text",
+            message: "No text model is ready. Install Claude Code, Codex or Gemini CLI and sign in to it (Settings → Providers shows what Slopify found), or add an OpenRouter key in Settings → Providers.",
+        });
+    let images;
+    for (const id of ["codex-image", ...keyedImages]) {
+        if (!ready(status(id)))
+            continue;
+        const model = await firstModel(input.modelsFor, id, "image");
+        if (model !== undefined) {
+            images = { provider: id, model };
+            break;
+        }
+    }
+    if (images === undefined)
+        gaps.push({
+            need: "images",
+            message: "No image model is ready. Install Codex CLI and sign in to it, or add an OpenAI, Google, fal.ai or Replicate key in Settings → Providers.",
+        });
+    let audio;
+    const saved = input.voices.find((voice) => ready(status(voice.provider)));
+    const provider = saved?.provider ??
+        (ready(status(input.suggested.provider)) ? input.suggested.provider : undefined);
+    if (provider !== undefined) {
+        const model = await firstModel(input.modelsFor, provider, "tts");
+        if (model !== undefined)
+            audio = { provider, model, voice: saved?.voiceId ?? input.suggested.voiceId };
+    }
+    if (audio === undefined)
+        gaps.push({
+            need: "voice",
+            message: keyedVoices.some((id) => ready(status(id)))
+                ? "Your voice provider has no saved voice yet. Add one in Settings → Voices, then try again."
+                : "No voice is ready to narrate the short: command-line tools can't speak. Add an OpenAI, ElevenLabs, Cartesia or Inworld key in Settings → Providers (with ElevenLabs, Cartesia or Inworld, also save a voice in Settings → Voices).",
+        });
+    return llm === undefined || images === undefined || audio === undefined
+        ? { ok: false, gaps }
+        : { ok: true, providers: { llm, audio, images } };
+}
+// The short-mode draft for a topic, using the pack's (or starter set's) script and scene
+// prompts under the names they have in the library.
+export function shortDraft(input) {
+    const topic = input.topic.trim().replace(/\s+/g, " ");
+    const title = `${topic.charAt(0).toUpperCase()}${topic.slice(1)}`.slice(0, titleMax);
+    const { style } = input.pack;
+    return {
+        mode: "short",
+        title,
+        format: "9:16",
+        sources: {
+            research: "off",
+            article: "generate",
+            audio: "generate",
+            images: "generate",
+            thumbnail: "off",
+            video: "generate",
+            document: "off",
+        },
+        llm: input.providers.llm,
+        audio: input.providers.audio,
+        images: input.providers.images,
+        articlePrompt: input.names.shortScript ?? "",
+        imagePrompts: [{ name: input.names.image ?? "", number: shortImages }],
+        values: { topic },
+        provided: {},
+        silenceGapSeconds: 0.5,
+        imageSeconds: shortImageSeconds,
+        zoomPercent: style.zoomPercent,
+        motionStyle: style.motionStyle,
+        edgeSilenceSeconds: 0.5,
+        ...(input.loudness === undefined ? {} : { loudness: input.loudness }),
+        sentencePauseSeconds: defaultSentencePauseSeconds,
+        subtitles: {
+            mode: "off",
+            language: "en",
+            fontId: "default",
+            fontSize: style.captions.fontSize,
+            position: style.captions.position,
+        },
+    };
+}
+// Four images of fifteen seconds each: a minute of narration.
+export const shortImages = 4;
+export const shortImageSeconds = 15;

package/dist/slices/onboarding/sample.js

@@ -0,0 +1,132 @@
+import { createReadStream, existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { importBackup } from "../storage/backup-import.js";
+import { deleteProject } from "../storage/delete-project.js";
+import { projectTitle } from "../storage/repo.js";
+import { copyProject } from "./copy.js";
+import { sampleIds } from "./model.js";
+import { readSampleRecord, writeSampleRecord } from "./state.js";
+// The bundled samples: finished projects that ship with the app as backup archives
+// (`assets/sample/`, built by `src/sample-build/`) - "The Library of Alexandria" (video,
+// shorts, article, PDF, description, captions, images), an audiobook read by a narrator and two
+// character voices, and a two-host podcast. Each is imported on first launch, can be played
+// and explored for free, and is read-only: the HTTP edge refuses every change to it, so nothing
+// on it can ever reach a paid provider. "Make my own copy" clones one into an ordinary project;
+// Settings → Restore samples brings back the originals.
+const bundled = (file) => fileURLToPath(new URL(`../../assets/sample/${file}`, import.meta.url));
+export const sampleArchives = {
+    library: bundled("sample-project.tar"),
+    audiobook: bundled("sample-audiobook.tar"),
+    podcast: bundled("sample-podcast.tar"),
+};
+export const sampleArchive = sampleArchives.library;
+const archiveOf = (deps, id) => deps.archives?.[id] ?? sampleArchives[id];
+function recordedProject(db, id) {
+    const record = readSampleRecord(db, id);
+    return record !== undefined && projectTitle(db, record.projectId) !== undefined
+        ? record.projectId
+        : undefined;
+}
+// The Library of Alexandria's project, while it is in Projects.
+export function sampleProjectId(db) {
+    return recordedProject(db, "library");
+}
+export function sampleProjectIds(db) {
+    return {
+        library: recordedProject(db, "library") ?? null,
+        audiobook: recordedProject(db, "audiobook") ?? null,
+        podcast: recordedProject(db, "podcast") ?? null,
+    };
+}
+export function isSampleProject(db, projectId) {
+    return sampleIds.some((id) => readSampleRecord(db, id)?.projectId === projectId);
+}
+// First launch only, for each sample: once one was seeded, deleting it keeps it deleted until
+// Restore samples is pressed. A sample added in a later version is seeded on the first launch
+// of that version.
+export async function seedSamples(deps) {
+    const outcomes = {};
+    for (const id of sampleIds) {
+        if (readSampleRecord(deps.db, id) !== undefined) {
+            outcomes[id] = "already-seeded";
+            continue;
+        }
+        const archive = archiveOf(deps, id);
+        if (!existsSync(archive)) {
+            deps.log.write("warn", "sample.seed", {
+                detail: `A bundled sample project is missing from this install (${archive}).`,
+            });
+            outcomes[id] = "missing";
+            continue;
+        }
+        await importSample(deps, id, archive);
+        outcomes[id] = "seeded";
+    }
+    return {
+        library: outcomes.library ?? "missing",
+        audiobook: outcomes.audiobook ?? "missing",
+        podcast: outcomes.podcast ?? "missing",
+    };
+}
+// Puts back every sample as it shipped: one that was deleted comes back, one that is there is
+// replaced by the original. Copies made of them are not touched.
+export async function restoreSamples(deps) {
+    const missing = sampleIds.filter((id) => !existsSync(archiveOf(deps, id)));
+    if (missing.length > 0)
+        return {
+            ok: false,
+            status: 500,
+            detail: "The sample projects aren't all part of this install, so they can't be restored. Update Slopify (npx @gentbajko/slopify@latest, or pull the latest Docker image) and try Restore samples again.",
+        };
+    for (const id of sampleIds) {
+        // The recorded sample, even when it waits in Settings → Trash: its rows would stop the
+        // archive's copy (same ids) from coming in, so it is removed for good first.
+        const current = readSampleRecord(deps.db, id)?.projectId;
+        if (current !== undefined) {
+            const removed = deleteProject({
+                db: deps.db,
+                paths: deps.paths,
+                log: deps.log,
+                ...(deps.hasInflight === undefined ? {} : { hasInflight: deps.hasInflight }),
+            }, current);
+            if (!removed.ok && removed.reason !== "no-project")
+                return {
+                    ok: false,
+                    status: removed.reason === "running" ? 409 : 500,
+                    detail: removed.reason === "running"
+                        ? "A sample is still being worked on, so it can't be replaced. Wait for it to finish, then press Restore samples again."
+                        : "Some of an old sample's files couldn't be removed. Close any program using files in its project folder, then press Restore samples again.",
+                };
+        }
+        await importSample(deps, id, archiveOf(deps, id));
+    }
+    return { ok: true, samples: sampleProjectIds(deps.db) };
+}
+async function importSample(deps, id, archive) {
+    const summary = await importBackup(deps, createReadStream(archive));
+    const skipped = summary.projects.skipped[0];
+    const project = summary.projects.imported[0] ??
+        (skipped !== undefined && projectTitle(deps.db, skipped.id) !== undefined
+            ? skipped
+            : undefined);
+    if (project === undefined)
+        throw new Error(`Slopify couldn't add a sample project${skipped === undefined ? "" : ` (${skipped.reason})`}. Reinstall Slopify, then try Restore samples in Settings → Backup & storage; if it happens again, use Download diagnostics in Settings and report it.`);
+    writeSampleRecord(deps.db, { projectId: project.id, seededAt: deps.clock.now().toISOString() }, id);
+    return project.id;
+}
+export function copySample(deps, projectId) {
+    if (!isSampleProject(deps.db, projectId))
+        return {
+            ok: false,
+            status: 404,
+            detail: "Only a sample project can be copied this way. Open the sample from Projects and press Make my own copy there.",
+        };
+    const title = projectTitle(deps.db, projectId);
+    if (title === undefined)
+        return {
+            ok: false,
+            status: 404,
+            detail: "That sample project is no longer here. Bring it back with Settings → Backup & storage → Restore samples, then press Make my own copy.",
+        };
+    return { ok: true, ...copyProject(deps, projectId, `${title} (my copy)`) };
+}

package/dist/slices/onboarding/state.js

@@ -0,0 +1,68 @@
+import { z } from "zod";
+import { readSetting, writeSetting } from "../settings/repo.js";
+// What the first five minutes remember, in the settings table: whether the first-run screen
+// was dismissed, which project is the bundled sample, and which library rows each installed
+// starter pack became. None of these keys is in a portable backup's settings, so another
+// install decides its own first run.
+export const dismissedKey = "onboarding.dismissed";
+export const sampleKey = "onboarding.sample";
+export const packsKey = "onboarding.packs";
+export const shortRequestsKey = "onboarding.short-requests";
+const sampleRecord = z.object({
+    projectId: z.string(),
+    seededAt: z.string(),
+});
+const packRecord = z.object({
+    installedAt: z.string(),
+    prompts: z.record(z.string(), z.string()),
+    voice: z.string().optional(),
+    template: z.string().optional(),
+});
+const packRecords = z.record(z.string(), packRecord);
+// A request id → the project it started, so a repeated "Make a 60-second short" (a double
+// click, a retried request) returns the same project instead of starting another.
+const shortRequests = z.record(z.string(), z.string());
+// ceiling: only a retry of a recent click needs its answer.
+const shortRequestsKept = 20;
+function readJson(db, key, schema) {
+    const raw = readSetting(db, key);
+    if (raw === undefined)
+        return undefined;
+    try {
+        const parsed = schema.safeParse(JSON.parse(raw));
+        return parsed.success ? parsed.data : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function firstRunDismissed(db) {
+    return readSetting(db, dismissedKey) !== undefined;
+}
+export function dismissFirstRun(db, at) {
+    if (!firstRunDismissed(db))
+        writeSetting(db, dismissedKey, at);
+}
+// Each bundled sample is remembered on its own ("The Library of Alexandria" under the key it
+// always had), so a demo added in a later version is seeded once on an install that already
+// has the first.
+const sampleKeyOf = (id) => (id === "library" ? sampleKey : `${sampleKey}.${id}`);
+export function readSampleRecord(db, id = "library") {
+    return readJson(db, sampleKeyOf(id), sampleRecord);
+}
+export function writeSampleRecord(db, record, id = "library") {
+    writeSetting(db, sampleKeyOf(id), JSON.stringify(record));
+}
+export function readPackRecords(db) {
+    return readJson(db, packsKey, packRecords) ?? {};
+}
+export function writePackRecord(db, packId, record) {
+    writeSetting(db, packsKey, JSON.stringify({ ...readPackRecords(db), [packId]: record }));
+}
+export function shortRequestProject(db, requestId) {
+    return readJson(db, shortRequestsKey, shortRequests)?.[requestId];
+}
+export function recordShortRequest(db, requestId, projectId) {
+    const kept = Object.entries(readJson(db, shortRequestsKey, shortRequests) ?? {}).slice(-(shortRequestsKept - 1));
+    writeSetting(db, shortRequestsKey, JSON.stringify(Object.fromEntries([...kept, [requestId, projectId]])));
+}

package/dist/slices/onboarding/template.js

@@ -0,0 +1,73 @@
+import { defaultEdgeSilenceSeconds } from "../admission/rules.js";
+import { playDraftDocumentSchema } from "../play-drafts/schema.js";
+// A pack's Play template: its prompts ticked, its voice picked, its style set, and the text and
+// image providers left for the user to choose, since which of them is installed or keyed
+// differs per machine.
+export function packTemplate(pack, names, voiceId) {
+    const { style } = pack;
+    const name = (key) => names[key] ?? "";
+    return playDraftDocumentSchema.parse({
+        schemaVersion: 1,
+        form: {
+            title: "",
+            format: "16:9",
+            sources: {
+                research: style.research ? "generate" : "off",
+                article: "generate",
+                audio: "generate",
+                images: "generate",
+                thumbnail: name("thumbnail") === "" ? "off" : "from_prompt",
+                video: "generate",
+                document: "off",
+            },
+            llm: { provider: "", model: "" },
+            audio: {
+                provider: pack.voice.provider,
+                model: pack.voice.model,
+                voice: voiceId,
+                usePronunciationGlossary: true,
+                shareGlossary: true,
+                describeFigures: true,
+            },
+            images: { provider: "", model: "" },
+            articlePrompt: name("article"),
+            narrationPrompt: "",
+            youtubeDescription: name("description") !== "",
+            showFigures: true,
+            descriptionPrompt: name("description"),
+            shorts: {
+                enabled: name("shorts") !== "",
+                count: "2",
+                minSeconds: "45",
+                maxSeconds: "90",
+                prompt: name("shorts"),
+                imagePrompt: name("image"),
+                titleOnScreen: true,
+            },
+            imagePrompts: name("image") === "" ? [] : [{ name: name("image"), number: String(style.imagesPerVideo) }],
+            thumbnailPrompt: name("thumbnail"),
+            intro: "",
+            outro: "",
+            chunking: { mode: "whole", words: "500", characters: "3000" },
+            subtitles: {
+                mode: "burn-in",
+                language: "en",
+                fontId: "default",
+                fontSize: String(style.captions.fontSize),
+                position: style.captions.position,
+            },
+            imageSeconds: String(style.imageSeconds),
+            edgeSilenceSeconds: String(defaultEdgeSilenceSeconds),
+            zoomPercent: String(style.zoomPercent),
+            motionStyle: style.motionStyle,
+            videoEdit: style.videoEdit,
+            values: {},
+            provided: { research: "", article: "", audio: null, images: [], thumbnail: null },
+        },
+        section: "content",
+        variants: [],
+        expectedWords: String(style.expectedWords),
+        previewText: "Every story begins with a word.",
+        fontUpload: null,
+    });
+}

package/dist/slices/patch-notes/library.js

@@ -0,0 +1,73 @@
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { z } from "zod";
+// The patch notes the app shows in Settings → Patch notes: Markdown files kept in the
+// repository's docs/patch-notes/ and copied into the build beside the compiled code
+// (scripts/copy-assets.mjs). index.json lists them with a title and a date; each note is
+// `<id>.md` beside it. Nothing here writes: the notes are part of the release.
+export const patchNoteIdPattern = /^[0-9A-Za-z][0-9A-Za-z.-]{0,63}$/;
+const entry = z
+    .object({
+    id: z.string().regex(patchNoteIdPattern),
+    title: z.string().min(1).max(200),
+    date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/),
+    // The one version a note is for ("3.0.0"), or the stretch it covers ("2.0.1 to 3.0.0").
+    version: z.string().max(40).optional(),
+    range: z.string().max(80).optional(),
+})
+    .strict();
+const index = z.array(entry).max(500);
+// dist/patch-notes when running the build; the repository's docs/patch-notes when running
+// from source (tests, `tsx`).
+export function bundledPatchNotesDir() {
+    const candidates = ["../../patch-notes/", "../../../../../docs/patch-notes/"].map((path) => fileURLToPath(new URL(path, import.meta.url)));
+    return candidates.find((dir) => existsSync(join(dir, "index.json"))) ?? candidates[0];
+}
+export class PatchNotesMissing extends Error {
+}
+// Newest first by date; notes of the same day keep the index's order.
+export async function listPatchNotes(dir) {
+    let raw;
+    try {
+        raw = await readFile(join(dir, "index.json"), "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            throw new PatchNotesMissing("This copy of Slopify has no patch notes: its docs/patch-notes/index.json is missing. Reinstall Slopify (or run npm run build) and reload the page.");
+        throw error;
+    }
+    let json;
+    try {
+        json = JSON.parse(raw);
+    }
+    catch (error) {
+        if (!(error instanceof SyntaxError))
+            throw error;
+        json = undefined;
+    }
+    const parsed = index.safeParse(json);
+    if (!parsed.success)
+        throw new PatchNotesMissing("This copy of Slopify has a damaged patch notes list (docs/patch-notes/index.json). Reinstall Slopify (or fix the file and run npm run build) and reload the page.");
+    return parsed.data
+        .map((note, order) => ({ note, order }))
+        .sort((a, b) => b.note.date.localeCompare(a.note.date) || a.order - b.order)
+        .map(({ note }) => note);
+}
+// A note's Markdown, or undefined when the index does not list it.
+export async function readPatchNote(dir, id) {
+    if (!patchNoteIdPattern.test(id))
+        return undefined;
+    const notes = await listPatchNotes(dir);
+    if (!notes.some((note) => note.id === id))
+        return undefined;
+    try {
+        return await readFile(join(dir, `${id}.md`), "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    }
+}

package/dist/slices/patch-notes/seen.js

@@ -0,0 +1,77 @@
+import { transact } from "../../kernel/db/tx.js";
+import { readSetting, writeSetting } from "../settings/repo.js";
+import { machineOf } from "../telemetry/repo.js";
+import { listPatchNotes } from "./library.js";
+// The patch notes open by themselves once, on the first start of a version that has notes of
+// its own, after an update. The newest version whose notes this install has closed (or read
+// from the What's new tour) lives in one settings key, so it is once per install rather than
+// once per browser. Backups leave it out, like the tour's key.
+export const patchNotesSeenKey = "patchNotes.seenVersion";
+function releaseOf(version) {
+    const match = /^(\d+)\.(\d+)\.(\d+)/.exec(version);
+    return match === null ? undefined : [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+// Whether `a` is a later release than `b`; false when either is not a release number.
+export function isNewerRelease(a, b) {
+    const left = releaseOf(a);
+    const right = releaseOf(b);
+    if (left === undefined || right === undefined)
+        return false;
+    for (const at of [0, 1, 2])
+        if (left[at] !== right[at])
+            return left[at] > right[at];
+    return false;
+}
+// The newest version whose notes were seen; undefined when none was recorded, null when the
+// stored value is damaged.
+function seenVersion(db) {
+    const raw = readSetting(db, patchNotesSeenKey);
+    if (raw === undefined)
+        return undefined;
+    let value;
+    try {
+        value = JSON.parse(raw);
+    }
+    catch (error) {
+        if (!(error instanceof SyntaxError))
+            throw error;
+        return null;
+    }
+    return typeof value === "string" && releaseOf(value) !== undefined ? value : null;
+}
+// Telling an update from a fresh install works as for the What's new tour
+// (slices/settings/whats-new.ts): before the first close, the machine row, written once when
+// the first-run notice is dismissed, keeps the version that was running then. A fresh install
+// has no machine yet or one stamped with the running version, so its notes do not open.
+export function duePatchNote(db, version, notes) {
+    const note = notes.find((item) => item.version === version);
+    if (note === undefined)
+        return null;
+    const seen = seenVersion(db);
+    // A damaged value is not a reason to open the notes on every launch.
+    if (seen === null)
+        return null;
+    if (seen !== undefined)
+        return isNewerRelease(version, seen) ? note.id : null;
+    const machine = machineOf(db);
+    if (machine === undefined)
+        return null;
+    return isNewerRelease(version, machine.appVersion) ? note.id : null;
+}
+export async function readPatchNotes(db, dir, version) {
+    const notes = await listPatchNotes(dir);
+    const current = notes.find((note) => note.version === version) ?? notes[0];
+    return { version, current: current?.id ?? null, due: duePatchNote(db, version, notes), notes };
+}
+// Closing the notes, or the What's new tour that stands in for them on a major update,
+// records the running version. Idempotent, and never lowers the value, so running an older
+// version for a while and updating again does not bring back notes already closed.
+export function markPatchNotesSeen(db, version) {
+    if (releaseOf(version) === undefined)
+        return;
+    transact(db, () => {
+        const seen = seenVersion(db);
+        if (seen === undefined || seen === null || isNewerRelease(version, seen))
+            writeSetting(db, patchNotesSeenKey, JSON.stringify(version));
+    });
+}