@gentbajko/slopify 2.4.0 → 3.0.0

package/dist/catalog/schema.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { thinkingModes } from "../kernel/ports/llm.js";
 import { providers } from "../slices/settings/model.js";
 const money = z.number().finite().nonnegative();
 const base = z.object({
@@ -13,6 +14,8 @@ const base = z.object({
         .object({
         inputPerMillionTokens: money.optional(),
         outputPerMillionTokens: money.optional(),
+        // Input read from the provider's prompt cache. Absent, cached input is priced as input.
+        cachedInputPerMillionTokens: money.optional(),
         perMillionCharacters: money.optional(),
         perImage: money.optional(),
         perMinute: money.optional(),
@@ -29,7 +32,7 @@ export const llmModelSchema = base
         maxOutputTokens: z.number().int().positive().optional(),
         webSearch: z.boolean().default(false),
         thinking: z
-            .partialRecord(z.enum(["off", "low", "medium", "high", "xhigh"]), z
+            .partialRecord(z.enum(thinkingModes), z
             .object({
             budget: z.number().int().min(-1).optional(),
             level: z.enum(["minimal", "low", "medium", "high"]).optional(),
@@ -95,6 +98,14 @@ export const catalogueSchema = z
 export function isVideoModel(model) {
     return model.keywords.includes("video");
 }
+// An image model that also takes an input image - so it can draw with the project's
+// establishing image as its visual reference - carries the `reference` keyword, the same way
+// and for the same reason the image-to-video models carry `video`.
+export function takesReferenceImage(model) {
+    return model.keywords.includes("reference");
+}
+// What the run says when the chosen image model cannot take the establishing image.
+export const referenceRefusal = "The chosen image model can't use an establishing image as a reference, so the images can't be drawn to match it. Choose an image model that can (Codex CLI, OpenAI, Google, or a fal.ai model listed with reference) under Images → Model on Play or in Edit project → Providers, or set Establishing image to Off in the Images section.";
 // The image-to-video models a provider offers, as Animate images lists them.
 export function videoModelsOf(catalogue, provider) {
     return catalogue.image.filter((m) => m.provider === provider && m.enabled && !m.deprecated && isVideoModel(m));

package/dist/catalog/store.js

@@ -1,9 +1,14 @@
 import { existsSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { parse } from "yaml";
+import { parse, stringify } from "yaml";
 import { isLocalCliProvider } from "../slices/settings/model.js";
+import { applyOpenRouterListing, catalogueFamilies, combineChanges, mergeCatalogue, modelKey, noChanges, } from "./merge.js";
 import { catalogueSchema, isVideoModel } from "./schema.js";
 export const catalogueSource = "https://raw.githubusercontent.com/GentBajko/slopify/main/packages/app/src/assets/models.yaml";
+// OpenRouter's public model list: live ids and per-token prices, no key needed.
+export const openRouterModelsSource = "https://openrouter.ai/api/v1/models";
+// How often the automatic check runs; it also runs once at every start.
+export const catalogueCheckIntervalMs = 24 * 60 * 60 * 1000;
 export function parseCatalogue(text) {
     if (Buffer.byteLength(text) > 1024 * 1024)
         throw new Error("Model catalogue exceeds 1 MB");
@@ -26,6 +31,9 @@ export function createCatalogueStore(deps) {
     let stamp = "";
     let warning = null;
     let refreshing;
+    let syncing;
+    const syncPath = join(deps.dataDir, "models-sync.json");
+    const now = deps.now ?? (() => new Date());
     function read() {
         try {
             const file = statSync(path);
@@ -40,12 +48,12 @@ export function createCatalogueStore(deps) {
         }
         catch {
             warning =
-                "Your models.yaml file is missing or has a mistake, so Slopify is still using the last working model list. Fix the file, or use Refresh published catalogue in Settings → Models to replace it.";
+                "Your models.yaml file is missing or has a mistake, so Slopify is still using the last working model list. Fix the file, or use Replace with published file in Settings → Models.";
         }
         return current;
     }
-    async function refresh() {
-        const response = await deps.fetch(catalogueSource, {
+    async function download(url, maxBytes) {
+        const response = await deps.fetch(url, {
             signal: AbortSignal.timeout(15000),
             redirect: "error",
         });
@@ -62,8 +70,8 @@ export function createCatalogueStore(deps) {
                 if (next.done)
                     break;
                 size += next.value.byteLength;
-                if (size > 1024 * 1024)
-                    throw new Error("Catalogue exceeds 1 MB");
+                if (size > maxBytes)
+                    throw new Error("Download is too large");
                 chunks.push(next.value);
             }
         }
@@ -71,7 +79,10 @@ export function createCatalogueStore(deps) {
             await reader.cancel().catch(() => { });
             reader.releaseLock();
         }
-        const text = Buffer.concat(chunks).toString("utf8");
+        return Buffer.concat(chunks).toString("utf8");
+    }
+    async function refresh() {
+        const text = await download(catalogueSource, 1024 * 1024);
         const next = parseCatalogue(text);
         mkdirSync(deps.dataDir, { recursive: true, mode: 0o700 });
         // A manual refresh replaces the local catalogue; retain the previous text for recovery.
@@ -84,10 +95,91 @@ export function createCatalogueStore(deps) {
         warning = null;
         read();
     }
+    function readSync() {
+        try {
+            const parsed = JSON.parse(readFileSync(syncPath, "utf8"));
+            if (isSyncFile(parsed))
+                return parsed;
+        }
+        catch {
+            // Absent or damaged: the first check starts from the bundled list below.
+        }
+        return { checkedAt: null, known: null, changes: noChanges, warning: null };
+    }
+    function writeSync(value) {
+        writeFileSync(`${syncPath}.next`, JSON.stringify(value), { mode: 0o600 });
+        renameSync(`${syncPath}.next`, syncPath);
+    }
+    async function openRouterListing() {
+        try {
+            return parseOpenRouterListing(JSON.parse(await download(openRouterModelsSource, 16 * 1024 * 1024)));
+        }
+        catch {
+            // Optional: the published catalogue still carries OpenRouter's curated prices.
+            return [];
+        }
+    }
+    async function sync() {
+        const saved = readSync();
+        const local = read();
+        if (warning !== null) {
+            // Never overwrite a file the user is in the middle of fixing.
+            writeSync({ ...saved, warning });
+            return { checkedAt: saved.checkedAt, changes: saved.changes, warning };
+        }
+        let published;
+        try {
+            published = parseCatalogue(await download(catalogueSource, 1024 * 1024));
+        }
+        catch {
+            const failed = "Slopify could not download the latest model list, so it is still using the one it has. Check your internet connection, then choose Check now in Settings → Models.";
+            writeSync({ ...saved, warning: failed });
+            return { checkedAt: saved.checkedAt, changes: saved.changes, warning: failed };
+        }
+        // Before the first check the models shipped with this version count as published, so a
+        // model the user added to the file is never mistaken for a retired one.
+        const known = new Set(saved.known ?? keysOf(parseCatalogue(bundled)));
+        const merged = mergeCatalogue(local, published, known);
+        const live = applyOpenRouterListing(merged.catalogue, await openRouterListing());
+        const changes = combineChanges(merged.changes, live.changes);
+        const text = `${syncedHeader}${stringify(live.catalogue, { aliasDuplicateObjects: false })}`;
+        const next = parseCatalogue(text);
+        if (JSON.stringify(next) !== JSON.stringify(local)) {
+            if (existsSync(path))
+                writeFileSync(`${path}.previous`, readFileSync(path), { mode: 0o600 });
+            writeFileSync(`${path}.next`, text, { mode: 0o600 });
+            renameSync(`${path}.next`, path);
+            current = next;
+            stamp = "";
+            read();
+        }
+        const status = { checkedAt: now().toISOString(), changes, warning: null };
+        writeSync({ ...status, known: [...merged.known].sort() });
+        return status;
+    }
     return {
+        sync: () => {
+            syncing ??= sync().finally(() => {
+                syncing = undefined;
+            });
+            return syncing;
+        },
+        syncDue: (at) => {
+            const last = readSync().checkedAt;
+            return last === null || at - Date.parse(last) >= catalogueCheckIntervalMs;
+        },
         read,
         models: (provider, family) => read()[family].filter((m) => m.provider === provider && m.enabled && !m.deprecated && !isVideoModel(m)),
-        status: () => ({ updatedAt: read().updatedAt, path, warning, source: catalogueSource }),
+        status: () => {
+            const saved = readSync();
+            return {
+                updatedAt: read().updatedAt,
+                path,
+                warning,
+                source: catalogueSource,
+                sync: { checkedAt: saved.checkedAt, changes: saved.changes, warning: saved.warning },
+            };
+        },
         refresh: () => {
             refreshing ??= refresh().finally(() => {
                 refreshing = undefined;
@@ -96,3 +188,50 @@ export function createCatalogueStore(deps) {
         },
     };
 }
+const syncedHeader = "# Slopify's model list, kept up to date automatically from the published catalogue.\n" +
+    "# Your edits are kept; retired models stay listed with deprecated: true.\n";
+function isSyncFile(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const row = value;
+    const changes = row.changes;
+    return ((row.checkedAt === null || typeof row.checkedAt === "string") &&
+        (row.known === null || Array.isArray(row.known)) &&
+        (row.warning === null || typeof row.warning === "string") &&
+        typeof changes === "object" &&
+        changes !== null &&
+        Array.isArray(changes.added) &&
+        Array.isArray(changes.retired) &&
+        Array.isArray(changes.priced));
+}
+function keysOf(catalogue) {
+    return catalogueFamilies.flatMap((family) => catalogue[family].map((row) => modelKey(family, row.provider, row.id)));
+}
+// `{ data: [{ id, pricing: { prompt, completion } }] }`, prices in USD per token as strings.
+// Rows that do not read cleanly are skipped; a negative price means "varies" and is ignored.
+export function parseOpenRouterListing(value) {
+    if (typeof value !== "object" || value === null)
+        return [];
+    const data = value.data;
+    if (!Array.isArray(data))
+        return [];
+    const price = (raw) => {
+        const number = typeof raw === "string" || typeof raw === "number" ? Number(raw) : Number.NaN;
+        return Number.isFinite(number) && number >= 0 ? number : undefined;
+    };
+    const rows = [];
+    for (const row of data) {
+        if (typeof row !== "object" || row === null)
+            continue;
+        const { id, pricing } = row;
+        if (typeof id !== "string" || id === "")
+            continue;
+        const prices = typeof pricing === "object" && pricing !== null ? pricing : {};
+        rows.push({
+            id,
+            promptPerToken: price(prices.prompt),
+            completionPerToken: price(prices.completion),
+        });
+    }
+    return rows;
+}

package/dist/catalog/validate.js

@@ -1,7 +1,7 @@
-import { usesNarrationPreparation, usesShorts, usesYoutubeDescription, } from "../slices/admission/rules.js";
+import { usesNarrationPreparation, usesReference, usesShorts, usesYoutubeDescription, } from "../slices/admission/rules.js";
 import { isLocalCliProvider } from "../slices/settings/model.js";
 import { usesAnimation } from "../slices/video/edit-settings.js";
-import { videoModelsOf } from "./schema.js";
+import { referenceRefusal, takesReferenceImage, videoModelsOf } from "./schema.js";
 export function modelFields(draft, catalogue) {
     if (!catalogue)
         return [];
@@ -45,6 +45,11 @@ export function modelFields(draft, catalogue) {
                 field,
                 message: "This model does not support that thinking setting. Choose another.",
             });
+        else if ("image" in model && choice.thinking)
+            fields.push({
+                field: "images.thinking",
+                message: "This image model has no effort setting. Set Effort back to Model default.",
+            });
         else if ("llm" in model && draft.sources.research === "generate" && !model.llm.webSearch)
             fields.push({
                 field,
@@ -65,6 +70,16 @@ export function modelFields(draft, catalogue) {
                 message: "This image model cannot make the vertical (9:16) images Shorts need. Choose another image model, or turn Shorts off.",
             });
     }
+    // The establishing image needs a model that takes an input image; the catalogue says which.
+    // The Codex CLI always can, so only the keyed providers are looked up.
+    if (usesReference(draft) &&
+        draft.images !== undefined &&
+        !isLocalCliProvider(draft.images.provider)) {
+        const images = draft.images;
+        const model = catalogue.models(images.provider, "image").find((m) => m.id === images.model);
+        if (model !== undefined && !takesReferenceImage(model))
+            fields.push({ field: "reference.source", message: referenceRefusal });
+    }
     // Animate images runs on the image provider's image-to-video models.
     if (usesAnimation(draft) && draft.images !== undefined) {
         const model = draft.videoEdit?.animateModel ?? "";

package/dist/compose.yaml

@@ -0,0 +1,71 @@
+# Slopify on Docker: one service, one private data volume, one host folder for project files.
+#
+# `npx @gentbajko/slopify --docker` copies this file to ~/.local/share/slopify/docker/<name>/
+# and writes the .env beside it, then runs `docker compose up`. You can also run it by hand; see
+# docs/docker.md for the variables. The data volume is external on purpose: `docker compose down`
+# (even with -v) never deletes it.
+name: ${SLOPIFY_NAME:-slopify}
+
+services:
+  slopify:
+    image: ${SLOPIFY_IMAGE:-ghcr.io/gentbajko/slopify:latest}
+    container_name: ${SLOPIFY_NAME:-slopify}
+    # Your own user id, so project files on the host belong to you (0:0 under rootless Docker).
+    user: ${SLOPIFY_USER:-1000:1000}
+    restart: unless-stopped
+    # Localhost only: anyone who reaches this port controls the app and its provider keys.
+    # An empty SLOPIFY_PORT picks a free port.
+    ports:
+      - 127.0.0.1:${SLOPIFY_PORT-6969}:6969
+    volumes:
+      - type: volume
+        source: data
+        target: /data
+      - type: bind
+        source: ${SLOPIFY_PROJECTS_DIR:?set SLOPIFY_PROJECTS_DIR to the folder for your project files}
+        target: /data/projects
+      # Scheduled backups' default folder, beside Projects (new installs from 3.0). Without
+      # SLOPIFY_BACKUPS_DIR it is an empty folder nobody reads and backups stay in
+      # Projects/Backups.
+      - type: bind
+        source: ${SLOPIFY_BACKUPS_DIR:-./backups-off}
+        target: /data/backups
+        bind:
+          create_host_path: true
+      # The host CLI bridge: a folder holding the helper's socket and token, nothing else.
+      # With the bridge off it is an empty folder and Settings shows the CLIs as unavailable.
+      - type: bind
+        source: ${SLOPIFY_HOST_CLI_SHARE:-./host-cli-off}
+        target: /opt/slopify-host
+        read_only: true
+        bind:
+          create_host_path: true
+      # The update handshake: activation.json says when the installer has committed this version.
+      - type: bind
+        source: ${SLOPIFY_ACTIVATION_DIR:-./activation}
+        target: /opt/slopify-install
+        read_only: true
+        bind:
+          create_host_path: true
+    environment:
+      SLOPIFY_DOCKER_PROJECTS_DIR: ${SLOPIFY_PROJECTS_DIR}
+      SLOPIFY_DOCKER_BACKUPS_DIR: ${SLOPIFY_BACKUPS_DIR:-}
+      SLOPIFY_HOST_CLI_DIR: /opt/slopify-host
+      SLOPIFY_DOCKER_INSTALL_STATE: /opt/slopify-install/activation.json
+      SLOPIFY_UPDATE_TOKEN: ${SLOPIFY_UPDATE_TOKEN:-}
+      SLOPIFY_UPDATE_PENDING: ${SLOPIFY_UPDATE_PENDING:-0}
+    healthcheck:
+      test:
+        - CMD
+        - node
+        - -e
+        - "fetch('http://127.0.0.1:6969/api/health').then(r => process.exit(r.ok ? 0 : 1)).catch(() => process.exit(1))"
+      interval: 30s
+      timeout: 5s
+      start_period: 120s
+      start_interval: 2s
+
+volumes:
+  data:
+    external: true
+    name: ${SLOPIFY_VOLUME:-slopify-data}

package/dist/edge/autostart/docker-record.js

@@ -0,0 +1,32 @@
+import { join } from "node:path";
+import { installSchema, readState, writeState } from "../docker-install/state.js";
+import { checkDockerStart, loginStartFile, loginStartReport, loginStartSchema, } from "./docker.js";
+import { autostartQuestion } from "./prompt.js";
+/**
+ * The --docker installer's part: ask "Start Slopify when you log in?" once (or take
+ * --autostart / --no-autostart), look whether Docker starts by itself, and leave the answer in
+ * the installation's activation folder, which the container reads at
+ * /opt/slopify-install/login-start.json. Docker's own settings are only read, never changed.
+ */
+export async function recordLoginStart(o) {
+    const install = await readState(join(o.directory, "install.json"), installSchema, o.uid);
+    // Rootless Docker runs the container as 0:0 (see compose.yaml's SLOPIFY_USER).
+    const manager = install?.user === "0:0" ? "rootless" : "system";
+    const path = join(o.directory, "activation", loginStartFile);
+    const previous = await readState(path, loginStartSchema, o.uid).catch(() => null);
+    let wanted = o.flag ?? previous?.wanted ?? null;
+    if (wanted === null && o.interactive)
+        wanted = (await o.ask(autostartQuestion)) ?? null;
+    const record = {
+        version: 1,
+        checkedAt: o.now().toISOString(),
+        docker: await checkDockerStart(o.exec, manager),
+        manager,
+        wanted,
+    };
+    await writeState(path, record);
+    o.report(wanted === false
+        ? `Slopify in Docker still starts whenever Docker does, because its container restarts with Docker. When you don't want it running: docker stop ${o.name}`
+        : loginStartReport(record));
+    return record;
+}

package/dist/edge/autostart/docker.js

@@ -0,0 +1,50 @@
+import { z } from "zod";
+// Slopify in Docker restarts with Docker (`restart: unless-stopped` in compose.yaml), so it
+// starts at login exactly when Docker does. Slopify never changes Docker's own setting; the
+// installer looks once, on this machine, and leaves the answer where the container can read
+// it (the read-only /opt/slopify-install folder), because a container can't see its host.
+export const loginStartFile = "login-start.json";
+export const containerLoginStart = `/opt/slopify-install/${loginStartFile}`;
+export const loginStartSchema = z
+    .object({
+    version: z.literal(1),
+    checkedAt: z.string().max(40),
+    // yes: Docker starts by itself; no: it doesn't; unknown: this machine couldn't say.
+    docker: z.enum(["yes", "no", "unknown"]),
+    // Which Docker the installation uses: the system one, or rootless Docker in your account.
+    manager: z.enum(["system", "rootless"]),
+    // The installer's "Start Slopify when you log in?" answer, or null when it wasn't asked.
+    wanted: z.boolean().nullable(),
+})
+    .strict();
+export function dockerHowTo(manager) {
+    return manager === "rootless"
+        ? "Turn on Docker's start at login in a terminal: systemctl --user enable docker (rootless Docker). Slopify then starts with it."
+        : "Turn on Docker's start with the computer in a terminal: sudo systemctl enable docker. Slopify then starts with it.";
+}
+export const desktopHowTo = "With Docker Desktop: Docker Desktop → Settings → General → Start Docker Desktop when you sign in. With Docker Engine on Linux: sudo systemctl enable docker. Slopify starts whenever Docker does.";
+/**
+ * Reads, never changes, whether Docker starts by itself. `systemctl is-enabled` only reports;
+ * it answers "enabled" or "disabled" (exit code 1), and fails without systemd.
+ */
+export async function checkDockerStart(exec, manager) {
+    const result = await exec("systemctl", manager === "rootless"
+        ? ["--user", "is-enabled", "docker.service"]
+        : ["is-enabled", "docker.service"]);
+    const answer = result.stdout.trim().split("\n")[0]?.trim() ?? "";
+    if (["enabled", "enabled-runtime", "alias"].includes(answer))
+        return "yes";
+    if (["disabled", "masked", "masked-runtime"].includes(answer))
+        return "no";
+    return "unknown";
+}
+// The terminal line the installer prints after its question.
+export function loginStartReport(record) {
+    if (record.docker === "yes")
+        return record.manager === "rootless"
+            ? "Slopify starts when you log in: rootless Docker starts with your login and restarts Slopify."
+            : "Slopify starts with this computer: Docker starts at boot and restarts Slopify.";
+    if (record.docker === "no")
+        return `Docker doesn't start by itself on this computer, so neither does Slopify. ${dockerHowTo(record.manager)}`;
+    return `Slopify couldn't tell whether Docker starts by itself here (systemctl didn't answer). ${dockerHowTo(record.manager)}`;
+}

package/dist/edge/autostart/index.js

@@ -0,0 +1,78 @@
+import { access, realpath } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import { readState } from "../docker-install/state.js";
+import { isWsl } from "../open-browser.js";
+import { containerLoginStart, loginStartSchema } from "./docker.js";
+import { createNativeAutostart, nodeAutostartExec, nodeAutostartFs } from "./native.js";
+import { createAutostartService } from "./service.js";
+/** The switch for this process: the container's report in Docker, the login entry otherwise. */
+export async function createAutostart(context) {
+    if (context.env.SLOPIFY_CONTAINER === "1")
+        return createAutostartService(context.db, {
+            kind: "docker",
+            record: () => context.env.SLOPIFY_DOCKER_INSTALL_STATE === undefined
+                ? Promise.resolve(null)
+                : readLoginStart(containerLoginStart),
+        });
+    return createAutostartService(context.db, {
+        kind: "native",
+        native: createNativeAutostart({
+            platform: process.platform,
+            home: homedir(),
+            env: context.env,
+            wsl: isWsl(process.platform, context.env),
+            fs: nodeAutostartFs,
+            exec: nodeAutostartExec,
+            node: process.execPath,
+            entry: await stableEntry(),
+            npxCli: await npxCli(),
+            version: context.version,
+            dataDir: context.dataDir,
+            port: context.port,
+            host: context.host,
+            log: join(context.logs, "autostart.log"),
+        }),
+    });
+}
+export async function readLoginStart(path) {
+    try {
+        return await readState(path, loginStartSchema, process.getuid?.() ?? -1);
+    }
+    catch {
+        // Damaged, or not the installer's: the same as not knowing.
+        return null;
+    }
+}
+// This package's cli.js, unless it lives in the npx cache, which npx may clean at any time.
+async function stableEntry() {
+    const entry = fileURLToPath(new URL("../cli.js", import.meta.url));
+    try {
+        await access(entry);
+        const real = await realpath(entry);
+        return real.includes(`${sep}_npx${sep}`) ? null : real;
+    }
+    catch {
+        // Running from source (tsx): there is no built entry to start.
+        return null;
+    }
+}
+// npm's npx script beside this Node (the Windows and the Unix installation layouts).
+async function npxCli() {
+    const nodeDir = dirname(process.execPath);
+    for (const candidate of [
+        join(nodeDir, "node_modules", "npm", "bin", "npx-cli.js"),
+        join(nodeDir, "..", "lib", "node_modules", "npm", "bin", "npx-cli.js"),
+    ]) {
+        try {
+            await access(candidate);
+            // Not resolved: Homebrew's links stay put while the folders they point to change.
+            return candidate;
+        }
+        catch {
+            // Try the next layout.
+        }
+    }
+    return null;
+}