@gentbajko/slopify 2.4.0 → 3.0.0

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,
+    };
+}