@gentbajko/slopify 0.5.1 → 0.7.0

package/dist/slices/video/write-export.js

@@ -1,12 +1,18 @@
-import { mkdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { copyFileSync, existsSync, mkdirSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
 import { dirname } from "node:path";
 import { transact } from "../../kernel/db/tx.js";
 import { setStageProgress } from "../admission/repo.js";
 import { outputPath } from "../storage/layout.js";
 import { deleteOutput, insertOutput, outputsOf } from "../storage/repo.js";
+import { subtitleRoles } from "../subtitles/prepare.js";
 import { runFfmpeg } from "./ffmpeg.js";
 const progressIntervalMs = 500;
-const renderRoles = ["video", "audio_export", "render_params"];
+const renderRoles = [
+    "video",
+    "audio_export",
+    "render_params",
+    ...subtitleRoles,
+];
 // Both local exports retain the previous finished asset until ffmpeg succeeds and
 // the abort check passes. The part file keeps its muxer's filename extension.
 export async function writeExport(deps, context, output) {
@@ -23,6 +29,7 @@ export async function writeExport(deps, context, output) {
         await runFfmpeg({
             bin: deps.ffmpeg,
             args: output.args(part),
+            cwd: output.subtitles?.directory,
             signal: context.signal,
             log: deps.log,
             onProgress: (elapsedMs) => {
@@ -31,7 +38,9 @@ export async function writeExport(deps, context, output) {
                     return;
                 }
                 announced = at;
-                const current = Math.min(elapsedMs, totalMs);
+                const current = output.subtitles === undefined
+                    ? Math.min(elapsedMs, totalMs)
+                    : Math.round((0.35 + 0.65 * Math.min(elapsedMs / totalMs, 1)) * totalMs);
                 setStageProgress(deps.db, context.stage.id, current, totalMs);
                 context.emit({
                     type: "stage.progress",
@@ -51,26 +60,82 @@ export async function writeExport(deps, context, output) {
         // A partial render file is discarded, never kept or served. Only the part file: the
         // previous export is a finished output and stays downloadable.
         rmSync(part, { force: true });
+        if (output.subtitles !== undefined)
+            rmSync(output.subtitles.directory, { recursive: true, force: true });
         throw error;
     }
-    // The swap. Everything below replaces the previous render, and nothing above it could.
-    renameSync(part, target);
     const params = outputPath(deps.paths, projectId, "render.json");
-    writeFileSync(params, `${JSON.stringify(output.record, null, 2)}\n`, { mode: 0o600 });
-    // No version history. The files were written under the names the previous render
-    // already used, so replacing the rows that named them is all that is left to do. In one
-    // transaction, or a crash between the delete and the insert would leave the finished
-    // export with no row and the boot reconcile would collect it. Read back rather than
-    // reused from above: the rows are what a download resolves.
-    transact(deps.db, () => {
-        for (const previous of outputsOf(deps.db, projectId)) {
-            if (renderRoles.includes(previous.role)) {
-                deleteOutput(deps.db, previous.id);
+    const previousOutputs = outputsOf(deps.db, projectId);
+    const replaced = [];
+    const paramsPart = outputPath(deps.paths, projectId, "render.part.json");
+    let committed = false;
+    try {
+        writeFileSync(paramsPart, `${JSON.stringify(output.record, null, 2)}\n`, { mode: 0o600 });
+        // The DB commit can fail after ffmpeg succeeds. Keep rollback copies until all
+        // media, caption and font rows commit, so a failed export keeps its old playback.
+        for (const path of [target, params]) {
+            const saved = { path, backup: `${path}.previous`, existed: existsSync(path), swapped: false };
+            if (saved.existed)
+                copyFileSync(path, saved.backup);
+            replaced.push(saved);
+        }
+        for (const saved of replaced) {
+            renameSync(saved.path === target ? part : paramsPart, saved.path);
+            saved.swapped = true;
+        }
+        transact(deps.db, () => {
+            for (const previous of previousOutputs) {
+                if (renderRoles.includes(previous.role))
+                    deleteOutput(deps.db, previous.id);
             }
+            store(deps, projectId, "render_params", "render.json", null);
+            store(deps, projectId, output.role, output.filename, totalMs, {
+                subtitlesMode: output.subtitles === undefined ? "off" : output.subtitles.burnIn ? "burn-in" : "files",
+            });
+            for (const asset of output.subtitles?.assets ?? [])
+                store(deps, projectId, asset.role, asset.path, null);
+        });
+        committed = true;
+    }
+    catch (error) {
+        for (const saved of replaced) {
+            if (!saved.swapped)
+                continue;
+            if (saved.existed)
+                renameSync(saved.backup, saved.path);
+            else
+                rmSync(saved.path, { force: true });
+            saved.swapped = false;
         }
-        store(deps, projectId, "render_params", "render.json", null);
-        store(deps, projectId, output.role, output.filename, totalMs);
-    });
+        rmSync(part, { force: true });
+        rmSync(paramsPart, { force: true });
+        if (output.subtitles !== undefined)
+            rmSync(output.subtitles.directory, { recursive: true, force: true });
+        throw error;
+    }
+    finally {
+        for (const saved of replaced) {
+            if (!committed && saved.swapped)
+                continue;
+            try {
+                rmSync(saved.backup, { force: true });
+            }
+            catch {
+                /* A retained backup is collected at the next boot. */
+            }
+        }
+    }
+    const kept = new Set(outputsOf(deps.db, projectId).map((one) => one.path));
+    for (const previous of previousOutputs) {
+        if (renderRoles.includes(previous.role) && !kept.has(previous.path)) {
+            try {
+                rmSync(outputPath(deps.paths, projectId, previous.path), { force: true });
+            }
+            catch {
+                /* Boot reconciliation collects a file that could not be removed. */
+            }
+        }
+    }
     // Written as well as emitted: a page opened after the render reads the row, and the
     // throttled in-flight writes would have left it frozen short of the end.
     setStageProgress(deps.db, context.stage.id, totalMs, totalMs);
@@ -82,7 +147,7 @@ export async function writeExport(deps, context, output) {
         total: totalMs,
     });
 }
-function store(deps, projectId, role, path, durationMs) {
+function store(deps, projectId, role, path, durationMs, meta = {}) {
     insertOutput(deps.db, {
         id: deps.ids.next(),
         projectId,
@@ -92,7 +157,7 @@ function store(deps, projectId, role, path, durationMs) {
         originalFilename: null,
         bytes: statSync(outputPath(deps.paths, projectId, path)).size,
         durationMs,
-        meta: {},
+        meta,
         createdAt: deps.clock.now().toISOString(),
     });
 }

package/dist/updater/candidate.js

@@ -0,0 +1,28 @@
+export function watchActivation(updater, token, expired, report) {
+    let checking = false;
+    const until = Date.now() + 120_000;
+    const timer = setInterval(() => {
+        if (checking)
+            return;
+        checking = true;
+        void updater
+            .activate(token)
+            .then(async (activated) => {
+            if (activated)
+                clearInterval(timer);
+            else if (Date.now() >= until) {
+                clearInterval(timer);
+                report("The update was not committed; stopping the candidate server.");
+                await expired();
+            }
+        })
+            .catch(() => {
+            report("The update activation marker could not be checked.");
+        })
+            .finally(() => {
+            checking = false;
+        });
+    }, 250);
+    timer.unref();
+    return () => clearInterval(timer);
+}

package/dist/updater/forward.js

@@ -0,0 +1,35 @@
+import { spawn } from "node:child_process";
+import { activeUpdateEntry } from "./plan.js";
+export async function forwardManagedUpdate(dataDir, version, args) {
+    if (process.env.SLOPIFY_SKIP_MANAGED_UPDATE === "1")
+        return undefined;
+    const entry = await activeUpdateEntry(dataDir, version);
+    if (entry === undefined)
+        return undefined;
+    return new Promise((resolve) => {
+        const child = spawn(process.execPath, [entry, ...args], {
+            stdio: "inherit",
+            windowsHide: true,
+        });
+        const interrupt = () => {
+            child.kill("SIGINT");
+        };
+        const terminate = () => {
+            child.kill("SIGTERM");
+        };
+        process.once("SIGINT", interrupt);
+        process.once("SIGTERM", terminate);
+        const cleanup = () => {
+            process.off("SIGINT", interrupt);
+            process.off("SIGTERM", terminate);
+        };
+        child.once("error", () => {
+            cleanup();
+            resolve(undefined);
+        });
+        child.once("close", (code) => {
+            cleanup();
+            resolve(code ?? 1);
+        });
+    });
+}

package/dist/updater/install-flow.js

@@ -0,0 +1,26 @@
+export async function runUpdateFlow(plan, deps) {
+    const entry = await deps.install();
+    // npm or package verification failures leave the currently serving app entirely alone.
+    await deps.handoff();
+    let backedUp = false;
+    try {
+        await deps.backup();
+        backedUp = true;
+        await deps.start(entry);
+        await deps.healthy(plan.version);
+        await deps.activate();
+    }
+    catch {
+        await deps.stopCandidate();
+        if (backedUp)
+            await deps.restore();
+        await deps.start(plan.oldEntry);
+        await deps.healthy(plan.previousVersion);
+        deps.report("The update did not start; the previous version and database were restored.");
+        throw new Error("The previous Slopify version was restored.");
+    }
+    // The pointer rename commits the new database. The candidate may already observe
+    // it and accept writes, so a lost unlock acknowledgement can never trigger rollback.
+    await deps.release();
+    deps.report(`Slopify ${plan.version} started successfully.`);
+}

package/dist/updater/install.js

@@ -0,0 +1,50 @@
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { updatePlanSchema } from "./plan.js";
+export async function launchUpdate(worker, plan, handoff) {
+    updatePlanSchema.parse(plan);
+    const directory = join(plan.dataDir, "updates");
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    const planPath = join(directory, `plan-${randomUUID()}.json`);
+    await writeFile(planPath, JSON.stringify(plan), { mode: 0o600 });
+    const child = spawn(process.execPath, [worker, planPath], {
+        cwd: plan.cwd,
+        detached: true,
+        windowsHide: true,
+        stdio: ["ignore", "ignore", "ignore", "ipc"],
+    });
+    try {
+        await new Promise((resolve, reject) => {
+            let restarting = false;
+            const send = (type) => {
+                if (!child.connected) {
+                    reject(new Error("The update worker disconnected."));
+                    return;
+                }
+                child.send({ type }, (error) => {
+                    if (error !== null)
+                        reject(new Error("The update handoff failed."));
+                });
+            };
+            child.once("error", () => reject(new Error("The update worker could not start.")));
+            child.once("exit", (code) => code === 0 ? resolve() : reject(new Error("The update worker could not finish.")));
+            child.on("message", (message) => {
+                if (typeof message !== "object" || message === null || !("type" in message))
+                    return;
+                if (message.type === "installed" && !restarting) {
+                    restarting = true;
+                    void handoff().then(() => send("handoff"), () => {
+                        send("abort");
+                        reject(new Error("Slopify could not release its server for the update."));
+                    });
+                }
+            });
+        });
+    }
+    finally {
+        child.unref();
+        await rm(planPath, { force: true });
+    }
+}

package/dist/updater/model.js

@@ -0,0 +1,24 @@
+export const updatePackage = "@gentbajko/slopify";
+export const npmRegistry = "https://registry.npmjs.org/";
+const stableVersion = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/;
+export function isStableVersion(value) {
+    return value.length <= 50 && stableVersion.test(value);
+}
+export function newerVersion(candidate, current) {
+    if (!isStableVersion(candidate) || !isStableVersion(current))
+        return false;
+    const left = candidate.split(".").map(BigInt);
+    const right = current.split(".").map(BigInt);
+    for (let index = 0; index < 3; index++) {
+        const a = left[index];
+        const b = right[index];
+        if (a === undefined || b === undefined)
+            return false;
+        if (a !== b)
+            return a > b;
+    }
+    return false;
+}
+export function isUpdateToken(value) {
+    return /^[a-f0-9]{64}$/.test(value);
+}

package/dist/updater/plan.js

@@ -0,0 +1,135 @@
+import { constants } from "node:fs";
+import { access, readFile, realpath, rename, writeFile } from "node:fs/promises";
+import { delimiter, dirname, join } from "node:path";
+import { z } from "zod";
+import { cliCommand } from "../kernel/cli-command.js";
+import { isStableVersion, isUpdateToken, newerVersion, npmRegistry, updatePackage, } from "./model.js";
+export const updatePlanSchema = z.object({
+    token: z.string().refine(isUpdateToken),
+    version: z.string().refine(isStableVersion),
+    previousVersion: z.string().refine(isStableVersion),
+    oldEntry: z.string().min(1),
+    dataDir: z.string().min(1),
+    cwd: z.string().min(1),
+    host: z.string().min(1),
+    port: z.number().int().min(1).max(65535),
+    npm: z.object({ file: z.string().min(1), args: z.array(z.string()) }),
+});
+export function installDirectory(dataDir, version) {
+    if (!isStableVersion(version))
+        throw new Error("Invalid update version.");
+    return join(dataDir, "updates", version);
+}
+export function installArgs(directory, version) {
+    if (!isStableVersion(version))
+        throw new Error("Invalid update version.");
+    return [
+        "install",
+        "--prefix",
+        directory,
+        "--registry",
+        npmRegistry,
+        `--@gentbajko:registry=${npmRegistry}`,
+        "--no-audit",
+        "--no-fund",
+        "--omit=dev",
+        "--save-exact",
+        "--global=false",
+        "--workspaces=false",
+        "--userconfig",
+        join(directory, ".npmrc"),
+        "--globalconfig",
+        join(directory, ".global-npmrc"),
+        "--cache",
+        join(dirname(directory), "npm-cache"),
+        `${updatePackage}@${version}`,
+    ];
+}
+export function restartArgs(entry, plan) {
+    // The existing page reconnects itself; opening a second browser tab on an update is unnecessary.
+    return [
+        entry,
+        "--host",
+        plan.host,
+        "--port",
+        String(plan.port),
+        "--data-dir",
+        plan.dataDir,
+        "--no-open",
+    ];
+}
+export async function installedEntry(dataDir, version) {
+    const directory = join(installDirectory(dataDir, version), "node_modules", "@gentbajko", "slopify");
+    const metadata = z
+        .object({ name: z.literal(updatePackage), version: z.literal(version) })
+        .parse(JSON.parse(await readFile(join(directory, "package.json"), "utf8")));
+    if (metadata.version !== version)
+        throw new Error("Installed update version differs.");
+    const entry = join(directory, "dist", "edge", "cli.js");
+    await access(entry, constants.R_OK);
+    return entry;
+}
+export async function activeUpdateEntry(dataDir, currentVersion) {
+    try {
+        const content = await readFile(join(dataDir, "updates", "current.json"), "utf8");
+        const { version } = z
+            .object({ version: z.string().refine(isStableVersion) })
+            .parse(JSON.parse(content));
+        return newerVersion(version, currentVersion)
+            ? await installedEntry(dataDir, version)
+            : undefined;
+    }
+    catch {
+        // A missing, partial or no-longer-installed pointer must not prevent the original CLI starting.
+        return undefined;
+    }
+}
+export async function activateUpdate(dataDir, version, token) {
+    if (!isUpdateToken(token))
+        throw new Error("Invalid update token.");
+    await installedEntry(dataDir, version);
+    const pointer = join(dataDir, "updates", "current.json");
+    const temporary = `${pointer}.${process.pid}.tmp`;
+    await writeFile(temporary, JSON.stringify({ version, token }), { mode: 0o600 });
+    await rename(temporary, pointer);
+}
+export async function npmCommand() {
+    const nodeDir = dirname(process.execPath);
+    for (const candidate of [
+        join(nodeDir, "node_modules", "npm", "bin", "npm-cli.js"),
+        join(nodeDir, "..", "lib", "node_modules", "npm", "bin", "npm-cli.js"),
+    ]) {
+        try {
+            await access(candidate, constants.R_OK);
+            return { file: process.execPath, args: [await realpath(candidate)] };
+        }
+        catch {
+            /* Try the next standard Node installation layout. */
+        }
+    }
+    if (process.platform === "win32")
+        return cliCommand("npm.cmd");
+    for (const directory of (process.env.PATH ?? "").split(delimiter)) {
+        if (directory === "")
+            continue;
+        const candidate = join(directory, "npm");
+        try {
+            await access(candidate, constants.X_OK);
+            return { file: await realpath(candidate), args: [] };
+        }
+        catch {
+            /* PATH can include directories without npm. */
+        }
+    }
+    throw new Error("npm is unavailable. Install Node.js with npm to use in-app updates.");
+}
+export async function updateCommitted(dataDir, version, token) {
+    try {
+        const pointer = z.object({ version: z.literal(version), token: z.literal(token) });
+        return pointer.safeParse(JSON.parse(await readFile(join(dataDir, "updates", "current.json"), "utf8"))).success;
+    }
+    catch {
+        // Before activation the marker is absent or belongs to the previous release.
+        return false;
+    }
+}

package/dist/updater/readiness.js

@@ -0,0 +1,15 @@
+import { z } from "zod";
+export async function candidateReady(origin, version, token, exited, fetcher) {
+    if (exited())
+        return false;
+    const response = await fetcher(`${origin}/api/update/ready`, {
+        headers: { "X-Slopify-Update-Token": token },
+        signal: AbortSignal.timeout(1500),
+        redirect: "error",
+    });
+    if (!response.ok)
+        return false;
+    const health = z.object({ status: z.literal("ok"), version: z.literal(version) });
+    const matches = health.safeParse(await response.json()).success;
+    return matches && !exited();
+}

package/dist/updater/registry.js

@@ -0,0 +1,19 @@
+import { z } from "zod";
+import { isStableVersion, npmRegistry, updatePackage } from "./model.js";
+const release = z.object({
+    name: z.literal(updatePackage),
+    version: z.string().refine(isStableVersion),
+});
+export async function publishedVersion(fetcher) {
+    const response = await fetcher(`${npmRegistry}@gentbajko%2Fslopify/latest`, {
+        signal: AbortSignal.timeout(10_000),
+        redirect: "error",
+        headers: { Accept: "application/json" },
+    });
+    if (!response.ok)
+        throw new Error("The npm release could not be checked.");
+    const parsed = release.safeParse(await response.json());
+    if (!parsed.success)
+        throw new Error("The npm release metadata is invalid.");
+    return parsed.data.version;
+}

package/dist/updater/service.js

@@ -0,0 +1,128 @@
+import { timingSafeEqual } from "node:crypto";
+import { isStableVersion, isUpdateToken, newerVersion } from "./model.js";
+export function createUpdater(deps) {
+    let latestVersion = null;
+    let checkedAt = -Infinity;
+    let status = deps.candidate?.pending === true ? "restarting" : "idle";
+    let activated = deps.candidate?.pending !== true;
+    let installError = deps.previousUpdateFailed
+        ? "The update did not start. The previous version and database were restored. You can try again."
+        : undefined;
+    let error = installError;
+    let checking;
+    let mutations = 0;
+    const busyNow = () => deps.busy() || mutations > 0;
+    const locked = () => status === "installing" || status === "restarting";
+    function info() {
+        const busy = busyNow();
+        const available = latestVersion !== null && newerVersion(latestVersion, deps.currentVersion);
+        const blockedReason = deps.unsupported() ??
+            (busy
+                ? "Pause running projects and wait for their active work to stop before updating."
+                : locked()
+                    ? "An update is already in progress."
+                    : undefined);
+        return {
+            currentVersion: deps.currentVersion,
+            latestVersion,
+            available,
+            busy,
+            canUpdate: available && blockedReason === undefined,
+            status,
+            ...(error === undefined ? {} : { error }),
+            ...(blockedReason === undefined ? {} : { blockedReason }),
+        };
+    }
+    async function check(refresh = false) {
+        if (locked())
+            return info();
+        if (checking !== undefined) {
+            await checking;
+            return info();
+        }
+        if (!refresh && deps.now() - checkedAt < 15 * 60_000)
+            return info();
+        status = "checking";
+        checking = (async () => {
+            try {
+                const found = await deps.latest();
+                if (!isStableVersion(found))
+                    throw new Error("Invalid release version");
+                latestVersion = found;
+                status = installError === undefined ? "idle" : "error";
+                error = installError;
+            }
+            catch {
+                status = "error";
+                error = "Could not check for updates. Check your connection and try again.";
+                deps.report(error);
+            }
+            finally {
+                checkedAt = deps.now();
+            }
+        })();
+        await checking;
+        checking = undefined;
+        return info();
+    }
+    const ready = (token) => deps.candidate !== undefined &&
+        isUpdateToken(token) &&
+        isUpdateToken(deps.candidate.token) &&
+        timingSafeEqual(Buffer.from(token), Buffer.from(deps.candidate.token));
+    return {
+        ready,
+        activate: async (token) => {
+            if (!ready(token) || deps.candidate === undefined)
+                return false;
+            if (activated)
+                return true;
+            const committed = await deps.candidate.committed();
+            if (activated)
+                return true;
+            if (!committed)
+                return false;
+            activated = true;
+            status = "idle";
+            return true;
+        },
+        check,
+        locked,
+        beginMutation: () => {
+            if (locked())
+                return undefined;
+            mutations++;
+            return () => {
+                mutations--;
+            };
+        },
+        start: async () => {
+            if (locked() || busyNow())
+                return { ok: false, code: 409, info: info() };
+            installError = undefined;
+            await check(true);
+            const current = info();
+            if (!current.canUpdate || latestVersion === null || current.status === "error") {
+                return {
+                    ok: false,
+                    code: current.busy || locked() ? 409 : current.status === "error" ? 503 : 400,
+                    info: current,
+                };
+            }
+            status = "installing";
+            error = undefined;
+            const version = latestVersion;
+            void Promise.resolve()
+                .then(() => deps.install(version, () => {
+                status = "restarting";
+            }))
+                .catch(() => {
+                status = "error";
+                error =
+                    "The update could not be completed. Your current installation is still available. Try again or restart Slopify.";
+                installError = error;
+                deps.report(error);
+            });
+            return { ok: true, info: info() };
+        },
+    };
+}