@gentbajko/slopify 2.5.0 → 3.0.0

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

@@ -0,0 +1,362 @@
+import { join } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { z } from "zod";
+const uuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+/** The id a recovery volume of `volume` carries in its name, or null for any other volume. */
+export function recoveryId(volume, name) {
+    const prefix = `${volume}-recovery-`;
+    if (!name.startsWith(prefix))
+        return null;
+    const id = name.slice(prefix.length);
+    return uuid.test(id) ? id : null;
+}
+// Docker's exit code alone says nothing, so its last error line decides the advice: the daemon
+// being stopped and the socket being off-limits are by far the most common first-run failures.
+export function dockerFailure(args, result) {
+    const detail = (result.stderr ?? "").trim();
+    if (/permission denied[^\n]*docker\.sock|docker\.sock[^\n]*permission denied/i.test(detail))
+        return "Your user isn't allowed to use Docker. Give it access with sudo usermod -aG docker $USER, then log out and back in (or run newgrp docker) and try again.";
+    if (/cannot connect to the docker daemon|is the docker daemon running|error during connect/i.test(detail))
+        return "Docker is installed but not running. Start it (sudo systemctl start docker, or systemctl --user start docker for rootless Docker) and try again.";
+    if (/port is already allocated|address already in use/i.test(detail))
+        return "The port Slopify wants is already in use by another program. Stop that program, or install on another port: npx @gentbajko/slopify --docker --port 7070";
+    if (/no space left on device/i.test(detail))
+        return "The disk Docker uses is full. Free up space (for example docker system prune) and try again.";
+    if (args[0] === "compose" && /is not a docker command|unknown command/i.test(detail))
+        return "Docker Compose isn't installed. Install the Docker Compose plugin (for example sudo apt install docker-compose-plugin, or sudo pacman -S docker-compose), check that docker compose version works, and try again.";
+    const last = detail.split("\n").at(-1)?.trim().slice(0, 300);
+    return `Docker command "docker ${args[0] ?? ""}" failed (exit code ${result.code}${last ? `: ${last}` : ""}). Check that Docker works (docker info) and run the command again.`;
+}
+const helperEntry = "/opt/slopify/packages/app/dist/edge/docker-install/volume.js";
+const inspectSchema = z.array(z.object({
+    Id: z.string(),
+    Name: z.string(),
+    Config: z.object({
+        Image: z.string(),
+        User: z.string(),
+        Labels: z.record(z.string(), z.string()).nullable(),
+    }),
+    State: z.object({ Running: z.boolean() }),
+    HostConfig: z.object({
+        RestartPolicy: z.object({ Name: z.string(), MaximumRetryCount: z.number() }),
+    }),
+    Mounts: z.array(z.object({
+        Type: z.string(),
+        Name: z.string().optional(),
+        Source: z.string(),
+        Destination: z.string(),
+    })),
+    NetworkSettings: z.object({
+        Ports: z
+            .record(z.string(), z.array(z.object({ HostIp: z.string(), HostPort: z.string() })).nullable())
+            .nullable(),
+    }),
+}));
+export function dockerEngine(runner, signal, env) {
+    const run = (args, localSignal = signal) => runner.exec("docker", args, localSignal);
+    async function command(args, localSignal = signal) {
+        const r = await run(args, localSignal);
+        if (r.code !== 0)
+            throw new Error(dockerFailure(args, r));
+        return r.stdout.trim();
+    }
+    const mount = (type, source, target, readonly = false) => [
+        "--mount",
+        `type=${type},source=${source},target=${target}${readonly ? ",readonly" : ""}`,
+    ];
+    // Fixed file operations inside the image being installed, as root, without network.
+    const helper = async (image, args, operation, user = "0:0") => JSON.parse(await command([
+        "run",
+        "--rm",
+        "--network",
+        "none",
+        "--read-only",
+        "--user",
+        "0:0",
+        ...(args.some((a) => a.includes("target=/data")) ? [] : ["--tmpfs", "/data"]),
+        ...args,
+        "--entrypoint",
+        "node",
+        image,
+        helperEntry,
+        operation,
+        user,
+    ]));
+    async function inspect(name) {
+        const result = await run(["container", "inspect", name]);
+        if (result.code !== 0) {
+            if (/no such (container|object)/i.test(result.stderr ?? ""))
+                return null;
+            throw new Error(dockerFailure(["container", "inspect"], result));
+        }
+        const raw = inspectSchema.parse(JSON.parse(result.stdout))[0];
+        if (!raw)
+            return null;
+        const binding = raw.NetworkSettings.Ports?.["6969/tcp"]?.[0];
+        const restart = raw.HostConfig.RestartPolicy;
+        return {
+            id: raw.Id,
+            name: raw.Name.replace(/^\//, ""),
+            image: raw.Config.Image,
+            user: raw.Config.User,
+            running: raw.State.Running,
+            restart: restart.Name === "on-failure" && restart.MaximumRetryCount > 0
+                ? `on-failure:${restart.MaximumRetryCount}`
+                : restart.Name || "no",
+            project: raw.Config.Labels?.["com.docker.compose.project"] ?? null,
+            launcher: raw.Config.Labels?.["io.slopify.launcher"] !== undefined,
+            mounts: raw.Mounts.map((m) => ({
+                type: m.Type,
+                name: m.Name ?? "",
+                source: m.Source,
+                destination: m.Destination,
+            })),
+            port: binding ? Number(binding.HostPort) : null,
+        };
+    }
+    return {
+        context: async (uid, gid) => {
+            let endpoint = env.DOCKER_HOST;
+            if (env.DOCKER_CONTEXT || !endpoint) {
+                const raw = JSON.parse(await command([
+                    "context",
+                    "inspect",
+                    ...(env.DOCKER_CONTEXT ? [env.DOCKER_CONTEXT] : []),
+                ]));
+                endpoint = z
+                    .array(z.object({ Endpoints: z.object({ docker: z.object({ Host: z.string() }) }) }))
+                    .parse(raw)[0]?.Endpoints.docker.Host;
+            }
+            if (!endpoint?.startsWith("unix://"))
+                throw new Error(`The --docker install only works with Docker running on this machine, not a remote Docker (${endpoint ?? "unknown endpoint"}). Switch to the local one (unset DOCKER_HOST, or docker context use default) and try again.`);
+            const rawInfo = JSON.parse(await command(["info", "--format", "{{json .}}"]));
+            // Some Docker versions print the daemon's absence inside the JSON instead of failing.
+            const serverErrors = z.object({ ServerErrors: z.array(z.string()) }).safeParse(rawInfo)
+                .data?.ServerErrors;
+            if (serverErrors !== undefined && serverErrors.length > 0)
+                throw new Error(dockerFailure(["info"], { code: 1, stderr: serverErrors.join("\n") }));
+            const info = z
+                .object({
+                ID: z.string(),
+                OSType: z.literal("linux"),
+                OperatingSystem: z.string(),
+                SecurityOptions: z.array(z.string()),
+            })
+                .parse(rawInfo);
+            if (/docker desktop/i.test(info.OperatingSystem))
+                throw new Error("Docker Desktop isn't supported by the --docker install because it can't give your project folder the right owner. Use Docker Engine on Linux (docker context use default), or run Slopify without Docker: npx @gentbajko/slopify");
+            const rootless = info.SecurityOptions.includes("name=rootless");
+            if (!rootless && info.SecurityOptions.some((s) => s.startsWith("name=userns")))
+                throw new Error("Your Docker uses userns-remap, which the --docker install doesn't support. Use rootless Docker or a standard Docker Engine setup, or run Slopify without Docker: npx @gentbajko/slopify. Don't turn off Docker's isolation to get around this.");
+            await command(["compose", "version", "--short"]);
+            return { daemon: info.ID, user: rootless ? "0:0" : `${uid}:${gid}` };
+        },
+        image: async (ref) => {
+            const found = await run(["image", "inspect", "--format", "{{.Id}}", ref]);
+            if (found.code !== 0 || ref.endsWith(":latest")) {
+                const pulled = await run(["pull", ref]);
+                if (pulled.code !== 0)
+                    throw new Error(`Could not download the Slopify Docker image ${ref}. Check your internet connection and that Docker is running (docker info), then try again. Nothing was changed. ${dockerFailure(["pull"], pulled)}`);
+            }
+        },
+        imageVersion: async (ref) => z
+            .string()
+            .regex(/^\d+\.\d+\.\d+$/)
+            .parse(await command([
+            "run",
+            "--rm",
+            "--network",
+            "none",
+            "--read-only",
+            "--tmpfs",
+            "/data",
+            "--entrypoint",
+            "node",
+            ref,
+            "-p",
+            "require('/opt/slopify/packages/app/package.json').version",
+        ])),
+        inspect,
+        legacyPrevious: async (name) => {
+            const ids = (await command([
+                "container",
+                "ls",
+                "-a",
+                "--filter",
+                `name=^/${name}-previous-`,
+                "--format",
+                "{{.ID}}",
+            ]))
+                .split(/\s+/)
+                .filter(Boolean);
+            const found = [];
+            for (const id of ids) {
+                const c = await inspect(id);
+                if (c && recoveryLikeName(name, c.name))
+                    found.push(c);
+            }
+            return found;
+        },
+        volumeExists: async (name) => (await command(["volume", "ls", "--format", "{{.Name}}"])).split(/\s+/).includes(name),
+        createVolume: async (name) => {
+            await command(["volume", "create", name]);
+        },
+        volumeProjects: async (image, volume) => {
+            const value = z
+                .discriminatedUnion("exists", [
+                z.object({ exists: z.literal(false) }),
+                z.object({
+                    exists: z.literal(true),
+                    digest: z.object({ hash: z.string(), files: z.number(), bytes: z.number() }),
+                }),
+            ])
+                .parse(await helper(image, mount("volume", volume, "/source", true), "projects"));
+            return value.exists ? value.digest : null;
+        },
+        copyVolumeProjects: async (image, volume, destination, id) => {
+            const reader = await command([
+                "create",
+                "--name",
+                `slopify-reader-${id}`,
+                "--network",
+                "none",
+                "--read-only",
+                "--tmpfs",
+                "/data",
+                ...mount("volume", volume, "/source", true),
+                "--entrypoint",
+                "true",
+                image,
+            ]);
+            try {
+                await command(["cp", `${reader}:/source/projects/.`, destination]);
+            }
+            finally {
+                await command(["rm", reader], AbortSignal.timeout(10_000));
+            }
+        },
+        snapshot: async (image, volume, backup, labels) => {
+            await command([
+                "volume",
+                "create",
+                ...Object.entries(labels).flatMap(([key, value]) => ["--label", `${key}=${value}`]),
+                backup,
+            ]);
+            return helper(image, [...mount("volume", volume, "/source", true), ...mount("volume", backup, "/backup")], "snapshot");
+        },
+        restore: async (image, backup, volume, expected) => {
+            const found = await helper(image, mount("volume", backup, "/source", true), "private");
+            if (found.hash !== expected.hash)
+                throw new Error(`The recovery volume ${backup} changed after it was made, so Slopify did not copy it back.`);
+            const restored = await helper(image, [...mount("volume", backup, "/source", true), ...mount("volume", volume, "/data")], "restore");
+            if (restored.hash !== expected.hash)
+                throw new Error(`The data copied back from ${backup} differs from the recovery volume.`);
+        },
+        own: async (image, volume, user) => {
+            await helper(image, mount("volume", volume, "/data"), "own", user);
+        },
+        recoveryVolumes: async (volume) => {
+            const names = (await command([
+                "volume",
+                "ls",
+                "--filter",
+                "label=io.slopify.transaction",
+                "--format",
+                "{{.Name}}",
+            ]))
+                .split(/\s+/)
+                .filter((name) => recoveryId(volume, name) !== null);
+            const found = [];
+            for (const name of names) {
+                const labels = z
+                    .record(z.string(), z.string())
+                    .nullable()
+                    .parse(JSON.parse(await command(["volume", "inspect", "--format", "{{json .Labels}}", name])));
+                found.push({
+                    name,
+                    transaction: labels?.["io.slopify.transaction"] ?? null,
+                    container: labels?.["io.slopify.container"] ?? null,
+                });
+            }
+            return found;
+        },
+        // Never forced: Docker refuses a volume a container still mounts, and that refusal stands.
+        removeVolume: async (name) => {
+            await command(["volume", "rm", name]);
+        },
+        removeContainer: async (id) => {
+            await command(["rm", "-f", id]);
+        },
+        stop: async (id) => {
+            await command(["stop", id]);
+        },
+        start: async (id) => {
+            await command(["start", id]);
+        },
+        rename: async (id, name) => {
+            await command(["rename", id, name]);
+        },
+        restartPolicy: async (id, policy) => {
+            await command(["update", `--restart=${policy}`, id]);
+        },
+        compose: async (directory, name, args) => {
+            await command([
+                "compose",
+                "--project-directory",
+                directory,
+                "--file",
+                join(directory, "compose.yaml"),
+                "--env-file",
+                join(directory, ".env"),
+                "--project-name",
+                name,
+                ...args,
+            ]);
+        },
+        ready: async (id, check) => {
+            const deadline = Date.now() + 120_000;
+            while (Date.now() < deadline) {
+                signal.throwIfAborted();
+                const probe = AbortSignal.any([
+                    signal,
+                    AbortSignal.timeout(Math.max(1, Math.min(3000, deadline - Date.now()))),
+                ]);
+                try {
+                    const result = await run([
+                        "exec",
+                        id,
+                        "node",
+                        "-e",
+                        "const [token,expected]=process.argv.slice(1); const get=(p,h)=>fetch('http://127.0.0.1:6969'+p,{headers:h}).then(async r=>{const b=await r.json(); if(!r.ok||b.status!=='ok'||(expected&&b.version!==expected)) process.exit(1)}); Promise.all([get('/api/health',{}), ...(token?[get('/api/update/ready',{'X-Slopify-Update-Token':token})]:[])]).catch(()=>process.exit(1))",
+                        check?.token ?? "",
+                        check?.version ?? "",
+                    ], probe);
+                    if (result.code === 0)
+                        return;
+                }
+                catch (error) {
+                    if (signal.aborted || !probe.aborted)
+                        throw error;
+                }
+                await delay(500, undefined, { signal });
+            }
+            throw new Error(`The Slopify container did not answer within 2 minutes. See why with: docker logs ${id}`);
+        },
+        busy: async (id) => {
+            const result = await run([
+                "exec",
+                id,
+                "node",
+                "-e",
+                "fetch('http://127.0.0.1:6969/api/update').then(r=>r.json()).then(b=>process.stdout.write(String(b.busy===true))).catch(()=>process.exit(1))",
+            ], AbortSignal.any([signal, AbortSignal.timeout(10_000)])).catch(() => undefined);
+            if (result === undefined || result.code !== 0)
+                return null;
+            return result.stdout.trim() === "true";
+        },
+    };
+}
+function recoveryLikeName(name, candidate) {
+    const prefix = `${name}-previous-`;
+    return candidate.startsWith(prefix) && uuid.test(candidate.slice(prefix.length));
+}

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

@@ -0,0 +1,154 @@
+import { access } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { fileURLToPath } from "node:url";
+import { nodeHostSetupRunner } from "../../host-cli/install.js";
+import { readVersion } from "../../kernel/version.js";
+import { documentsDir, nodeDocumentsHost } from "../../slices/storage/documents.js";
+import { recordLoginStart } from "../autostart/docker-record.js";
+import { nodeAutostartExec } from "../autostart/native.js";
+import { askTerminal } from "../autostart/prompt.js";
+import { assertManagedDockerHost, planDockerHostCli } from "../docker.js";
+import { applyDocker } from "./apply.js";
+import { dockerEngine } from "./engine.js";
+import { absolute, dockerRoot, identifier } from "./state.js";
+/** `slopify --docker`, `slopify install --docker` and `slopify update --docker`. */
+export async function runDockerCommand(command) {
+    const env = process.env;
+    const uid = process.getuid?.();
+    const gid = process.getgid?.();
+    assertManagedDockerHost(process.platform, uid, gid);
+    const home = homedir();
+    const version = readVersion();
+    const portText = command.port ?? env.SLOPIFY_DOCKER_HOST_PORT;
+    if (portText !== undefined &&
+        portText !== "" &&
+        (!/^\d{1,5}$/.test(portText) || Number(portText) > 65535))
+        throw new Error(`Invalid port ${JSON.stringify(portText)}: use a whole number between 1 and 65535, for example --port 7070.`);
+    const projectsText = command.projectsDir ?? env.SLOPIFY_DOCKER_PROJECTS_DIR;
+    const name = identifier.safeParse(env.SLOPIFY_DOCKER_NAME || "slopify");
+    const volume = identifier.safeParse(env.SLOPIFY_DOCKER_VOLUME || "slopify-data");
+    if (!name.success || !volume.success)
+        throw new Error("SLOPIFY_DOCKER_NAME and SLOPIFY_DOCKER_VOLUME may only use letters, digits, dots, dashes and underscores, and must start with a letter or digit. Fix them and try again.");
+    // New installs keep their files in this computer's Documents folder; `--projects-dir
+    // documents` moves an existing one there.
+    const documents = await documentsDir(nodeDocumentsHost());
+    const projects = !projectsText
+        ? null
+        : projectsText === "documents"
+            ? documentsProjects(documents, name.success ? name.data : "slopify")
+            : resolve(projectsText.startsWith("~/") ? join(home, projectsText.slice(2)) : projectsText);
+    if (projects !== null && !absolute.safeParse(projects).success)
+        throw new Error(`The project folder ${JSON.stringify(projectsText)} can't be used: give a full path without commas, for example --projects-dir ~/Slopify/Projects.`);
+    const controller = new AbortController();
+    const abort = () => controller.abort(new Error("Stopped before it finished. Run the same command again; Slopify puts the previous version back first if anything was half done."));
+    process.once("SIGINT", abort);
+    process.once("SIGTERM", abort);
+    try {
+        const hostCli = await planDockerHostCli({
+            root: join(env.XDG_DATA_HOME || join(home, ".local/share"), "slopify/host-cli"),
+            version,
+            disabled: command.hostCli === "off",
+            accepted: command.acceptHostCli === true,
+            interactive: process.stdin.isTTY === true,
+            env,
+            signal: AbortSignal.any([controller.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 result = await applyDocker({
+            home,
+            uid,
+            gid: gid,
+            root: dockerRoot(env, home),
+            name: name.data,
+            volume: volume.data,
+            image: env.SLOPIFY_DOCKER_IMAGE || `ghcr.io/gentbajko/slopify:${version}`,
+            version,
+            port: portText === undefined ? null : portText === "" ? 0 : Number(portText),
+            projects,
+            documents,
+            mode: command.mode,
+            composeFile: await composeFile(),
+            hostCli,
+            report: (line) => console.log(line),
+        }, dockerEngine(nodeHostSetupRunner, controller.signal, env));
+        console.log(result.changed
+            ? `Slopify ${version} is running at ${result.url}`
+            : `Slopify ${version} is already installed and running at ${result.url}`);
+        console.log(`Project files on this machine: ${result.projects}`);
+        if (result.backups !== null)
+            console.log(`Backups on this machine: ${result.backups}`);
+        console.log(hostCli.enabled
+            ? "Host CLI bridge ready: Claude Code, Codex and Gemini run on this machine with their existing logins."
+            : command.hostCli === "off"
+                ? "Using API keys only (--host-cli=off). Leave that option out to use the Claude Code, Codex or Gemini CLI installed on this machine."
+                : "Using API keys only. Install Claude Code, Codex or Gemini on this machine and run the command again to use them.");
+        if (result.recovery)
+            console.log(`Recovery copy of your data: Docker volume ${result.recovery}`);
+        for (const line of result.removed)
+            console.log(`Removed ${line}.`);
+        for (const problem of result.problems)
+            console.warn(problem);
+        await recordLoginStart({
+            directory: join(dockerRoot(env, home), name.data),
+            name: name.data,
+            uid,
+            flag: command.autostart,
+            interactive: process.stdin.isTTY === true,
+            ask: askTerminal,
+            exec: nodeAutostartExec,
+            now: () => new Date(),
+            report: (line) => console.log(line),
+        }).catch((error) => {
+            console.warn(`Slopify couldn't check whether Docker starts when you log in (${error instanceof Error ? error.message : String(error)}). Settings → General will say it doesn't know; run the command again to check again.`);
+        });
+    }
+    finally {
+        process.off("SIGINT", abort);
+        process.off("SIGTERM", abort);
+    }
+}
+// dist/compose.yaml in the package; the repository's own compose.yaml when run from source.
+async function composeFile() {
+    const candidates = ["../../compose.yaml", "../../../../../compose.yaml"].map((path) => fileURLToPath(new URL(path, import.meta.url)));
+    for (const path of candidates) {
+        try {
+            await access(path);
+            return path;
+        }
+        catch {
+            // Try the next location.
+        }
+    }
+    throw new Error("This Slopify package is missing its compose.yaml. Reinstall it (npx @gentbajko/slopify@latest --docker) and try again.");
+}
+/** Whether this user has a Docker installation, so `slopify update` knows which one to update. */
+export async function hasDockerInstall(env) {
+    const directory = join(dockerRoot(env, homedir()), env.SLOPIFY_DOCKER_NAME || "slopify");
+    for (const file of ["install.json", "receipt.json"]) {
+        try {
+            await access(join(directory, file));
+            return true;
+        }
+        catch {
+            // Not this one.
+        }
+    }
+    return false;
+}
+/** `<Documents>/Slopify/Projects`, or `<Documents>/Slopify/<name>/Projects` for a second install. */
+export function documentsProjects(documents, name) {
+    return name === "slopify"
+        ? join(documents, "Slopify", "Projects")
+        : join(documents, "Slopify", name, "Projects");
+}

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

@@ -0,0 +1,146 @@
+import { lstat, mkdir } from "node:fs/promises";
+import { dirname, isAbsolute, join, resolve, sep } from "node:path";
+import { z } from "zod";
+import { privateRead, privateWrite } from "../../host-cli/service.js";
+import { isMissing, syncDirectory } from "./tree.js";
+export const identifier = z
+    .string()
+    .min(1)
+    .max(128)
+    .regex(/^[a-zA-Z0-9][a-zA-Z0-9_.-]*$/);
+export const absolute = z
+    .string()
+    .min(1)
+    .max(4096)
+    .refine((p) => isAbsolute(p) && resolve(p) === p && !/[\p{Cc},]/u.test(p));
+const identity = z.object({ dev: z.string(), ino: z.string() }).strict();
+const digest = z
+    .object({
+    hash: z.string().regex(/^[a-f0-9]{64}$/),
+    files: z.number().int().nonnegative(),
+    bytes: z.number().int().nonnegative(),
+})
+    .strict();
+const token = z.string().regex(/^[a-f0-9]{64}$/);
+/**
+ * install.json: what the Docker install command last committed. The compose file and its .env
+ * are rendered from it, the host helper reads `projects` and `projectsIdentity` to decide which
+ * folders it may open, and the next install or update starts from it.
+ */
+export const installSchema = z
+    .object({
+    version: z.literal(2),
+    name: identifier,
+    volume: identifier,
+    daemon: z.string(),
+    image: z.string().min(1),
+    appVersion: z.string().regex(/^\d+\.\d+\.\d+$/),
+    user: z.string().regex(/^\d+:\d+$/),
+    port: z.number().int().min(0).max(65535),
+    projects: absolute,
+    projectsIdentity: identity,
+    // The Backups folder shared beside Projects (installs from 3.0 on). Absent: backups stay in
+    // the Projects folder's own Backups folder, as older installs keep them.
+    backups: absolute.optional(),
+    hostCli: z.boolean(),
+    token,
+    recovery: z.string().nullable(),
+})
+    .strict();
+/**
+ * update.json exists only while an install or update is changing things. If a run is cut off,
+ * the next run finds it and puts the previous version back before doing anything else.
+ */
+export const updateSchema = z
+    .object({
+    version: z.literal(2),
+    id: z.string().uuid(),
+    phase: z.enum(["stopping", "snapshot", "starting"]),
+    // The image being installed; its fixed volume helper does the snapshot and the restore.
+    image: z.string().min(1),
+    previous: z.discriminatedUnion("kind", [
+        z.object({ kind: z.literal("none") }).strict(),
+        z.object({ kind: z.literal("compose"), env: z.string(), activation: z.string() }).strict(),
+        z
+            .object({
+            kind: z.literal("legacy"),
+            id: z.string(),
+            name: identifier,
+            renamed: identifier,
+            running: z.boolean(),
+            restart: z.string(),
+        })
+            .strict(),
+    ]),
+    backup: z.string().nullable(),
+    backupDigest: digest.nullable(),
+    // A project folder this run filled with a verified copy; the undo removes it again.
+    published: z.object({ path: absolute, identity }).strict().nullable(),
+})
+    .strict();
+// 2.5.0's launcher records, read only to adopt an installation it made.
+export const legacyReceiptSchema = z
+    .object({ name: identifier, volume: identifier, projects: absolute, directoryIdentity: identity })
+    .passthrough();
+export const legacyJournalSchema = z
+    .object({
+    id: z.string(),
+    name: identifier,
+    volume: identifier,
+    phase: z.string(),
+    backup: z.string(),
+})
+    .passthrough();
+export const settledLegacyPhases = new Set(["healthy", "committed", "restored", "rolled-back"]);
+/** Where the Docker install command keeps one folder per installation. */
+export function dockerRoot(env, home) {
+    return join(absolute.parse(env.XDG_DATA_HOME || join(home, ".local/share")), "slopify/docker");
+}
+export async function privateDirectory(path, uid) {
+    absolute.parse(path);
+    let current = sep;
+    for (const name of path.split(sep).filter(Boolean)) {
+        current = join(current, name);
+        await mkdir(current, { mode: 0o700 }).catch((error) => {
+            if (!(typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST"))
+                throw error;
+        });
+        const s = await lstat(current);
+        if (!s.isDirectory() ||
+            s.isSymbolicLink() ||
+            ((s.mode & 0o022) !== 0 && (s.mode & 0o1000) === 0))
+            throw new Error(`${current} is not a normal folder, or other users can write to it, so Slopify won't keep its Docker settings under it. Fix its permissions (chmod go-w ${current}) or set XDG_DATA_HOME to another folder, then try again.`);
+    }
+    const s = await lstat(path);
+    if (s.uid !== uid || (s.mode & 0o077) !== 0)
+        throw new Error(`${path} must belong to you and be private. Fix it with chmod 700 ${path} (and chown it to your user if needed), then try again.`);
+}
+export async function readState(path, schema, uid) {
+    const s = await lstat(path).catch((error) => {
+        if (isMissing(error))
+            return undefined;
+        throw error;
+    });
+    if (s === undefined)
+        return null;
+    if (!s.isFile() || s.isSymbolicLink() || s.nlink !== 1 || s.uid !== uid || (s.mode & 0o077) !== 0)
+        throw new Error(`${path} is not a private file owned by you, so Slopify won't trust it. Fix it (chmod 600 ${path}) and try again.`);
+    const text = await privateRead(path, uid);
+    if (text === undefined)
+        throw new Error(`${path} changed while Slopify was reading it. Try again.`);
+    try {
+        return schema.parse(JSON.parse(text));
+    }
+    catch {
+        throw new Error(`${path} is damaged, so Slopify can't tell what is installed. Move it aside and run the install command again.`);
+    }
+}
+export async function writeState(path, value) {
+    await writeText(path, JSON.stringify(value));
+}
+export async function writeText(path, text) {
+    if (Buffer.byteLength(text) > 64 * 1024)
+        throw new Error("Installation control record exceeds 64 KiB.");
+    await privateWrite(path, text);
+    await syncDirectory(dirname(path));
+}

package/dist/edge/{docker-projects → docker-install}/volume.js

@@ -1,5 +1,5 @@
 import { execFileSync } from "node:child_process";
-import { chmod, lchown, lstat, mkdir, readdir, rm, writeFile } from "node:fs/promises";
+import { chmod, lchown, lstat, mkdir, readdir, rm } from "node:fs/promises";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { isMissing, syncDirectory, treeDigest } from "./tree.js";
@@ -78,10 +78,6 @@ export async function volumeOperation(args) {
         await lchown("/data/home", uid, gid);
         return { ok: true };
     }
-    if (operation === "probe") {
-        await writeFile("/probe/container", "slopify ownership probe", { flag: "wx", mode: 0o600 });
-        return { uid: process.getuid?.(), gid: process.getgid?.() };
-    }
     throw new Error("Unknown fixed Docker volume operation.");
 }
 if (process.argv[1] === fileURLToPath(import.meta.url)) {