@gentbajko/slopify 2.5.0 → 3.0.0

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/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;
+}

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";