@gentbajko/slopify 2.5.0 → 3.0.1

package/dist/catalog/validate.js

@@ -1,5 +1,5 @@
 import { usesNarrationPreparation, usesReference, usesShorts, usesYoutubeDescription, } from "../slices/admission/rules.js";
-import { isLocalCliProvider } from "../slices/settings/model.js";
+import { isLocalCliProvider, isUncataloguedProvider } from "../slices/settings/model.js";
 import { usesAnimation } from "../slices/video/edit-settings.js";
 import { referenceRefusal, takesReferenceImage, videoModelsOf } from "./schema.js";
 export function modelFields(draft, catalogue) {
@@ -32,7 +32,7 @@ export function modelFields(draft, catalogue) {
         },
     ];
     for (const { field, family, choice, needed } of checks) {
-        if (!needed || !choice || isLocalCliProvider(choice.provider))
+        if (!needed || !choice || isUncataloguedProvider(choice.provider))
             continue;
         const model = catalogue.models(choice.provider, family).find((m) => m.id === choice.model);
         if (!model)

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 { inspectDockerStart, 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(),
+        manager,
+        wanted,
+        ...(await inspectDockerStart({ exec: o.exec, manager, host: o.host })),
+    };
+    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,118 @@
+import { posix, win32 } from "node:path";
+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(),
+    // The system the installer ran on, and whether its Docker is Docker Desktop, which has its
+    // own sign-in setting instead of a systemd service. Absent in records from before 3.0.1.
+    platform: z.enum(["linux", "darwin", "win32", "other"]).optional(),
+    desktop: z.boolean().optional(),
+})
+    .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 dockerDesktopHowTo = "Turn on Docker Desktop → Settings → General → Start Docker Desktop when you sign in to your computer. Slopify then starts with it.";
+// Where to turn Docker's start at login on, for the Docker this installation uses. A record
+// from before the installer noted the system can't tell Docker Desktop from Docker Engine
+// when systemctl didn't answer (macOS and Windows have none), so it names both.
+export function howToFor(record) {
+    if (record.desktop === true)
+        return dockerDesktopHowTo;
+    if (record.platform === undefined && record.docker === "unknown")
+        return desktopHowTo;
+    return dockerHowTo(record.manager);
+}
+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";
+}
+// Docker Desktop's settings files, newest name first: settings-store.json in current
+// versions, settings.json before it.
+export function desktopSettingsPaths(host) {
+    const names = ["settings-store.json", "settings.json"];
+    if (host.platform === "win32") {
+        const appData = host.env.APPDATA?.trim() || win32.join(host.home, "AppData", "Roaming");
+        return names.map((name) => win32.join(appData, "Docker", name));
+    }
+    if (host.platform === "darwin")
+        return names.map((name) => posix.join(host.home, "Library", "Group Containers", "group.com.docker", name));
+    return names.map((name) => posix.join(host.home, ".docker", "desktop", name));
+}
+// `AutoStart` in settings-store.json, `autoStart` in the older settings.json: Start Docker
+// Desktop when you sign in to your computer.
+export function desktopAutoStart(text) {
+    try {
+        const value = JSON.parse(text);
+        if (typeof value !== "object" || value === null)
+            return "unknown";
+        const record = value;
+        const start = record.AutoStart ?? record.autoStart;
+        return start === true ? "yes" : start === false ? "no" : "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+}
+/**
+ * Reads, never changes, whether Docker starts by itself on this machine. macOS and Windows run
+ * Docker Desktop, whose settings file says; on Linux, Docker Desktop's settings file when it
+ * is there, otherwise the system or rootless docker service through systemctl.
+ */
+export async function inspectDockerStart(o) {
+    const platform = o.host.platform === "linux" || o.host.platform === "darwin" || o.host.platform === "win32"
+        ? o.host.platform
+        : "other";
+    for (const path of desktopSettingsPaths(o.host)) {
+        const text = await o.host.read(path);
+        if (text !== undefined)
+            return { docker: desktopAutoStart(text), desktop: true, platform };
+    }
+    if (platform === "darwin" || platform === "win32")
+        return { docker: "unknown", desktop: true, platform };
+    return { docker: await checkDockerStart(o.exec, o.manager), desktop: false, platform };
+}
+// The terminal line the installer prints after its question.
+export function loginStartReport(record) {
+    if (record.desktop === true) {
+        if (record.docker === "yes")
+            return "Slopify starts when you sign in: Docker Desktop starts at sign-in and restarts Slopify.";
+        if (record.docker === "no")
+            return `Docker Desktop doesn't start when you sign in, so neither does Slopify. ${dockerDesktopHowTo}`;
+        return `Slopify couldn't tell whether Docker Desktop starts when you sign in (its settings file didn't say). ${dockerDesktopHowTo}`;
+    }
+    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;
+}

package/dist/edge/autostart/launcher.js

@@ -0,0 +1,176 @@
+// The files "Start Slopify when I log in" writes, as pure text. Nothing here touches the disk,
+// so every platform's output is tested on any machine (`launcher.test.ts`).
+//
+// The login entry never names the npx cache: npx may clean it or move it on its next run. It
+// runs a small launcher kept in the data folder instead, which starts, in order:
+//   1. the installed Slopify entry, when Slopify runs from a real install (npm i -g, a local
+//      checkout), not from the npx cache;
+//   2. npx's own script next to this Node, asking for the version that was running when the
+//      switch was turned on (`@gentbajko/slopify@<version>`), so a login works offline once
+//      that version is in the cache and never jumps to a new release by itself;
+//   3. plain `npx` from PATH, the same way.
+// In-app updates still apply: the started version forwards to the newest one installed in the
+// data folder (`updater/forward.ts`). Each start with the switch on writes the launcher again,
+// so it follows the Node, the entry and the version actually in use.
+export const packageName = "@gentbajko/slopify";
+export const launcherMarker = "Written by Slopify: Settings";
+export const desktopMarker = "X-Slopify-Autostart=true";
+export const agentLabel = "stream.slopify.app";
+export const runKey = "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run";
+export const runValue = "Slopify";
+// The flags a login start runs with: quiet (no browser tab), and the data folder, port and
+// host of the Slopify that turned the switch on, since no terminal is there to pass them.
+export function launchArgs(spec) {
+    return [
+        "--no-open",
+        "--data-dir",
+        spec.dataDir,
+        "--port",
+        String(spec.port),
+        ...(spec.host === "127.0.0.1" ? [] : ["--host", spec.host]),
+    ];
+}
+// POSIX sh single quotes: nothing inside is special except the quote itself.
+export function shQuote(value) {
+    return `'${value.replaceAll("'", `'\\''`)}'`;
+}
+export function shellLauncher(spec) {
+    const args = launchArgs(spec).map(shQuote).join(" ");
+    const pkg = shQuote(`${packageName}@${spec.version}`);
+    const lines = [
+        "#!/bin/sh",
+        "# Starts Slopify quietly when you log in: no browser tab, open it from your bookmark.",
+        `# ${launcherMarker} → General → "Start Slopify when I log in".`,
+        "# Turning that switch off deletes this file and the login entry that runs it.",
+        `exec >>${shQuote(spec.log)} 2>&1`,
+        `echo "$(date) Starting Slopify at login"`,
+        `NODE=${shQuote(spec.node)}`,
+        '[ -x "$NODE" ] || NODE=$(command -v node) || {',
+        `  echo "Slopify could not start at login: Node.js was not found. Install Node.js from https://nodejs.org, then start Slopify once with npx ${packageName}."`,
+        "  exit 1",
+        "}",
+        'PATH=$(dirname "$NODE"):$PATH',
+        "export PATH",
+    ];
+    if (spec.entry !== null)
+        lines.push(`if [ -f ${shQuote(spec.entry)} ]; then exec "$NODE" ${shQuote(spec.entry)} ${args}; fi`);
+    if (spec.npxCli !== null)
+        lines.push(`if [ -f ${shQuote(spec.npxCli)} ]; then exec "$NODE" ${shQuote(spec.npxCli)} --yes ${pkg} ${args}; fi`);
+    lines.push(`exec npx --yes ${pkg} ${args}`, "");
+    return lines.join("\n");
+}
+// cmd.exe: inside double quotes only `%` still expands, so it is doubled. A path can't hold a
+// double quote on Windows, and `windowsPathProblem` refuses the rest before anything is written.
+function cmdQuote(value) {
+    return `"${value.replaceAll("%", "%%")}"`;
+}
+export function cmdLauncher(spec) {
+    const args = launchArgs(spec)
+        .map((arg) => (/^[\w.:-]+$/u.test(arg) ? arg : cmdQuote(arg)))
+        .join(" ");
+    const pkg = `${packageName}@${spec.version}`;
+    const log = `>>${cmdQuote(spec.log)} 2>&1`;
+    const nodeDir = spec.node.slice(0, Math.max(spec.node.lastIndexOf("\\"), 0));
+    const lines = [
+        "@echo off",
+        "rem Starts Slopify quietly when you log in: no browser tab, open it from your bookmark.",
+        `rem ${launcherMarker} > General > "Start Slopify when I log in".`,
+        "rem Turning that switch off deletes this file and the login entry that runs it.",
+        "rem Closing this window stops Slopify.",
+        "chcp 65001 >nul",
+        "title Slopify",
+        `set "NODE=${spec.node.replaceAll("%", "%%")}"`,
+        `set "PATH=${nodeDir.replaceAll("%", "%%")};%PATH%"`,
+        'if not exist "%NODE%" set "NODE=node"',
+    ];
+    if (spec.entry !== null)
+        lines.push(`if not exist ${cmdQuote(spec.entry)} goto npxcli`, `"%NODE%" ${cmdQuote(spec.entry)} ${args} ${log}`, "exit /b");
+    lines.push(":npxcli");
+    if (spec.npxCli !== null)
+        lines.push(`if not exist ${cmdQuote(spec.npxCli)} goto npx`, `"%NODE%" ${cmdQuote(spec.npxCli)} --yes ${pkg} ${args} ${log}`, "exit /b");
+    lines.push(":npx", `call npx --yes ${pkg} ${args} ${log}`, "");
+    return lines.join("\r\n");
+}
+// The registry's Run value: a minimised console running the launcher, so a login shows a
+// taskbar button named Slopify rather than a window in the way. REG_SZ doesn't expand
+// variables, and `start` takes the first quoted argument as the window title.
+export function windowsRunCommand(launcher) {
+    return `cmd.exe /d /c start "Slopify" /min "${launcher}"`;
+}
+// Characters cmd.exe would read as its own inside the Run value (`%` expands even in quotes
+// there, where a batch file's `%%` doesn't apply). Windows paths can't contain `"`.
+export function windowsPathProblem(path) {
+    return /[%"\r\n]/u.test(path)
+        ? `The Slopify data folder ${path} contains a % sign, which Windows' start-up list can't run. Start Slopify with another folder (npx ${packageName} --data-dir C:\\Slopify) and turn the switch on there.`
+        : undefined;
+}
+// Desktop Entry spec: an argument with spaces or reserved characters is double-quoted, with
+// `"`, `` ` ``, `$` and `\` backslash-escaped inside; the value as a whole then escapes `\`
+// again, and `%` is a field code unless doubled.
+export function desktopExecArg(value) {
+    if (/^[A-Za-z0-9_./+,:@=-]+$/u.test(value))
+        return value;
+    const quoted = `"${value.replace(/["`$\\]/gu, (char) => `\\${char}`)}"`;
+    return quoted.replaceAll("\\", "\\\\").replaceAll("%", "%%");
+}
+// Freedesktop keys escape newlines, tabs and backslashes in plain string values.
+function desktopString(value) {
+    return value
+        .replaceAll("\\", "\\\\")
+        .replaceAll("\n", "\\n")
+        .replaceAll("\t", "\\t")
+        .replaceAll("\r", "\\r");
+}
+export function desktopEntry(launcher) {
+    return [
+        "[Desktop Entry]",
+        "Type=Application",
+        "Name=Slopify",
+        desktopString(`Comment=Starts Slopify quietly when you log in. Turn it off in Slopify: Settings → General.`),
+        `Exec=/bin/sh ${desktopExecArg(launcher)}`,
+        "Terminal=false",
+        "NoDisplay=true",
+        "Hidden=false",
+        "X-GNOME-Autostart-enabled=true",
+        desktopMarker,
+        "",
+    ].join("\n");
+}
+export function xmlText(value) {
+    return value
+        .replaceAll("&", "&amp;")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;");
+}
+// A per-user LaunchAgent: launchd loads every agent in ~/Library/LaunchAgents at login and
+// RunAtLoad starts it once. No KeepAlive, so quitting Slopify keeps it quit until next login.
+export function launchAgent(launcher, log) {
+    return [
+        '<?xml version="1.0" encoding="UTF-8"?>',
+        '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">',
+        `<!-- ${launcherMarker} → General → "Start Slopify when I log in". -->`,
+        '<plist version="1.0">',
+        "<dict>",
+        "  <key>Label</key>",
+        `  <string>${agentLabel}</string>`,
+        "  <key>ProgramArguments</key>",
+        "  <array>",
+        "    <string>/bin/sh</string>",
+        `    <string>${xmlText(launcher)}</string>`,
+        "  </array>",
+        "  <key>RunAtLoad</key>",
+        "  <true/>",
+        "  <key>KeepAlive</key>",
+        "  <false/>",
+        "  <key>ProcessType</key>",
+        "  <string>Interactive</string>",
+        "  <key>StandardOutPath</key>",
+        `  <string>${xmlText(log)}</string>`,
+        "  <key>StandardErrorPath</key>",
+        `  <string>${xmlText(log)}</string>`,
+        "</dict>",
+        "</plist>",
+        "",
+    ].join("\n");
+}

package/dist/edge/autostart/model.js

@@ -0,0 +1,3 @@
+// The settings row that remembers the question was answered (on the first-run screen, in
+// Settings or in the terminal), so it is never offered again.
+export const autostartAnsweredKey = "autostart.answered";