@gentbajko/slopify 2.5.0 → 3.0.0

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.`;
+}

package/dist/edge/cli.js

@@ -1,17 +1,14 @@
 #!/usr/bin/env node
-import { spawnSync } from "node:child_process";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { createInterface } from "node:readline/promises";
-import { fileURLToPath } from "node:url";
 import { parseArgs } from "node:util";
 import { configFrom } from "../kernel/config/index.js";
 import { readVersion } from "../kernel/version.js";
 import { boot } from "../main.js";
 import { forwardManagedUpdate } from "../updater/forward.js";
+import { askTerminal, autostartFlag, settleAutostart } from "./autostart/prompt.js";
 import { openBrowser } from "./open-browser.js";
 import { installSignalShutdown } from "./signal-shutdown.js";
-const { values } = parseArgs({
+const { values, positionals } = parseArgs({
+    allowPositionals: true,
     options: {
         port: { type: "string" },
         host: { type: "string" },
@@ -21,72 +18,72 @@ const { values } = parseArgs({
         docker: { type: "boolean" },
         "host-cli": { type: "string" },
         "accept-host-cli": { type: "boolean" },
+        autostart: { type: "boolean" },
+        "no-autostart": { type: "boolean" },
     },
 });
 let config;
 try {
-    if (values["projects-dir"] !== undefined && !values.docker)
+    const autostart = autostartFlag(values);
+    const [action, ...extra] = positionals;
+    if (extra.length > 0 || (action !== undefined && action !== "install" && action !== "update"))
+        throw new Error(`Unknown command "${positionals.join(" ")}". Use npx @gentbajko/slopify to start Slopify, npx @gentbajko/slopify --docker to install it in Docker, or npx @gentbajko/slopify@latest update to update it.`);
+    if (action === "install" && !values.docker)
+        throw new Error("Without Docker there is nothing to install: npx @gentbajko/slopify starts Slopify directly. To install it in Docker, run npx @gentbajko/slopify install --docker.");
+    // `update` goes to the Docker installation when this user has one.
+    const docker = values.docker === true ||
+        (action === "update" &&
+            (await (await import("./docker-install/run.js")).hasDockerInstall(process.env)));
+    if (values["projects-dir"] !== undefined && !docker)
         throw new Error("--projects-dir only works together with --docker. Without Docker, choose where Slopify keeps its files with --data-dir <folder>.");
-    if ((values["host-cli"] !== undefined || values["accept-host-cli"] !== undefined) &&
-        !values.docker)
+    if ((values["host-cli"] !== undefined || values["accept-host-cli"] !== undefined) && !docker)
         throw new Error("--host-cli and --accept-host-cli only work together with --docker. Add --docker, or remove those options.");
     if (values["host-cli"] !== undefined && values["host-cli"] !== "off")
-        throw new Error(`--host-cli=${values["host-cli"]} is not supported. The only value is --host-cli=off, which starts Docker using API keys only; leave the option out to use the AI CLIs installed on this machine.`);
-    if (values.docker) {
+        throw new Error(`--host-cli=${values["host-cli"]} is not supported. The only value is --host-cli=off, which installs Docker using API keys only; leave the option out to use the AI CLIs installed on this machine.`);
+    if (docker) {
         if (values.host !== undefined || values["data-dir"] !== undefined)
             throw new Error("--host and --data-dir can't be used with --docker: the Docker version always listens on localhost and keeps its data in a Docker volume. Use --projects-dir <folder> for project files and --port <number> for the port.");
-        const docker = await import("./docker.js");
-        docker.assertManagedDockerHost(process.platform, process.getuid?.(), process.getgid?.());
-        const { prepareDockerHostCli } = docker;
-        const { nodeHostSetupRunner } = await import("../host-cli/install.js");
-        const bridge = await prepareDockerHostCli({
-            root: join(process.env.XDG_DATA_HOME ?? join(homedir(), ".local/share"), "slopify/host-cli"),
-            version: readVersion(),
-            image: process.env.SLOPIFY_DOCKER_IMAGE ?? "ghcr.io/gentbajko/slopify:latest",
-            disabled: values["host-cli"] === "off",
-            accepted: values["accept-host-cli"] === true,
-            interactive: process.stdin.isTTY === true,
-            env: process.env,
-            signal: AbortSignal.timeout(20 * 60_000),
-            runner: nodeHostSetupRunner,
-            prompt: async (message) => {
-                const terminal = createInterface({ input: process.stdin, output: process.stdout });
-                try {
-                    return /^(?:y|yes)$/i.test((await terminal.question(message)).trim());
-                }
-                finally {
-                    terminal.close();
-                }
-            },
+        const { runDockerCommand } = await import("./docker-install/run.js");
+        await runDockerCommand({
+            mode: action === "update" ? "update" : "install",
+            ...(values.port === undefined ? {} : { port: values.port }),
+            ...(values["projects-dir"] === undefined ? {} : { projectsDir: values["projects-dir"] }),
+            ...(values["host-cli"] === undefined ? {} : { hostCli: values["host-cli"] }),
+            ...(values["accept-host-cli"] === undefined
+                ? {}
+                : { acceptHostCli: values["accept-host-cli"] }),
+            ...(autostart === undefined ? {} : { autostart }),
         });
-        console.log(bridge.directory
-            ? "Host CLI helper ready. Existing CLI logins stay on the host."
-            : "Starting API-only Docker. Rerun the launcher after installing host CLIs to enable them.");
-        const result = spawnSync("bash", [fileURLToPath(new URL("../../scripts/docker-run.sh", import.meta.url))], {
-            stdio: "inherit",
-            env: {
-                ...process.env,
-                SLOPIFY_HOST_CLI_DIR: bridge.directory ?? "",
-                ...(values.port === undefined ? {} : { SLOPIFY_DOCKER_HOST_PORT: values.port }),
-                ...(values["projects-dir"] === undefined
-                    ? {}
-                    : { SLOPIFY_DOCKER_PROJECTS_DIR: values["projects-dir"] }),
-            },
+        process.exit(0);
+    }
+    if (action === "update") {
+        config = configFrom(values, process.env);
+        const { runNativeUpdate } = await import("./native-update.js");
+        await runNativeUpdate({
+            origin: `http://${config.host === "0.0.0.0" ? "127.0.0.1" : config.host}:${config.port}`,
+            fetch: globalThis.fetch,
+            report: (line) => console.log(line),
         });
-        if (result.error)
-            throw new Error(`Could not start the Docker launcher script (${result.error.message}). Make sure bash is installed and on your PATH, then try again.`);
-        process.exit(result.status ?? 1);
+        process.exit(0);
     }
     config = configFrom(values, process.env);
     const forwarded = await forwardManagedUpdate(config.dataDir, readVersion(), process.argv.slice(2));
     if (forwarded !== undefined)
         process.exit(forwarded);
-    const { paths, url, stop } = await boot(config, {
+    const booted = await boot(config, {
+        refreshAutostart: true,
         prefetchSubtitleModel: ["", "0", "false"].includes((process.env.SLOPIFY_NO_MODEL_PREFETCH ?? "").trim().toLowerCase()),
         subtitleModelSeed: process.env.SLOPIFY_SUBTITLE_MODEL_SEED?.trim() || undefined,
+        seedSample: true,
+        // A data dir chosen with --data-dir or SLOPIFY_DATA_DIR keeps a new install's files inside
+        // it, so a second or throwaway install never shares a Documents folder with the main one.
+        filesInDocuments: values["data-dir"] === undefined && (process.env.SLOPIFY_DATA_DIR ?? "") === "",
+        refreshModels: ["", "0", "false"].includes((process.env.SLOPIFY_NO_MODEL_REFRESH ?? "").trim().toLowerCase()),
     });
+    const { paths, url, stop } = booted;
     console.log(`Slopify is running at ${url}`);
     console.log(`Slopify data directory: ${paths.dataDir}`);
+    console.log(`Projects: ${paths.projects}`);
     console.log(`Database: ${paths.db}`);
     console.log(`Logs: ${paths.logs}`);
     if (config.host !== "127.0.0.1") {
@@ -102,6 +99,15 @@ try {
         stop,
         exit: (code) => process.exit(code),
     });
+    // After the server is up, so the question never holds Slopify back.
+    await settleAutostart({
+        autostart: booted.autostart,
+        flag: autostart,
+        interactive: process.stdin.isTTY === true && process.stdout.isTTY === true,
+        ask: askTerminal,
+        report: (line) => console.log(line),
+        warn: (line) => console.warn(line),
+    });
 }
 catch (error) {
     console.error(explainStartupError(error, config));

package/dist/edge/docker-install/activation.js

@@ -0,0 +1,56 @@
+import { timingSafeEqual } from "node:crypto";
+import { lstat, readFile } from "node:fs/promises";
+import { isAbsolute, join, resolve } from "node:path";
+import { z } from "zod";
+import { backupsFolderName } from "../../slices/storage/layout.js";
+import { readState } from "./state.js";
+const activationSchema = z
+    .object({
+    version: z.literal(1),
+    token: z.string().regex(/^[a-f0-9]{64}$/),
+    committed: z.boolean(),
+})
+    .strict();
+export async function dockerActivationCommitted(path, token) {
+    if (!/^[a-f0-9]{64}$/.test(token))
+        return false;
+    const marker = await readState(path, activationSchema, process.getuid?.() ?? -1);
+    return (marker?.committed === true && timingSafeEqual(Buffer.from(marker.token), Buffer.from(token)));
+}
+// Where a container keeps the user-visible files. The installer decides them on the host (the
+// Projects bind, and from 3.0 a Backups bind beside it), so they are never stored in settings.
+export function dockerFilesLayout(env, dataDir) {
+    const projects = join(dataDir, "projects");
+    return {
+        projects,
+        backups: env.SLOPIFY_DOCKER_BACKUPS_DIR
+            ? join(dataDir, "backups")
+            : join(projects, backupsFolderName),
+        exports: null,
+    };
+}
+export async function dockerFolderConfiguration(env, projectsRoot) {
+    if (env.SLOPIFY_CONTAINER !== "1")
+        return { container: false, hostProjects: null, hostBackups: null };
+    const host = env.SLOPIFY_DOCKER_PROJECTS_DIR;
+    if (!host || env.SLOPIFY_DOCKER_INSTALL_STATE !== "/opt/slopify-install/activation.json")
+        return { container: true, hostProjects: null, hostBackups: null };
+    const backups = env.SLOPIFY_DOCKER_BACKUPS_DIR || null;
+    for (const path of [host, backups])
+        if (path !== null && (!isAbsolute(path) || resolve(path) !== path || /[\p{Cc},]/u.test(path)))
+            throw new Error("Invalid Docker host project path.");
+    const root = await lstat(projectsRoot);
+    const mounts = (await readFile("/proc/self/mountinfo", "utf8"))
+        .split("\n")
+        .map((line) => line.split(" ")[4]);
+    if (projectsRoot !== "/data/projects" ||
+        !root.isDirectory() ||
+        root.isSymbolicLink() ||
+        !mounts.includes("/data/projects"))
+        throw new Error("Managed Docker project bind is missing.");
+    return {
+        container: true,
+        hostProjects: host,
+        hostBackups: backups !== null && mounts.includes("/data/backups") ? backups : null,
+    };
+}