@gentbajko/slopify 2.5.0 → 3.0.0

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

@@ -1,254 +0,0 @@
-import { createHash, randomBytes, randomUUID } from "node:crypto";
-import { lstat, mkdir, readdir, rename } from "node:fs/promises";
-import { dirname, join } from "node:path";
-import { readVersion } from "../../kernel/version.js";
-import { assertVolumeClaims } from "./claims.js";
-import { readCommittedJournal } from "./committed.js";
-import { pruneRecoveryVolumes } from "./prune.js";
-import { assertSourceIdentity, recoverInstallation } from "./recover.js";
-import { journalSchema, privateDirectory, readState, receiptSchema, selectProjects, writeState, } from "./state.js";
-import { assertIdentity, assertWritableTree, identity, isMissing, privateTree, safePath, syncDirectory, treeDigest, } from "./tree.js";
-export async function installProjects(c, e, recovery) {
-    await privateDirectory(c.directory, c.uid);
-    const receiptPath = join(c.directory, "receipt.json");
-    const journalPath = join(c.directory, "journal.json");
-    let receipt = await readState(receiptPath, receiptSchema, c.uid);
-    let previousJournal = await readState(journalPath, journalSchema, c.uid);
-    const context = await e.context(c.uid, c.gid);
-    const currentVolume = await e.volume(c.volume);
-    if ((receipt && receipt.volumeIdentity !== currentVolume) ||
-        (previousJournal?.volumeIdentity && previousJournal.volumeIdentity !== currentVolume))
-        throw new Error(`Remembered data volume ${c.volume} is missing or was replaced since Slopify was installed. Restore the original volume (see docker volume ls) and run the launcher again. Nothing was changed.`);
-    if ((receipt && receipt.daemon !== context.daemon) ||
-        (previousJournal && previousJournal.daemon !== context.daemon))
-        throw new Error("This is not the Docker that Slopify was installed with (a different Docker context or DOCKER_HOST is active). Switch back to the original one (docker context use <name>, or unset DOCKER_HOST) and try again.");
-    await assertVolumeClaims(c, e, context.daemon, currentVolume, await e.inspect(c.name));
-    if (previousJournal && previousJournal.phase !== "rolled-back")
-        previousJournal = await recoverInstallation(c, previousJournal, receipt, recovery());
-    if (previousJournal?.phase === "rolled-back")
-        await assertSourceIdentity(previousJournal);
-    receipt = await readState(receiptPath, receiptSchema, c.uid);
-    const old = await e.inspect(c.name);
-    if (!receipt &&
-        previousJournal?.sourceBind &&
-        (old?.id !== previousJournal.previous?.id ||
-            old?.mounts.find((m) => m.destination === "/data/projects")?.source !==
-                previousJournal.sourceBind))
-        throw new Error(`Original bound container is missing or changed. Restore the recorded original container using ${previousJournal.sourceBind}; the hidden volume projects are not authoritative.`);
-    for (const name of await readdir(c.root)) {
-        if (name === c.name || name === "setup.lock")
-            continue;
-        const s = await lstat(join(c.root, name));
-        if (!s.isDirectory() || s.isSymbolicLink())
-            continue;
-        const other = await readState(join(c.root, name, "receipt.json"), receiptSchema, c.uid);
-        if (other?.daemon === context.daemon && other.volume === c.volume)
-            throw new Error(`The Docker volume ${c.volume} already belongs to another Slopify installation (${other.name}). Give this one its own volume with SLOPIFY_DOCKER_VOLUME=<name> and try again.`);
-    }
-    let reuse = null;
-    if (previousJournal?.phase === "rolled-back" &&
-        previousJournal.sourceBind !== previousJournal.destination &&
-        previousJournal.publishedIdentity &&
-        previousJournal.sourceDigest &&
-        (c.projectsOverride === null || c.projectsOverride === previousJournal.destination)) {
-        await assertIdentity(previousJournal.destination, previousJournal.publishedIdentity);
-        if ((await treeDigest(previousJournal.destination)).hash !== previousJournal.sourceDigest.hash)
-            throw new Error(`Published retry folder changed; preserve it for inspection: ${previousJournal.destination}`);
-        reuse = previousJournal;
-    }
-    const base = await selectProjects(c, receipt, old, reuse);
-    const projects = reuse?.destination ?? base;
-    await safePath(projects, c.home, c.root, true);
-    const bind = receipt?.projects ??
-        old?.mounts.find((m) => m.destination === "/data/projects")?.source ??
-        null;
-    if (bind !== null)
-        await assertWritableTree(bind, c.uid);
-    const image = await e.image(c.image);
-    const expectedVersion = await e.version(image);
-    if (expectedVersion !== readVersion())
-        throw new Error(`The Docker image is Slopify ${expectedVersion} but this launcher is ${readVersion()}. Run the latest of both (npx @gentbajko/slopify@latest --docker), or if you set SLOPIFY_DOCKER_IMAGE, point it at version ${readVersion()}. Your existing container was not changed.`);
-    const signature = createHash("sha256")
-        .update(JSON.stringify([image, c.volume, c.port, c.bridge, projects, context.user]))
-        .digest("hex");
-    await e.writers(c.volume, [projects, ...(bind ? [bind] : [])], old ? [old.id] : []);
-    await e.probe(c, image, context.user, projects);
-    if (receipt &&
-        old &&
-        old.signature === signature &&
-        old.image === image &&
-        old.user === context.user &&
-        old.mounts.find((m) => m.destination === "/data/projects")?.source === projects &&
-        old.mounts.find((m) => m.destination === "/data")?.name === c.volume &&
-        old.mounts.find((m) => m.destination === "/data")?.rw === true &&
-        old.mounts.find((m) => m.destination === "/opt/slopify-install")?.source ===
-            join(c.directory, receipt.transaction) &&
-        old.mounts.find((m) => m.destination === "/opt/slopify-install")?.rw === false &&
-        old.restart.Name === "always" &&
-        old.port?.startsWith("127.0.0.1:") &&
-        (c.port === 0 || old.port === `127.0.0.1:${c.port}`) &&
-        (old.mounts.find((m) => m.destination === "/opt/slopify-host")?.source ?? null) === c.bridge) {
-        const j = await readCommittedJournal(c, receipt, old);
-        if (!old.running)
-            await e.command(["start", old.id]);
-        await e.health(old.id, j.token, expectedVersion);
-        return {
-            url: `http://${old.port}`,
-            projects,
-            recovery: j.backup,
-            pruned: { removed: [], problems: [] },
-        };
-    }
-    const id = randomUUID();
-    const directory = join(c.directory, id);
-    await privateDirectory(directory, c.uid);
-    const destinationBefore = await identity(projects).catch((error) => {
-        if (isMissing(error))
-            return null;
-        throw error;
-    });
-    let j = {
-        version: 1,
-        id,
-        installation: receipt?.installation ?? randomUUID(),
-        daemon: context.daemon,
-        name: c.name,
-        volume: c.volume,
-        volumeIdentity: currentVolume,
-        image,
-        user: context.user,
-        signature,
-        phase: "prepared",
-        previous: old,
-        previousReceipt: receipt,
-        sourceBind: bind,
-        sourceIdentity: bind === null ? null : (receipt?.directoryIdentity ?? (await identity(bind))),
-        destination: projects,
-        destinationBefore,
-        staging: join(dirname(projects), `.slopify-projects-${id}`),
-        stagingIdentity: null,
-        publishedIdentity: reuse?.publishedIdentity ?? null,
-        sourceDigest: reuse?.sourceDigest ?? null,
-        sourceAbsent: reuse?.sourceAbsent ?? false,
-        backup: `${c.volume}-recovery-${id}`,
-        backupDigest: null,
-        candidate: null,
-        token: randomBytes(32).toString("hex"),
-    };
-    async function save(change) {
-        j = journalSchema.parse({ ...j, ...change });
-        await writeState(join(directory, "journal.json"), j);
-        await writeState(journalPath, j);
-    }
-    await save({});
-    await writeState(join(directory, "activation.json"), {
-        version: 1,
-        token: j.token,
-        committed: false,
-    });
-    try {
-        await save({ phase: "stopping" });
-        if (old)
-            await e.stop(old);
-        await e.writers(c.volume, [projects, ...(bind ? [bind] : [])], []);
-        await assertSourceIdentity(j);
-        await save({ phase: "stopped" });
-        await e.ensureVolume(c.volume);
-        await save({ volumeIdentity: await e.volume(c.volume) });
-        const source = await e.projects(image, c.volume, bind);
-        if (reuse && (reuse.sourceAbsent ? source !== null : source?.hash !== reuse.sourceDigest?.hash))
-            throw new Error(`Stale migration baseline. Retain ${projects} and ${reuse.staging}; select a new empty --projects-dir for a fresh verified copy.`);
-        await save({
-            sourceDigest: source ?? reuse?.sourceDigest ?? null,
-            sourceAbsent: source === null,
-        });
-        const backupDigest = await e.snapshot(j);
-        await save({ phase: "snapshot", backupDigest });
-        if (projects !== bind && reuse === null) {
-            await mkdir(j.staging, { mode: 0o700 });
-            await save({ phase: "copying", stagingIdentity: await identity(j.staging) });
-            if (source !== null)
-                await e.copy(image, c.volume, bind, j.staging, j.id);
-            await privateTree(j.staging, c.uid, c.gid);
-            const copied = await treeDigest(j.staging);
-            const after = await e.projects(image, c.volume, bind);
-            if ((source === null && copied.files !== 0) ||
-                (source !== null && (copied.hash !== source.hash || after?.hash !== source.hash)))
-                throw new Error("Project copy verification failed; source and staging are retained.");
-            await save({ phase: "verified", sourceDigest: source ?? copied });
-            await safePath(projects, c.home, c.root, false);
-            if (j.destinationBefore) {
-                await assertIdentity(projects, j.destinationBefore);
-                if ((await readdir(projects)).length !== 0)
-                    throw new Error("Destination became populated before publication.");
-            }
-            else {
-                const exists = await lstat(projects).catch((error) => {
-                    if (isMissing(error))
-                        return null;
-                    throw error;
-                });
-                if (exists !== null)
-                    throw new Error("Destination appeared before publication.");
-            }
-            if (!j.stagingIdentity)
-                throw new Error("Missing staging identity.");
-            await assertIdentity(j.staging, j.stagingIdentity);
-            await rename(j.staging, projects);
-            await syncDirectory(dirname(projects));
-        }
-        await save({ phase: "published", publishedIdentity: await identity(projects) });
-        await assertSourceIdentity(j);
-        await e.writers(c.volume, [projects, ...(bind ? [bind] : [])], []);
-        await e.own(j);
-        if (old)
-            await e.command(["rename", old.id, `${c.name}-previous-${j.id}`]);
-        await save({ phase: "starting" });
-        const candidate = await e.start(c, j, directory);
-        await save({ candidate });
-        await e.health(candidate, j.token, expectedVersion);
-        await save({ phase: "healthy" });
-        if (!j.publishedIdentity || !j.volumeIdentity)
-            throw new Error("Missing published storage identity.");
-        const next = {
-            version: 1,
-            installation: j.installation,
-            daemon: j.daemon,
-            name: c.name,
-            volume: c.volume,
-            volumeIdentity: j.volumeIdentity,
-            projects,
-            directoryIdentity: j.publishedIdentity,
-            user: j.user,
-            image,
-            signature,
-            transaction: j.id,
-        };
-        await writeState(receiptPath, next);
-        await e.command(["update", "--restart=always", candidate]);
-        await writeState(join(directory, "activation.json"), {
-            version: 1,
-            token: j.token,
-            committed: true,
-        });
-        await save({ phase: "committed" });
-        const ready = await e.inspect(candidate);
-        if (!ready?.port)
-            throw new Error("Slopify started but Docker did not report which port it is on. Run the same command again to finish.");
-        // Only now, with the new container committed and healthy, are older snapshots redundant.
-        const pruned = await pruneRecoveryVolumes(c, e, j);
-        return { url: `http://${ready.port}`, projects, recovery: j.backup, pruned };
-    }
-    catch (cause) {
-        const current = await readState(receiptPath, receiptSchema, c.uid);
-        if (current?.transaction === j.id)
-            throw new Error(`Slopify was installed (project files at ${projects}) but the last step did not finish. Run the same command again to complete it. Backup volume: ${j.backup}`, { cause });
-        try {
-            await recoverInstallation(c, j, current, recovery());
-        }
-        catch (failure) {
-            throw new Error(`Recovery incomplete: the install failed and Slopify could not fully undo it. Leave the Slopify container stopped and don't delete anything: backup volume ${j.backup}, progress file ${journalPath}, project folder ${projects}. Fix the problem below, then run the same command again. ${failure instanceof Error ? failure.message : "The undo step failed."}`, { cause });
-        }
-        throw new Error(`Install failed. Previous installation restored${old?.running ? " and restarted" : " (not started)"}, so nothing was lost. Backup volume: ${j.backup}; project copy: ${projects}. Reason: ${cause instanceof Error ? cause.message : "Installation failed."}`, { cause });
-    }
-}

package/dist/edge/docker-projects/prune.js

@@ -1,66 +0,0 @@
-import { join } from "node:path";
-import { recoveryId } from "./engine.js";
-import { journalSchema, readState } from "./state.js";
-// Phases an update's record is left in once it is over, one way or the other. Anything else
-// is an update that never finished, and its volume may be the only copy of the data.
-const settled = new Set(["healthy", "committed", "restored", "rolled-back"]);
-// After an update is committed and healthy, keep only its own recovery volume. An older one is
-// removed only when all of these hold, so a volume some other installation, container or person
-// made is never touched:
-// - its name is exactly `<this data volume>-recovery-<uuid>`, never the data volume itself;
-// - its io.slopify.transaction label is that same uuid (every launcher has set it);
-// - the container label, which this launcher adds, names this container (earlier launchers
-//   set none, and for those the next check decides alone);
-// - the update's own record, <install dir>/<uuid>/journal.json in this container's private
-//   folder, exists and names this container, data volume and Docker, the installation the
-//   volume's label names, and exactly this volume as its backup, and says that update is
-//   over. A first install that was rolled back has an installation id of its own, so the
-//   id is matched against the volume's label rather than the current update's.
-// Docker refuses to remove a volume a container still uses; that refusal is reported, not
-// forced. Nothing here can fail the update, which has already finished.
-export async function pruneRecoveryVolumes(c, e, j) {
-    const removed = [];
-    const problems = [];
-    let volumes;
-    try {
-        volumes = await e.recoveryVolumes(c.volume);
-    }
-    catch (error) {
-        return {
-            removed,
-            problems: [
-                `Couldn't list older recovery volumes to tidy up, so all of them are kept. See them with docker volume ls --filter label=io.slopify.transaction and remove the ones you no longer need with docker volume rm <name>. ${reason(error)}`,
-            ],
-        };
-    }
-    for (const volume of volumes) {
-        const id = recoveryId(c.volume, volume.name);
-        if (id === null || id === j.id || volume.name === j.backup || volume.name === c.volume)
-            continue;
-        if (volume.transaction !== id)
-            continue;
-        if (volume.container !== null && volume.container !== c.name)
-            continue;
-        const record = await readState(join(c.directory, id, "journal.json"), journalSchema, c.uid).catch(() => null);
-        if (record === null ||
-            record.id !== id ||
-            record.name !== c.name ||
-            record.volume !== c.volume ||
-            record.daemon !== j.daemon ||
-            (volume.installation !== null && volume.installation !== record.installation) ||
-            record.backup !== volume.name ||
-            !settled.has(record.phase))
-            continue;
-        try {
-            await e.removeVolume(volume.name);
-            removed.push(volume.name);
-        }
-        catch (error) {
-            problems.push(`Couldn't remove the older recovery volume ${volume.name}, so it is kept. Once nothing uses it, remove it with docker volume rm ${volume.name}. ${reason(error)}`);
-        }
-    }
-    return { removed, problems };
-}
-function reason(error) {
-    return error instanceof Error ? `Why: ${error.message}` : "";
-}

package/dist/edge/docker-projects/recover.js

@@ -1,100 +0,0 @@
-import { join } from "node:path";
-import { readCommittedJournal } from "./committed.js";
-import { selectProjects, writeState, } from "./state.js";
-import { assertIdentity, assertWritableTree, identity, isMissing, treeDigest } from "./tree.js";
-export async function assertSourceIdentity(j) {
-    if (j.sourceBind === null)
-        return;
-    if (!j.sourceIdentity)
-        throw new Error("Original project bind identity is missing.");
-    await assertIdentity(j.sourceBind, j.sourceIdentity);
-}
-export async function recoverInstallation(c, j, receipt, e) {
-    const directory = join(c.directory, j.id);
-    if (j.name !== c.name || j.volume !== c.volume)
-        throw new Error("Journal installation conflict.");
-    if (receipt?.transaction === j.id) {
-        const current = await e.inspect(c.name);
-        await selectProjects({ ...c, projectsOverride: null }, receipt, current);
-        await assertWritableTree(receipt.projects, c.uid);
-        j = await readCommittedJournal(c, receipt, current);
-        await e.writers(c.volume, [receipt.projects], current ? [current.id] : []);
-        await writeState(join(directory, "activation.json"), {
-            version: 1,
-            token: j.token,
-            committed: true,
-        });
-        if (current && current.installation === j.installation && current.signature === j.signature) {
-            await e.command(["update", "--restart=always", current.id]);
-            if (!current.running)
-                await e.command(["start", current.id]);
-        }
-        const finished = { ...j, phase: "committed" };
-        await writeState(join(c.directory, "journal.json"), finished);
-        return finished;
-    }
-    if (j.phase === "rolled-back")
-        return j;
-    await assertSourceIdentity(j);
-    const occupant = await e.inspect(c.name);
-    if (j.phase === "verified" && j.stagingIdentity && j.sourceDigest) {
-        const found = await identity(j.destination).catch((error) => {
-            if (isMissing(error))
-                return null;
-            throw error;
-        });
-        if (found?.dev === j.stagingIdentity.dev &&
-            found.ino === j.stagingIdentity.ino &&
-            (await treeDigest(j.destination)).hash === j.sourceDigest.hash) {
-            j = { ...j, publishedIdentity: found };
-        }
-    }
-    const possible = j.candidate ? await e.inspect(j.candidate) : occupant;
-    if (occupant && occupant.id !== j.previous?.id && occupant.id !== possible?.id)
-        throw new Error("Recovery name is occupied by an unrelated container.");
-    if (possible && possible.id !== j.previous?.id) {
-        const transaction = await e.command([
-            "inspect",
-            "--format",
-            '{{index .Config.Labels "io.slopify.transaction"}}',
-            possible.id,
-        ]);
-        if (transaction !== j.id ||
-            possible.installation !== j.installation ||
-            possible.signature !== j.signature)
-            throw new Error("Recovery name is occupied by an unrelated container.");
-        if (j.candidate !== possible.id) {
-            j = { ...j, candidate: possible.id };
-            await writeState(join(c.directory, "journal.json"), j);
-            await writeState(join(directory, "journal.json"), j);
-        }
-        await e.stop(possible);
-        const failedName = `${c.name}-failed-${j.id}`;
-        if (possible.name !== failedName)
-            await e.command(["rename", possible.id, failedName]);
-    }
-    if (j.phase !== "restored") {
-        if (j.backupDigest) {
-            await e.writers(c.volume, [j.destination, ...(j.sourceBind ? [j.sourceBind] : [])], []);
-            await e.restore(j);
-        }
-        j = { ...j, phase: "restored" };
-        await writeState(join(c.directory, "journal.json"), j);
-        await writeState(join(directory, "journal.json"), j);
-    }
-    if (j.previous) {
-        const old = await e.inspect(j.previous.id);
-        if (!old || old.mounts.find((m) => m.destination === "/data")?.name !== c.volume)
-            throw new Error("Original container/storage is missing; automatic rollback is unsafe.");
-        if (j.previousReceipt)
-            await selectProjects({ ...c, projectsOverride: null }, j.previousReceipt, old);
-        if (j.sourceBind !== null)
-            await assertWritableTree(j.sourceBind, c.uid);
-        await e.writers(c.volume, [j.destination, ...(j.sourceBind ? [j.sourceBind] : [])], [old.id]);
-        await e.restart(j.previous);
-    }
-    const rolledBack = { ...j, phase: "rolled-back" };
-    await writeState(join(c.directory, "journal.json"), rolledBack);
-    await writeState(join(directory, "journal.json"), rolledBack);
-    return rolledBack;
-}

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

@@ -1,225 +0,0 @@
-import { lstat, mkdir, readdir } 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 { assertIdentity, contains, isMissing, safePath, syncDirectory, treeDigest, } from "./tree.js";
-const identifier = z
-    .string()
-    .min(1)
-    .max(128)
-    .regex(/^[a-zA-Z0-9][a-zA-Z0-9_.-]*$/);
-const absolute = z
-    .string()
-    .min(1)
-    .max(4096)
-    .refine((p) => isAbsolute(p) && resolve(p) === p && !/[\p{Cc},]/u.test(p));
-export const identitySchema = z.object({ dev: z.string(), ino: z.string() }).strict();
-export const digestSchema = z
-    .object({
-    hash: z.string().regex(/^[a-f0-9]{64}$/),
-    files: z.number().int().nonnegative(),
-    bytes: z.number().int().nonnegative(),
-})
-    .strict();
-export const containerSchema = z
-    .object({
-    id: z.string(),
-    name: z.string(),
-    image: z.string(),
-    user: z.string(),
-    running: z.boolean(),
-    restart: z.object({ Name: z.string(), MaximumRetryCount: z.number().int() }),
-    signature: z.string().nullable(),
-    installation: z.string().nullable(),
-    mounts: z.array(z.object({
-        type: z.string(),
-        name: z.string(),
-        source: z.string(),
-        destination: z.string(),
-        rw: z.boolean(),
-    })),
-    port: z.string().nullable(),
-})
-    .strict();
-export const receiptSchema = z
-    .object({
-    version: z.literal(1),
-    installation: z.string().uuid(),
-    daemon: z.string(),
-    name: identifier,
-    volume: identifier,
-    volumeIdentity: z.string(),
-    projects: absolute,
-    directoryIdentity: identitySchema,
-    user: z.string(),
-    image: z.string(),
-    signature: z.string(),
-    transaction: z.string().uuid(),
-})
-    .strict();
-export const phases = [
-    "prepared",
-    "stopping",
-    "stopped",
-    "snapshot",
-    "copying",
-    "verified",
-    "published",
-    "starting",
-    "healthy",
-    "committed",
-    "restored",
-    "rolled-back",
-];
-export const journalSchema = z
-    .object({
-    version: z.literal(1),
-    id: z.string().uuid(),
-    installation: z.string().uuid(),
-    daemon: z.string(),
-    name: identifier,
-    volume: identifier,
-    volumeIdentity: z.string().nullable(),
-    image: z.string(),
-    user: z.string(),
-    signature: z.string(),
-    phase: z.enum(phases),
-    previous: containerSchema.nullable(),
-    previousReceipt: receiptSchema.nullable(),
-    sourceBind: absolute.nullable(),
-    sourceIdentity: identitySchema.nullable().default(null),
-    destination: absolute,
-    destinationBefore: identitySchema.nullable(),
-    staging: absolute,
-    stagingIdentity: identitySchema.nullable(),
-    publishedIdentity: identitySchema.nullable(),
-    sourceDigest: digestSchema.nullable(),
-    sourceAbsent: z.boolean().default(false),
-    backup: z
-        .string()
-        .max(174)
-        .regex(/^[a-zA-Z0-9][a-zA-Z0-9_.-]*$/),
-    backupDigest: digestSchema.nullable(),
-    candidate: z.string().nullable(),
-    token: z.string().regex(/^[a-f0-9]{64}$/),
-})
-    .strict();
-/** Where the Docker launcher keeps one folder (and receipt) per installation. */
-export function dockerRoot(env, home) {
-    return join(absolute.parse(env.XDG_DATA_HOME || join(home, ".local/share")), "slopify/docker");
-}
-export function dockerConfig(env, home, cwd, uid, gid) {
-    const name = identifier.parse(env.SLOPIFY_DOCKER_NAME || "slopify");
-    const volume = identifier.parse(env.SLOPIFY_DOCKER_VOLUME || "slopify-data");
-    const root = dockerRoot(env, home);
-    const raw = env.SLOPIFY_DOCKER_PROJECTS_DIR || null;
-    const projectsOverride = raw === null ? null : resolve(cwd, raw.startsWith("~/") ? join(home, raw.slice(2)) : raw);
-    const portText = env.SLOPIFY_DOCKER_HOST_PORT || "6969";
-    if (!/^\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.`);
-    return {
-        home,
-        uid,
-        gid,
-        root,
-        directory: join(root, name),
-        name,
-        volume,
-        image: z
-            .string()
-            .min(1)
-            .refine((s) => !/[\p{Cc}]/u.test(s))
-            .parse(env.SLOPIFY_DOCKER_IMAGE || "ghcr.io/gentbajko/slopify:latest"),
-        port: Number(portText),
-        projectsOverride,
-        bridge: env.SLOPIFY_HOST_CLI_DIR || null,
-    };
-}
-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("Unsafe private installation record.");
-    const text = await privateRead(path, uid);
-    if (text === undefined)
-        throw new Error("Installation record changed while reading.");
-    return schema.parse(JSON.parse(text));
-}
-export async function writeState(path, value) {
-    const text = JSON.stringify(value);
-    if (Buffer.byteLength(text) > 64 * 1024)
-        throw new Error("Installation control record exceeds 64 KiB.");
-    await privateWrite(path, text);
-    await syncDirectory(dirname(path));
-}
-export async function selectProjects(c, receipt, old, retry = null) {
-    const data = old?.mounts.find((m) => m.destination === "/data");
-    const bind = old?.mounts.find((m) => m.destination === "/data/projects");
-    if (old && (data?.type !== "volume" || data.name !== c.volume))
-        throw new Error("Existing container uses a different data volume.");
-    if (bind && (bind.type !== "bind" || !bind.rw))
-        throw new Error("Unsupported existing projects mount.");
-    if (old?.mounts.some((m) => m.destination.startsWith("/data/") && m.destination !== "/data/projects"))
-        throw new Error("Unexpected nested data mount; use the existing installation for recovery.");
-    if (receipt) {
-        if (receipt.name !== c.name || receipt.volume !== c.volume)
-            throw new Error("Receipt selects a different installation or volume.");
-        await safePath(receipt.projects, c.home, c.root, false);
-        await assertIdentity(receipt.projects, receipt.directoryIdentity).catch((cause) => {
-            throw new Error(`Remembered project folder ${receipt.projects} is missing or was replaced. Put the original folder back where it was and run the launcher again.`, {
-                cause,
-            });
-        });
-        if (old && (bind?.source !== receipt.projects || old.installation !== receipt.installation))
-            throw new Error("Actual container mounts/installation disagree with its receipt.");
-    }
-    const chosen = c.projectsOverride ??
-        receipt?.projects ??
-        bind?.source ??
-        (c.name === "slopify"
-            ? join(c.home, "Slopify/Projects")
-            : join(c.home, "Slopify", c.name, "Projects"));
-    await safePath(chosen, c.home, c.root, true);
-    const source = receipt?.projects ?? bind?.source;
-    if (source && source !== chosen && (contains(source, chosen) || contains(chosen, source)))
-        throw new Error(`The new project folder ${chosen} and the current one ${source} are inside each other. Choose a separate folder with --projects-dir <folder>.`);
-    if (chosen !== source) {
-        const entries = await readdir(chosen).catch((error) => {
-            if (isMissing(error))
-                return [];
-            throw error;
-        });
-        if (entries.length > 0) {
-            if (retry?.destination !== chosen || !retry.publishedIdentity || !retry.sourceDigest)
-                throw new Error(`The project folder ${chosen} already has files in it that Slopify didn't put there. Choose an empty or new folder with --projects-dir <folder>, or move those files away, then try again.`);
-            await assertIdentity(chosen, retry.publishedIdentity);
-            if ((await treeDigest(chosen)).hash !== retry.sourceDigest.hash)
-                throw new Error(`Published retry destination changed: ${chosen}`);
-        }
-    }
-    return chosen;
-}