@gentbajko/slopify 1.5.1 → 2.0.1

package/README.md

@@ -30,17 +30,40 @@ slopify
 
 Both commands launch the same local app.
 
-For Docker on Linux with systemd, use `slopify --docker` or
+For Docker on Linux with Node 26+ and util-linux (`flock`), use `slopify --docker` or
 `npx @gentbajko/slopify@latest --docker`. The launcher detects installed Codex,
 Claude Code and Gemini CLIs. It asks once before installing a private host helper
 and enabling automatic startup, including user lingering. The CLIs run on your
 host with their existing logins; credentials never move into Docker.
 
-Slopify runs in the background, restarts with Docker and keeps your data in
-`slopify-data`. Add `--port 7070` to change the default port. Rerun the launcher
-after changing host CLI installations or search paths. Native installs need no helper.
-Plain `docker run` is API-only without a configured helper. Use `--host-cli=off`
-for API-only launcher setup, or `--accept-host-cli` to approve non-interactive setup.
+Slopify runs in the background at `http://127.0.0.1:6969` and restarts with Docker.
+The managed Linux launcher saves generated project files in `~/Slopify/Projects`.
+Custom container names use `~/Slopify/<container>/Projects`. The database,
+credentials, logs and staging stay private in the named `slopify-data` volume.
+Run as your normal user with Node 26+, Docker access and util-linux (`flock`).
+Systemd is needed only for the optional host CLI helper. Native installs continue
+using their configured data directory and need no helper.
+
+Use `--projects-dir "/path/to/Projects"` or `SLOPIFY_DOCKER_PROJECTS_DIR` to choose
+a dedicated folder. Later launches remember that absolute path when the override
+is omitted. `--port 7070` changes the localhost port. Custom installations sharing
+a machine need distinct `SLOPIFY_DOCKER_NAME` and `SLOPIFY_DOCKER_VOLUME` values.
+Do not store unrelated documents in the managed Projects tree: storage
+reconciliation owns it. Moving to another folder performs a verified copy;
+existing unrelated contents are never merged or overwritten.
+
+Existing installations are stopped, copied and verified before the new folder
+is activated. Current and historical output actions show the real host folder
+on the machine running Slopify; downloads remain available. This also works with
+`--host-cli=off`, without installing a host helper. Docker does not open a desktop
+window on your browser's machine.
+
+Rerun the launcher after changing host CLI installations or search paths.
+Plain `docker run` is API-only unless connected to an already configured helper.
+It does not set up a host project folder or install host services; its files stay
+in the private named volume. Use the managed launcher for automatic migration
+and host-folder access. Use `--host-cli=off` for API-only launcher setup, or
+`--accept-host-cli` to approve non-interactive setup.
 See the [Docker setup guide](https://github.com/GentBajko/slopify#docker) for
 updates and the dedicated helper's status/disable commands.
 
@@ -85,6 +108,7 @@ for account limits. Both model IDs are bundled; Inworld's LLM catalogue does not
 | `--port` | `SLOPIFY_PORT` | `6969` |
 | `--host` | `SLOPIFY_HOST` | `127.0.0.1` |
 | `--data-dir` | `SLOPIFY_DATA_DIR` | `~/.slopify` |
+| `--projects-dir` (Docker only) | `SLOPIFY_DOCKER_PROJECTS_DIR` | remembered path; otherwise `~/Slopify/Projects` (custom names: `~/Slopify/<container>/Projects`) |
 | `--no-open` | `SLOPIFY_NO_OPEN` | the browser opens |
 | `--docker` | — | run locally; with the flag, launch Docker with host CLI detection |
 | — | `SLOPIFY_FFMPEG` | the bundled binary |
@@ -92,8 +116,10 @@ for account limits. Both model IDs are bundled; Inworld's LLM catalogue does not
 There is no login. Binding to anything but `127.0.0.1` hands the app and every key in
 it to whoever reaches the port, and the CLI says so on startup.
 
-Everything lives in one SQLite file and one directory tree under the data directory:
-`slopify.db`, `projects/`, `staging/`, `logs/`. Delete it and nothing of yours remains.
+Native installations keep `slopify.db`, `projects/`, `staging/` and `logs/` under
+their configured data directory. Managed Docker places only projects in its
+remembered host folder; keep both that folder and the named private volume when
+backing up an installation. The portable settings archive is not a project/history backup.
 
 ## ffmpeg and the GPL
 

package/dist/adapters/alignment/cache.js

@@ -4,6 +4,7 @@ import { mkdir, mkdtemp, rename, rm, stat } from "node:fs/promises";
 import { join } from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
+import { setTimeout as delay } from "node:timers/promises";
 const revision = "a19f851b3d42865797e410752b4c570c871e4825";
 export const alignmentModel = {
     filename: "wav2vec2-base-960h-cd5040c1.onnx",
@@ -17,22 +18,70 @@ export async function prepareModel(input, deps = { model: alignmentModel, fetch:
     const target = join(input.cacheDir, deps.model.filename);
     if (await verified(target, deps.model, input.signal))
         return target;
+    let lastFailure;
+    for (let attempt = 1; attempt <= 3; attempt += 1) {
+        try {
+            return await downloadModel(input, deps, target);
+        }
+        catch (error) {
+            input.signal.throwIfAborted();
+            if (!(error instanceof Error) || error.name !== "SubtitleModelDownloadInterrupted")
+                throw error;
+            lastFailure = error;
+            if (attempt < 3) {
+                if (deps.wait)
+                    await deps.wait(attempt * 1000, input.signal);
+                else
+                    await delay(attempt * 1000, undefined, { signal: input.signal });
+            }
+        }
+    }
+    throw new Error("The free subtitle model download was interrupted after 3 attempts. Check your connection and retry.", { cause: lastFailure });
+}
+async function downloadModel(input, deps, target) {
+    input.signal.throwIfAborted();
     const staging = await mkdtemp(join(input.cacheDir, ".alignment-download-"));
     const part = join(staging, "model.part");
     try {
-        const response = await deps.fetch(deps.model.url, {
-            signal: AbortSignal.any([input.signal, AbortSignal.timeout(300_000)]),
-        });
-        if (!response.ok || response.body === null)
-            throw new Error(`The free subtitle model could not be downloaded (HTTP ${response.status}). Check your connection and try again.`);
+        let response;
+        try {
+            response = await deps.fetch(deps.model.url, {
+                signal: AbortSignal.any([input.signal, AbortSignal.timeout(300_000)]),
+            });
+        }
+        catch (error) {
+            throw interrupted(error);
+        }
+        if (!response.ok || response.body === null) {
+            const error = new Error(`The free subtitle model could not be downloaded (HTTP ${response.status}). Check your connection and try again.`);
+            let failure = error;
+            try {
+                if (response.body !== null)
+                    await response.body.cancel();
+            }
+            catch (cleanup) {
+                failure = new AggregateError([error, cleanup], error.message, { cause: error });
+            }
+            if (response.status === 408 || response.status === 429 || response.status >= 500)
+                throw interrupted(failure);
+            throw failure;
+        }
         let current = 0;
         const hash = createHash("sha256");
         const reader = response.body.getReader();
         async function* chunks() {
+            let readFailed = false;
             try {
                 for (;;) {
                     input.signal.throwIfAborted();
-                    const result = await reader.read();
+                    let result;
+                    try {
+                        result = await reader.read();
+                    }
+                    catch (error) {
+                        readFailed = true;
+                        throw interrupted(error);
+                    }
                     if (result.done)
                         break;
                     current += result.value.length;
@@ -44,7 +93,13 @@ export async function prepareModel(input, deps = { model: alignmentModel, fetch:
                 }
             }
             finally {
-                await reader.cancel();
+                try {
+                    if (!readFailed)
+                        await reader.cancel();
+                }
+                finally {
+                    reader.releaseLock();
+                }
             }
         }
         await pipeline(Readable.from(chunks()), createWriteStream(part, { mode: 0o600 }), {
@@ -72,6 +127,11 @@ export async function prepareModel(input, deps = { model: alignmentModel, fetch:
         await rm(staging, { recursive: true, force: true });
     }
 }
+function interrupted(cause) {
+    const error = new Error("The subtitle model download was interrupted.", { cause });
+    error.name = "SubtitleModelDownloadInterrupted";
+    return error;
+}
 async function verified(path, model, signal) {
     try {
         if ((await stat(path)).size !== model.bytes)

package/dist/edge/cli.js

@@ -16,6 +16,7 @@ const { values } = parseArgs({
         port: { type: "string" },
         host: { type: "string" },
         "data-dir": { type: "string" },
+        "projects-dir": { type: "string" },
         "no-open": { type: "boolean" },
         docker: { type: "boolean" },
         "host-cli": { type: "string" },
@@ -23,6 +24,8 @@ const { values } = parseArgs({
     },
 });
 try {
+    if (values["projects-dir"] !== undefined && !values.docker)
+        throw new Error("--projects-dir requires --docker; native installs use --data-dir.");
     if ((values["host-cli"] !== undefined || values["accept-host-cli"] !== undefined) &&
         !values.docker)
         throw new Error("Host CLI options require --docker.");
@@ -30,8 +33,10 @@ try {
         throw new Error("The --host-cli override supports only off (API-only Docker).");
     if (values.docker) {
         if (values.host !== undefined || values["data-dir"] !== undefined)
-            throw new Error("Docker stores data in the slopify-data volume and binds to localhost. Use --port to change its port.");
-        const { prepareDockerHostCli } = await import("./docker.js");
+            throw new Error("Docker keeps private data in its named volume and binds to localhost. Use --projects-dir for project files and --port 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"),
@@ -62,6 +67,9 @@ try {
                 ...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"] }),
             },
         });
         if (result.error)

package/dist/edge/docker-launch.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { constants } from "node:fs";
+import { open } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { nodeHostSetupRunner } from "../host-cli/install.js";
+import { assertManagedDockerHost } from "./docker.js";
+import { dockerEngine } from "./docker-projects/engine.js";
+import { installProjects } from "./docker-projects/install.js";
+import { dockerConfig, privateDirectory } from "./docker-projects/state.js";
+async function main() {
+    const uid = process.getuid?.();
+    const gid = process.getgid?.();
+    assertManagedDockerHost(process.platform, uid, gid);
+    if (gid === undefined)
+        throw new Error("Missing host group.");
+    const c = dockerConfig(process.env, homedir(), process.cwd(), uid, gid);
+    await privateDirectory(c.root, uid);
+    if (process.argv[2] !== "--locked") {
+        const path = join(c.root, "setup.lock");
+        const fd = await open(path, constants.O_CREAT | constants.O_RDWR | constants.O_NOFOLLOW, 0o600);
+        try {
+            const s = await fd.stat();
+            if (!s.isFile() || s.nlink !== 1 || s.uid !== uid || (s.mode & 0o077) !== 0)
+                throw new Error("Unsafe Docker setup lock.");
+            const child = spawn("flock", [
+                "--nonblock",
+                "--no-fork",
+                "--conflict-exit-code",
+                "73",
+                path,
+                process.execPath,
+                fileURLToPath(import.meta.url),
+                "--locked",
+            ], { stdio: "inherit" });
+            const code = await new Promise((resolve, reject) => {
+                child.once("error", () => reject(new Error("Install util-linux (flock) before using the managed Docker launcher.")));
+                child.once("exit", (status, signal) => signal
+                    ? reject(new Error("Docker setup was interrupted; rerun to recover."))
+                    : resolve(status ?? 1));
+            });
+            if (code === 73)
+                throw new Error("Another managed Docker installation is changing storage. Wait for it to finish and rerun.");
+            process.exitCode = code;
+            return;
+        }
+        finally {
+            await fd.close();
+        }
+    }
+    const controller = new AbortController();
+    const abort = () => controller.abort(new Error("Docker setup interrupted."));
+    process.once("SIGINT", abort);
+    process.once("SIGTERM", abort);
+    try {
+        const e = dockerEngine(nodeHostSetupRunner, controller.signal, process.env);
+        const recovery = () => dockerEngine(nodeHostSetupRunner, AbortSignal.timeout(5 * 60_000), process.env);
+        const result = await installProjects(c, e, recovery);
+        console.log(`Slopify is running at ${result.url}`);
+        console.log(`Project files on this machine: ${result.projects}`);
+        if (result.recovery)
+            console.log(`Recovery volume retained: ${result.recovery}. Previous containers remain stopped.`);
+    }
+    finally {
+        process.off("SIGINT", abort);
+        process.off("SIGTERM", abort);
+    }
+}
+try {
+    await main();
+}
+catch (error) {
+    console.error(error instanceof Error ? error.message : "Docker setup failed.");
+    process.exitCode = 1;
+}

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

@@ -0,0 +1,35 @@
+import { timingSafeEqual } from "node:crypto";
+import { lstat, readFile } from "node:fs/promises";
+import { isAbsolute, resolve } from "node:path";
+import { z } from "zod";
+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)));
+}
+export async function dockerFolderConfiguration(env, projectsRoot) {
+    if (env.SLOPIFY_CONTAINER !== "1")
+        return { container: false, hostProjects: 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 };
+    if (!isAbsolute(host) || resolve(host) !== host || /[\p{Cc},]/u.test(host))
+        throw new Error("Invalid Docker host project path.");
+    const root = await lstat(projectsRoot);
+    const mounts = await readFile("/proc/self/mountinfo", "utf8");
+    if (projectsRoot !== "/data/projects" ||
+        !root.isDirectory() ||
+        root.isSymbolicLink() ||
+        !mounts.split("\n").some((line) => line.split(" ")[4] === "/data/projects"))
+        throw new Error("Managed Docker project bind is missing.");
+    return { container: true, hostProjects: host };
+}

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

@@ -0,0 +1,85 @@
+import { lstat, readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { journalSchema, readState } from "./state.js";
+export async function assertVolumeClaims(c, e, daemon, volumeIdentity, current) {
+    const permitted = new Set(current ? [current.id] : []);
+    for (const entry of await readdir(c.directory)) {
+        if (!/^[a-f0-9-]{36}$/.test(entry))
+            continue;
+        const directory = join(c.directory, entry);
+        const s = await lstat(directory);
+        if (!s.isDirectory() || s.isSymbolicLink() || s.uid !== c.uid || (s.mode & 0o077) !== 0)
+            throw new Error("Unsafe recovery transaction directory.");
+        const j = await readState(join(directory, "journal.json"), journalSchema, c.uid);
+        if (!j ||
+            j.id !== entry ||
+            j.name !== c.name ||
+            j.daemon !== daemon ||
+            j.volume !== c.volume ||
+            j.volumeIdentity !== volumeIdentity)
+            continue;
+        const readerName = `slopify-reader-${j.id}`;
+        const reader = await e.inspect(readerName);
+        if (reader) {
+            const transaction = await e.command([
+                "inspect",
+                "--format",
+                '{{index .Config.Labels "io.slopify.reader"}}',
+                reader.id,
+            ]);
+            const source = reader.mounts.find((m) => m.destination === "/source");
+            const bind = reader.mounts.find((m) => m.destination === "/source/projects");
+            if (reader.name !== readerName ||
+                transaction !== j.id ||
+                reader.image !== j.image ||
+                reader.running ||
+                source?.type !== "volume" ||
+                source.name !== j.volume ||
+                source.rw ||
+                (j.sourceBind !== null &&
+                    (bind?.type !== "bind" || bind.source !== j.sourceBind || bind.rw)) ||
+                reader.mounts.some((m) => m !== source &&
+                    !(j.sourceBind !== null && m === bind) &&
+                    !(m.type === "tmpfs" && m.destination === "/data")))
+                throw new Error("Copy reader identity or mounts conflict; recovery material is retained.");
+            await e.command(["rm", reader.id]);
+        }
+        if (j.previous) {
+            const prior = await e.inspect(j.previous.id);
+            if (prior &&
+                [j.previous.name, `${c.name}-previous-${j.id}`].includes(prior.name) &&
+                prior.image === j.previous.image &&
+                prior.user === j.previous.user &&
+                sameMounts(prior.mounts, j.previous.mounts))
+                permitted.add(prior.id);
+        }
+        if (j.candidate) {
+            const candidate = await e.inspect(j.candidate);
+            if (candidate &&
+                [c.name, `${c.name}-failed-${j.id}`].includes(candidate.name) &&
+                candidate.installation === j.installation &&
+                candidate.signature === j.signature)
+                permitted.add(candidate.id);
+        }
+    }
+    await e.claims(c.volume, [...permitted], (container) => legacyRollback(container, c.name));
+}
+// Docker reports a container's mounts in no fixed order, so the recorded shape is compared as
+// a set; comparing the JSON as listed refused this installation's own retained container on
+// some runs.
+function sameMounts(a, b) {
+    const shape = (mounts) => JSON.stringify([...mounts].sort((x, y) => `${x.destination}\0${x.type}\0${x.name}\0${x.source}`.localeCompare(`${y.destination}\0${y.type}\0${y.name}\0${y.source}`)));
+    return shape(a) === shape(b);
+}
+// Launchers before project folders kept each replaced container stopped as a rollback, named
+// `<name>-previous-<YYYYmmddHHMMSS>` with the launcher's label and restart off. Such a container
+// never writes unless someone starts it by hand, which is equally true of the rollbacks this
+// launcher keeps itself, so it does not block an upgrade. Anything running, restartable,
+// unlabelled or otherwise named still does.
+function legacyRollback(container, name) {
+    const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return (!container.running &&
+        container.restart.Name === "no" &&
+        container.signature !== null &&
+        new RegExp(`^${escaped}-previous-\\d{14}$`).test(container.name));
+}

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

@@ -0,0 +1,40 @@
+import { join } from "node:path";
+import { journalSchema, readState, } from "./state.js";
+export async function readCommittedJournal(c, receipt, current) {
+    const j = await readState(join(c.directory, receipt.transaction, "journal.json"), journalSchema, c.uid);
+    if (!j ||
+        j.id !== receipt.transaction ||
+        j.name !== receipt.name ||
+        j.installation !== receipt.installation ||
+        j.daemon !== receipt.daemon ||
+        j.volume !== receipt.volume ||
+        j.volumeIdentity !== receipt.volumeIdentity ||
+        j.destination !== receipt.projects ||
+        j.signature !== receipt.signature ||
+        j.image !== receipt.image ||
+        j.user !== receipt.user ||
+        j.publishedIdentity?.dev !== receipt.directoryIdentity.dev ||
+        j.publishedIdentity.ino !== receipt.directoryIdentity.ino)
+        throw new Error("Committed activation journal is missing or inconsistent.");
+    if (current) {
+        const data = current.mounts.find((m) => m.destination === "/data");
+        const projects = current.mounts.find((m) => m.destination === "/data/projects");
+        const activation = current.mounts.find((m) => m.destination === "/opt/slopify-install");
+        if (current.id !== j.candidate ||
+            current.image !== receipt.image ||
+            current.user !== receipt.user ||
+            current.signature !== receipt.signature ||
+            current.installation !== receipt.installation ||
+            data?.type !== "volume" ||
+            data.name !== receipt.volume ||
+            !data.rw ||
+            projects?.type !== "bind" ||
+            projects.source !== receipt.projects ||
+            !projects.rw ||
+            activation?.type !== "bind" ||
+            activation.source !== join(c.directory, receipt.transaction) ||
+            activation.rw)
+            throw new Error("Committed container identity or mounts differ from its receipt.");
+    }
+    return j;
+}