@gentbajko/slopify 2.4.0 → 3.0.0

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

package/dist/edge/autostart/native.js

@@ -0,0 +1,210 @@
+import { execFile } from "node:child_process";
+import { mkdir, readFile, rename, rmdir, unlink, writeFile } from "node:fs/promises";
+import { posix, win32 } from "node:path";
+import { agentLabel, cmdLauncher, desktopEntry, desktopExecArg, desktopMarker, launchAgent, launcherMarker, runKey, runValue, shellLauncher, windowsPathProblem, windowsRunCommand, xmlText, } from "./launcher.js";
+const launcherDir = "autostart";
+// How each entry spells the launcher's path.
+function launcherRef(platform, launcher) {
+    return platform === "linux"
+        ? desktopExecArg(launcher)
+        : platform === "darwin"
+            ? xmlText(launcher)
+            : launcher;
+}
+// Where each platform keeps the per-user login entry. None of them needs administrator
+// rights, and none is a systemd unit: a desktop login starts them.
+function locations(o, platform) {
+    const path = platform === "win32" ? win32 : posix;
+    const dir = path.join(o.dataDir, launcherDir);
+    const launcher = path.join(dir, platform === "win32" ? "start-slopify.cmd" : "start-slopify.sh");
+    const configHome = o.env.XDG_CONFIG_HOME && posix.isAbsolute(o.env.XDG_CONFIG_HOME)
+        ? o.env.XDG_CONFIG_HOME
+        : posix.join(o.home, ".config");
+    const entry = platform === "linux"
+        ? posix.join(configHome, "autostart", "slopify.desktop")
+        : platform === "darwin"
+            ? posix.join(o.home, "Library", "LaunchAgents", `${agentLabel}.plist`)
+            : null;
+    return {
+        dir,
+        launcher,
+        entry,
+        where: entry ?? `${runKey} → ${runValue}`,
+    };
+}
+function supported(o) {
+    if (o.wsl)
+        return "Slopify runs inside WSL here, and Windows doesn't start Linux programs when you log in. Start Slopify from a Windows terminal instead (npx @gentbajko/slopify), then turn this switch on there.";
+    if (o.platform === "linux" || o.platform === "darwin" || o.platform === "win32")
+        return o.platform;
+    return `Starting at login isn't supported on ${o.platform}. Start Slopify yourself with npx @gentbajko/slopify.`;
+}
+export function createNativeAutostart(o) {
+    const platform = supported(o);
+    if (platform !== "linux" && platform !== "darwin" && platform !== "win32") {
+        const off = { available: false, enabled: false, where: null, summary: platform };
+        return {
+            status: async () => off,
+            enable: () => Promise.reject(new Error(platform)),
+            disable: async () => off,
+            refresh: async () => { },
+        };
+    }
+    const at = locations(o, platform);
+    const spec = { ...o, platform };
+    const launcherText = platform === "win32" ? cmdLauncher(spec) : shellLauncher(spec);
+    const entryText = platform === "linux"
+        ? desktopEntry(at.launcher)
+        : platform === "darwin"
+            ? launchAgent(at.launcher, o.log)
+            : windowsRunCommand(at.launcher);
+    // The entry as it is now: absent, Slopify's (with its current text), or someone else's.
+    async function entryNow() {
+        if (platform === "win32") {
+            const result = await o.exec("reg", ["query", runKey, "/v", runValue]);
+            if (result.code !== 0)
+                return { state: "none" };
+            const data = /REG_(?:EXPAND_)?SZ\s+(.*)$/mu.exec(result.stdout)?.[1]?.trim();
+            if (data === undefined)
+                return { state: "foreign" };
+            return data.includes("start-slopify.cmd")
+                ? { state: "ours", text: data }
+                : { state: "foreign", text: data };
+        }
+        const text = await o.fs.read(at.entry);
+        if (text === undefined)
+            return { state: "none" };
+        const ours = text.includes(platform === "linux" ? desktopMarker : launcherMarker);
+        return { state: ours ? "ours" : "foreign", text };
+    }
+    function state(enabled) {
+        return {
+            available: true,
+            enabled,
+            where: at.where,
+            summary: enabled
+                ? "Slopify starts quietly when you log in to this computer, without opening a browser tab."
+                : "Slopify starts only when you start it.",
+        };
+    }
+    async function writeLauncher() {
+        if ((await o.fs.read(at.launcher)) !== launcherText)
+            await o.fs.write(at.launcher, launcherText, 0o700);
+    }
+    async function writeEntry(current) {
+        if (current === entryText)
+            return;
+        if (platform === "win32") {
+            const result = await o.exec("reg", [
+                "add",
+                runKey,
+                "/v",
+                runValue,
+                "/t",
+                "REG_SZ",
+                "/d",
+                entryText,
+                "/f",
+            ]);
+            if (result.code !== 0)
+                throw new Error(`Windows refused to add Slopify to the programs that start when you log in (reg add ${runKey}: ${result.stderr.trim() || `exit code ${result.code}`}). Nothing needs administrator rights here, so try the switch again; if it keeps failing, check that a security program isn't blocking changes to your start-up list.`);
+            return;
+        }
+        await o.fs.write(at.entry, entryText, 0o644);
+    }
+    return {
+        status: async () => state((await entryNow()).state === "ours"),
+        enable: async () => {
+            if (platform === "win32") {
+                const problem = windowsPathProblem(o.dataDir);
+                if (problem !== undefined)
+                    throw new Error(problem);
+            }
+            const now = await entryNow();
+            if (now.state === "foreign")
+                throw new Error(platform === "win32"
+                    ? `Your start-up list already has an entry named ${runValue} that Slopify didn't make (${runKey}). Slopify left it alone. Remove it in Task Manager → Startup apps, or rename it, then turn the switch on again.`
+                    : `${at.entry} already exists and wasn't made by Slopify, so Slopify left it alone. Delete or rename that file, then turn the switch on again.`);
+            await writeLauncher();
+            await writeEntry(now.text);
+            return state(true);
+        },
+        disable: async () => {
+            const now = await entryNow();
+            if (now.state === "ours") {
+                if (platform === "win32") {
+                    const result = await o.exec("reg", ["delete", runKey, "/v", runValue, "/f"]);
+                    if (result.code !== 0)
+                        throw new Error(`Windows refused to remove Slopify from the programs that start when you log in (reg delete ${runKey}: ${result.stderr.trim() || `exit code ${result.code}`}). Turn it off in Task Manager → Startup apps → Slopify instead.`);
+                }
+                else
+                    await o.fs.remove(at.entry);
+            }
+            // The launcher is only ever Slopify's own; a hand-edited one without the marker stays.
+            const launcher = await o.fs.read(at.launcher);
+            if (launcher?.includes(launcherMarker))
+                await o.fs.remove(at.launcher);
+            await o.fs.removeEmptyDir(at.dir);
+            return state(false);
+        },
+        refresh: async () => {
+            const now = await entryNow();
+            // Only the entry that runs this data folder's launcher: a Slopify started with another
+            // --data-dir must not take over the one the switch was turned on from.
+            if (now.state !== "ours" || !now.text?.includes(launcherRef(platform, at.launcher)))
+                return;
+            await writeLauncher();
+            await writeEntry(now.text);
+        },
+    };
+}
+export const nodeAutostartFs = {
+    read: async (path) => {
+        try {
+            return await readFile(path, "utf8");
+        }
+        catch (error) {
+            if (isMissing(error))
+                return undefined;
+            throw error;
+        }
+    },
+    write: async (path, text, mode) => {
+        const directory = path.slice(0, Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\")));
+        await mkdir(directory, { recursive: true, mode: 0o700 });
+        const temporary = `${path}.${process.pid}.tmp`;
+        await writeFile(temporary, text, { mode });
+        await rename(temporary, path);
+    },
+    remove: async (path) => {
+        try {
+            await unlink(path);
+        }
+        catch (error) {
+            if (!isMissing(error))
+                throw error;
+        }
+    },
+    removeEmptyDir: async (path) => {
+        try {
+            await rmdir(path);
+        }
+        catch {
+            // Missing, or holds something else: either way it stays as it is.
+        }
+    },
+};
+export const nodeAutostartExec = (file, args) => new Promise((resolve) => {
+    execFile(file, [...args], { windowsHide: true, timeout: 15_000, encoding: "utf8" }, (error, stdout, stderr) => {
+        const code = error === null
+            ? 0
+            : typeof error.code === "number"
+                ? error.code
+                : // A missing command (ENOENT) or a timeout: no exit code of its own.
+                    127;
+        resolve({ code, stdout, stderr: stderr || (error?.message ?? "") });
+    });
+});
+function isMissing(error) {
+    return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}

package/dist/edge/autostart/prompt.js

@@ -0,0 +1,66 @@
+import { createInterface } from "node:readline/promises";
+export const autostartQuestion = "Start Slopify when you log in? (Y/n) ";
+// The two flags as one answer: undefined when neither was given.
+export function autostartFlag(values) {
+    if (values.autostart === true && values["no-autostart"] === true)
+        throw new Error("--autostart and --no-autostart say opposite things. Keep the one you mean and try again.");
+    return values.autostart === true ? true : values["no-autostart"] === true ? false : undefined;
+}
+// Y, yes or just Enter is yes; n or no is no; anything else is no answer.
+export function readAnswer(text) {
+    const answer = text.trim().toLowerCase();
+    if (answer === "" || answer === "y" || answer === "yes")
+        return true;
+    if (answer === "n" || answer === "no")
+        return false;
+    return undefined;
+}
+// One question on the terminal. Ctrl+C still stops Slopify: the question gives up and the
+// signal goes on to the handler that shuts the server down.
+export async function askTerminal(question) {
+    const terminal = createInterface({ input: process.stdin, output: process.stdout });
+    const interrupted = new Promise((resolve) => {
+        terminal.once("SIGINT", () => {
+            terminal.close();
+            resolve(undefined);
+            process.kill(process.pid, "SIGINT");
+        });
+    });
+    try {
+        return await Promise.race([terminal.question(question).then(readAnswer), interrupted]);
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        terminal.close();
+    }
+}
+/**
+ * `npx @gentbajko/slopify`: --autostart / --no-autostart set the switch; without them an
+ * interactive terminal is asked once, unless the first-run screen or Settings already asked.
+ * Never fails the start: a refusal is printed with what to do.
+ */
+export async function settleAutostart(options) {
+    try {
+        let wanted = options.flag;
+        if (wanted === undefined) {
+            if (!options.interactive || !(await options.autostart.unanswered()))
+                return;
+            wanted = await options.ask(autostartQuestion);
+            if (wanted === undefined)
+                return;
+        }
+        const view = await options.autostart.set(wanted);
+        if (!view.available) {
+            options.report(view.summary);
+            return;
+        }
+        options.report(view.enabled === true
+            ? `${view.summary} Login entry: ${view.where}. Turn it off in Settings → General.`
+            : `${view.summary} Turn it on any time in Settings → General.`);
+    }
+    catch (error) {
+        options.warn(error instanceof Error ? error.message : String(error));
+    }
+}

package/dist/edge/autostart/service.js

@@ -0,0 +1,81 @@
+import { readSetting, writeSetting } from "../../slices/settings/repo.js";
+import { desktopHowTo, dockerHowTo } from "./docker.js";
+import { autostartAnsweredKey } from "./model.js";
+export class AutostartRefusal extends Error {
+}
+export function createAutostartService(db, source) {
+    const answered = () => readSetting(db, autostartAnsweredKey) === "1";
+    const markAnswered = () => writeSetting(db, autostartAnsweredKey, "1");
+    async function view() {
+        if (source.kind === "docker") {
+            const record = await source.record();
+            return {
+                kind: "docker",
+                available: false,
+                enabled: record === null || record.docker === "unknown" ? null : record.docker === "yes",
+                summary: record === null
+                    ? "Slopify runs in Docker and starts whenever Docker starts. From inside the container it can't see whether Docker starts when you log in."
+                    : record.docker === "yes"
+                        ? record.manager === "rootless"
+                            ? "Slopify runs in Docker and starts when you log in: rootless Docker starts with your login and restarts Slopify."
+                            : "Slopify runs in Docker and starts with this computer: Docker starts at boot and restarts Slopify."
+                        : record.docker === "no"
+                            ? "Slopify runs in Docker, and Docker doesn't start by itself on this computer, so Slopify doesn't either."
+                            : "Slopify runs in Docker and starts whenever Docker starts. The installer couldn't tell whether Docker starts by itself here.",
+                where: null,
+                howTo: record === null
+                    ? desktopHowTo
+                    : `${dockerHowTo(record.manager)} To check again after changing it, run npx @gentbajko/slopify --docker.`,
+                checkedAt: record?.checkedAt ?? null,
+                offer: false,
+            };
+        }
+        const state = await source.native.status();
+        return {
+            kind: "native",
+            available: state.available,
+            enabled: state.enabled,
+            summary: state.summary,
+            where: state.where,
+            howTo: null,
+            checkedAt: null,
+            offer: state.available && !state.enabled && !answered(),
+        };
+    }
+    return {
+        view,
+        set: async (enabled) => {
+            if (source.kind === "docker") {
+                const current = await view();
+                throw new AutostartRefusal(`Slopify in Docker starts whenever Docker starts, so this switch can't change it. ${current.howTo ?? desktopHowTo}`);
+            }
+            try {
+                await (enabled ? source.native.enable() : source.native.disable());
+            }
+            catch (error) {
+                throw new AutostartRefusal(plain(error, enabled));
+            }
+            markAnswered();
+            return view();
+        },
+        answer: async () => {
+            markAnswered();
+            return view();
+        },
+        unanswered: async () => (await view()).offer,
+        refresh: () => (source.kind === "native" ? source.native.refresh() : Promise.resolve()),
+    };
+}
+// The native steps already speak in sentences; a file error from the disk doesn't.
+function plain(error, enabled) {
+    const message = error instanceof Error ? error.message : String(error);
+    const code = error instanceof Error && "code" in error && typeof error.code === "string"
+        ? error.code
+        : undefined;
+    if (code === undefined)
+        return message;
+    const path = error instanceof Error && "path" in error && typeof error.path === "string"
+        ? ` ${error.path}`
+        : "";
+    return `Slopify couldn't ${enabled ? "add" : "remove"} its login entry: writing${path} failed (${message}). Make sure your user owns that folder and can write to it, then press Start Slopify when I log in in Settings → General again.`;
+}