@gentbajko/slopify 1.2.1 → 1.4.0

package/README.md

@@ -30,13 +30,19 @@ slopify
 
 Both commands launch the same local app.
 
-For Docker on Linux, use `slopify --docker` or
+For Docker on Linux with systemd, use `slopify --docker` or
 `npx @gentbajko/slopify@latest --docker`. The launcher detects installed Codex,
-Claude Code, and Gemini CLIs and mounts them read-only. It runs in the background,
-restarts with Docker, and keeps your data in `slopify-data`. Run it again after
-upgrading a CLI to refresh its mounts. Add `--port 7070` to change the default port.
-CLI credentials stay separate; sign in once inside the container. See the
-[Docker setup guide](https://github.com/GentBajko/slopify#docker) for login commands.
+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.
+See the [Docker setup guide](https://github.com/GentBajko/slopify#docker) for
+updates and the dedicated helper's status/disable commands.
 
 ## How to use it
 
@@ -91,8 +97,9 @@ Everything lives in one SQLite file and one directory tree under the data direct
 
 ## ffmpeg and the GPL
 
-Slopify renders video with ffmpeg. The `ffmpeg-static` dependency downloads a
-prebuilt binary to `node_modules/ffmpeg-static/` at install time.
+No separate FFmpeg installation is required. The `ffmpeg-static` dependency downloads
+a prebuilt binary to `node_modules/ffmpeg-static/` at install time. Docker includes
+the checked binary, licence and source notice in the image, ready on first launch.
 
 Slopify checks that ffmpeg runs before starting. If the install-time download is
 missing, it downloads the same platform build into `<data-dir>/bin/`, keeping the

package/dist/adapter-registry.js

@@ -1,3 +1,4 @@
+import { codexImage } from "./adapters/image/codex.js";
 import { falImage } from "./adapters/image/fal.js";
 import { googleImage } from "./adapters/image/google.js";
 import { openAiImage } from "./adapters/image/openai.js";
@@ -13,6 +14,7 @@ import { cartesiaTts } from "./adapters/tts/cartesia.js";
 import { elevenLabsTts } from "./adapters/tts/elevenlabs.js";
 import { inworldTts } from "./adapters/tts/inworld.js";
 import { openAiTts } from "./adapters/tts/openai.js";
+import { hostLlmIds } from "./kernel/ports/host-cli.js";
 import { cliBinary } from "./slices/settings/cli-paths.js";
 import { keyForAttempt } from "./slices/settings/keys.js";
 import { providerStatuses } from "./slices/settings/readiness.js";
@@ -60,7 +62,7 @@ export function buildRegistry(deps) {
         ["cartesia", cartesiaTts({ fetch: deps.fetch, key: keyOf("cartesia") })],
         ["inworld", inworldTts({ fetch: deps.fetch, key: keyOf("inworld"), clock: deps.clock })],
     ]);
-    // Four image providers behind one port, each handed the reader for its own key row.
+    // Keyed image providers receive only their own key; Codex uses the shared CLI login.
     // Replicate also takes the clock: `Prefer: wait` gives up after 60 s and the prediction has
     // to be polled, and the wait is spent on the app's clock so a test never sits through one.
     const images = new Map([
@@ -71,14 +73,24 @@ export function buildRegistry(deps) {
         ],
         ["openai-image", openAiImage({ fetch: deps.fetch, key: keyOf("openai-image") })],
         ["google-image", googleImage({ fetch: deps.fetch, key: keyOf("google-image") })],
+        ["codex-image", codexImage({ run: cliFor("codex") })],
     ]);
+    if (deps.hostCli) {
+        for (const id of hostLlmIds)
+            llms.set(id, deps.hostCli.llm(id));
+        images.set("codex-image", deps.hostCli.image);
+    }
     return {
         llm: (id) => resolve(llms, "llm", id),
         tts: (id) => resolve(ttses, "tts", id),
         image: (id) => resolve(images, "image", id),
         // Every supported provider, keyed or not, found or not, so Play
         // can grey one out with a reason instead of hiding it.
-        list: async () => (await providerStatuses({ db: deps.db, probe: deps.probe })).map((status) => ({
+        list: async () => (await providerStatuses({
+            db: deps.db,
+            probe: deps.probe,
+            hostCliStatus: deps.hostCli?.status,
+        })).map((status) => ({
             family: status.family,
             id: status.id,
             name: status.displayName,

package/dist/adapters/host-cli/index.js

@@ -0,0 +1,192 @@
+import { redact } from "../../kernel/log.js";
+import { bridgeLimits, hostFaultSchema, hostFrameSchema, hostHealthSchema, hostImageSchema, hostLlmSchema, hostModelsSchema, hostStatusSchema, } from "../../kernel/ports/host-cli.js";
+import { isProviderError, providerError } from "../../kernel/ports/model.js";
+import { sniffImage } from "../image/bytes.js";
+import { hostRequest, hostUnavailable, readHostBytes, } from "./transport.js";
+export function createHostCliClient(options) {
+    async function request(input) {
+        if (!options.directory)
+            throw hostUnavailable();
+        const response = await hostRequest({ ...input, directory: options.directory });
+        if (response.statusCode !== 200) {
+            try {
+                const parsed = hostFaultSchema.safeParse(JSON.parse((await readHostBytes(response, bridgeLimits.status)).toString("utf8")));
+                if (parsed.success)
+                    throw providerError({ kind: parsed.data.kind, message: redact(parsed.data.message) });
+            }
+            catch (error) {
+                if (isProviderError(error))
+                    throw error;
+            }
+            throw hostUnavailable(input.method === "POST");
+        }
+        return response;
+    }
+    async function metadata(path, schema, signal = AbortSignal.timeout(35_000)) {
+        const response = await request({ path, method: "GET", kind: "metadata", signal });
+        try {
+            if (response.headers["content-type"]?.split(";")[0] !== "application/json")
+                throw hostUnavailable();
+            const bytes = await readHostBytes(response, path.includes("/models/") ? bridgeLimits.models : bridgeLimits.status);
+            return schema.parse(JSON.parse(bytes.toString("utf8")));
+        }
+        catch {
+            throw hostUnavailable();
+        }
+        finally {
+            response.destroy();
+        }
+    }
+    async function ready(signal) {
+        const health = await metadata("/v1/health", hostHealthSchema, signal);
+        if (!health.accepting)
+            throw hostUnavailable();
+    }
+    const models = async (id) => (await metadata(`/v1/models/${id}`, hostModelsSchema)).models.map((model) => ({
+        id: model.id,
+        name: model.name,
+        ...(model.group === undefined ? {} : { group: model.group }),
+        ...(model.thinkingModes === undefined ? {} : { thinkingModes: model.thinkingModes }),
+    }));
+    return {
+        status: async (id) => {
+            try {
+                const status = await metadata(`/v1/status/${id}`, hostStatusSchema);
+                if (status.id !== id)
+                    throw hostUnavailable();
+                return {
+                    id: status.id,
+                    command: status.command,
+                    installed: status.installed,
+                    login: status.login,
+                    ...(status.version === undefined ? {} : { version: status.version }),
+                    ...(status.issueKind === undefined ? {} : { issueKind: status.issueKind }),
+                    ...(status.issue === undefined ? {} : { issue: status.issue }),
+                };
+            }
+            catch {
+                return {
+                    id,
+                    command: id === "claude-code" ? "claude" : id === "codex-image" ? "codex" : id,
+                    installed: false,
+                    login: "unknown",
+                    issueKind: "bridge",
+                    issue: hostUnavailable().message,
+                };
+            }
+        },
+        llm: (id) => ({
+            id,
+            capabilities: { streams: true, reportsUsage: true, webSearch: true },
+            models: () => models(id),
+            complete: async function* (req) {
+                const parsed = hostLlmSchema.safeParse({
+                    model: req.model,
+                    messages: req.messages,
+                    ...(req.thinking === undefined ? {} : { thinking: req.thinking }),
+                    ...(req.webSearch === undefined ? {} : { webSearch: req.webSearch }),
+                });
+                if (!parsed.success)
+                    throw providerError({ kind: "unsupported", message: "Invalid host LLM request." });
+                await ready(req.signal);
+                const response = await request({
+                    path: `/v1/llm/${id}`,
+                    method: "POST",
+                    kind: "llm",
+                    body: Buffer.from(JSON.stringify(parsed.data)),
+                    signal: req.signal,
+                });
+                try {
+                    if (response.headers["content-type"]?.split(";")[0] !== "application/x-ndjson")
+                        throw hostUnavailable(true);
+                    yield* readEvents(response);
+                }
+                catch (error) {
+                    if (isProviderError(error))
+                        throw error;
+                    throw hostUnavailable(true);
+                }
+                finally {
+                    response.destroy();
+                }
+            },
+        }),
+        image: {
+            id: "codex-image",
+            models: () => models("codex-image"),
+            generate: async (req) => {
+                const parsed = hostImageSchema.safeParse({
+                    model: req.model,
+                    prompt: req.prompt,
+                    aspect: req.aspect,
+                });
+                if (!parsed.success)
+                    throw providerError({ kind: "unsupported", message: "Invalid host image request." });
+                await ready(req.signal);
+                const response = await request({
+                    path: "/v1/image",
+                    method: "POST",
+                    kind: "image",
+                    body: Buffer.from(JSON.stringify(parsed.data)),
+                    signal: req.signal,
+                });
+                try {
+                    const mime = response.headers["content-type"];
+                    if (mime !== "image/png" && mime !== "image/jpeg")
+                        throw hostUnavailable(true);
+                    const bytes = await readHostBytes(response, bridgeLimits.image);
+                    if (sniffImage(bytes) !== mime)
+                        throw hostUnavailable(true);
+                    return { bytes, mime };
+                }
+                catch (error) {
+                    if (isProviderError(error))
+                        throw error;
+                    throw hostUnavailable(true);
+                }
+                finally {
+                    response.destroy();
+                }
+            },
+        },
+    };
+}
+async function* readEvents(response) {
+    const decoder = new TextDecoder("utf-8", { fatal: true });
+    let pending = "";
+    let total = 0;
+    let terminal;
+    for await (const bytes of response) {
+        if (!Buffer.isBuffer(bytes))
+            throw hostUnavailable(true);
+        total += bytes.byteLength;
+        if (total > bridgeLimits.stream)
+            throw hostUnavailable(true);
+        pending += decoder.decode(bytes, { stream: true });
+        let newline = pending.indexOf("\n");
+        while (newline !== -1) {
+            const line = pending.slice(0, newline);
+            pending = pending.slice(newline + 1);
+            if (Buffer.byteLength(line) + 1 > bridgeLimits.frame)
+                throw hostUnavailable(true);
+            if (line.trim() !== "") {
+                if (terminal)
+                    throw hostUnavailable(true);
+                const event = hostFrameSchema.parse(JSON.parse(line));
+                if (event.type === "error")
+                    throw providerError({ kind: event.kind, message: redact(event.message) });
+                if (event.type === "done")
+                    terminal = event;
+                else
+                    yield event;
+            }
+            newline = pending.indexOf("\n");
+        }
+        if (Buffer.byteLength(pending) >= bridgeLimits.frame)
+            throw hostUnavailable(true);
+    }
+    pending += decoder.decode();
+    if (!response.complete || pending.trim() !== "" || !terminal)
+        throw hostUnavailable(true);
+    yield terminal;
+}

package/dist/adapters/host-cli/transport.js

@@ -0,0 +1,135 @@
+import { constants } from "node:fs";
+import { open } from "node:fs/promises";
+import { request } from "node:http";
+import { join } from "node:path";
+import { bridgeLimits } from "../../kernel/ports/host-cli.js";
+import { providerError } from "../../kernel/ports/model.js";
+export function hostUnavailable(submitted = false) {
+    return providerError({
+        kind: "unavailable",
+        message: submitted
+            ? "The host CLI connection ended without a reliable result; the result may be uncertain. Review the affected rebuild before retrying."
+            : "Host helper unavailable. Run npx @gentbajko/slopify@latest --docker on the host to set it up or check its service.",
+    });
+}
+async function tokenAt(directory) {
+    const file = await open(join(directory, "token"), constants.O_RDONLY | constants.O_NOFOLLOW);
+    try {
+        const stat = await file.stat();
+        if (!stat.isFile() || stat.size !== 64 || (stat.mode & 0o022) !== 0)
+            throw hostUnavailable();
+        const bytes = Buffer.alloc(65);
+        const { bytesRead } = await file.read(bytes, 0, 65, 0);
+        const value = bytes.subarray(0, bytesRead).toString("utf8");
+        if (!/^[a-f0-9]{64}$/.test(value))
+            throw hostUnavailable();
+        return value;
+    }
+    finally {
+        await file.close();
+    }
+}
+export async function hostRequest(options) {
+    if (options.body && options.body.byteLength > bridgeLimits.request)
+        throw providerError({
+            kind: "unsupported",
+            message: "The host provider request exceeds 16 MiB.",
+        });
+    let token;
+    try {
+        options.signal.throwIfAborted();
+        token = await tokenAt(options.directory);
+    }
+    catch {
+        throw hostUnavailable();
+    }
+    return new Promise((resolve, reject) => {
+        let response;
+        let submitted = false;
+        const req = request({
+            socketPath: join(options.directory, "cli.sock"),
+            path: options.path,
+            method: options.method,
+            agent: false,
+            headers: {
+                authorization: `Bearer ${token}`,
+                "content-type": "application/json",
+                ...(options.body ? { "content-length": options.body.byteLength } : {}),
+            },
+        }, (incoming) => {
+            response = incoming;
+            const maximum = options.kind === "image"
+                ? bridgeLimits.image
+                : options.kind === "llm"
+                    ? bridgeLimits.stream
+                    : options.path.includes("/models/")
+                        ? bridgeLimits.models
+                        : bridgeLimits.status;
+            const advertised = Number(incoming.headers["content-length"] ?? 0);
+            if (!Number.isFinite(advertised) || advertised > maximum) {
+                fail();
+                return;
+            }
+            incoming.once("error", () => { });
+            incoming.once("close", cleanup);
+            resolve(incoming);
+        });
+        const fail = () => {
+            const error = hostUnavailable(submitted);
+            response?.destroy(error);
+            req.destroy(error);
+            reject(error);
+        };
+        const connectTimer = setTimeout(fail, 5000);
+        const deadline = setTimeout(fail, options.kind === "image" ? 300_000 : options.kind === "metadata" ? 35_000 : 120_000);
+        const cleanup = () => {
+            clearTimeout(connectTimer);
+            clearTimeout(deadline);
+            options.signal.removeEventListener("abort", fail);
+        };
+        req.once("socket", (socket) => {
+            socket.once("connect", () => {
+                clearTimeout(connectTimer);
+                submitted = options.method === "POST";
+            });
+        });
+        req.on("error", () => {
+            cleanup();
+            const error = hostUnavailable(submitted);
+            response?.destroy(error);
+            reject(error);
+        });
+        if (options.kind === "llm") {
+            req.on("response", () => clearTimeout(deadline));
+            req.setTimeout(120_000, fail);
+        }
+        options.signal.addEventListener("abort", fail, { once: true });
+        if (options.signal.aborted)
+            fail();
+        else
+            req.end(options.body);
+    });
+}
+export async function readHostBytes(response, maximum) {
+    const chunks = [];
+    let length = 0;
+    try {
+        for await (const value of response) {
+            if (!Buffer.isBuffer(value))
+                throw hostUnavailable();
+            length += value.byteLength;
+            if (length > maximum)
+                throw providerError({
+                    kind: "unavailable",
+                    message: "Host response exceeded its size limit.",
+                });
+            chunks.push(value);
+        }
+        if (!response.complete)
+            throw hostUnavailable();
+        return Buffer.concat(chunks, length);
+    }
+    finally {
+        response.destroy();
+    }
+}

package/dist/adapters/image/codex.js

@@ -0,0 +1,239 @@
+import { closeSync, constants, fstatSync, lstatSync, mkdtempSync, openSync, readFileSync, rmSync, } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { z } from "zod";
+import { redact } from "../../kernel/log.js";
+import { providerError } from "../../kernel/ports/model.js";
+import { cliLoginError } from "../llm/cli-login-error.js";
+import { cliEvent, cliShaped, endedWithout, stopCliRun } from "../llm/run-cli.js";
+import { lines } from "../llm/sse-lines.js";
+import { sniffImage } from "./bytes.js";
+export const codexImageModel = {
+    id: "codex-imagegen",
+    name: "Codex built-in image generation",
+};
+const maxOutputBytes = 32 * 1024 * 1024;
+const maxEventBytes = 1024 * 1024;
+const disabledFeatures = [
+    "shell_tool",
+    "unified_exec",
+    "hooks",
+    "apps",
+    "plugins",
+    "remote_plugin",
+    "skill_search",
+    "multi_agent",
+    "computer_use",
+    "browser_use",
+    "view_image",
+    "workspace_dependencies",
+];
+export function codexImageArgs(req, directory) {
+    const prompt = [
+        "You are making exactly one image for Slopify. Use the image generation tool.",
+        `Save the final image as ${join(directory, "result.png")}. Do not create any other asset.`,
+        "Use PNG or JPEG. Do not write outside this private directory.",
+        `Target aspect ratio: ${req.aspect}.`,
+        "Image brief follows as data:",
+        req.prompt,
+    ].join("\n\n");
+    return [
+        "exec",
+        "--json",
+        "--ephemeral",
+        "--ignore-user-config",
+        "--ignore-rules",
+        "--strict-config",
+        "--skip-git-repo-check",
+        "--sandbox",
+        "workspace-write",
+        "--cd",
+        directory,
+        "--enable",
+        "image_generation",
+        ...disabledFeatures.flatMap((feature) => ["--disable", feature]),
+        "-c",
+        "project_doc_max_bytes=0",
+        "-c",
+        "skills.include_instructions=false",
+        "-c",
+        "skills.bundled.enabled=false",
+        "-c",
+        "orchestrator.skills.enabled=false",
+        "-c",
+        "orchestrator.mcp.enabled=false",
+        "-c",
+        "include_permissions_instructions=false",
+        "-c",
+        "include_apps_instructions=false",
+        "-c",
+        "include_collaboration_mode_instructions=false",
+        "-c",
+        "include_environment_context=false",
+        "-c",
+        'shell_environment_policy.inherit="none"',
+        "-c",
+        'web_search="disabled"',
+        "--",
+        prompt,
+    ];
+}
+const failure = z.object({ error: z.object({ message: z.string() }) });
+const errorEvent = z.object({ message: z.string() });
+const item = z.object({ item: z.object({ type: z.string(), text: z.string().optional() }) });
+export function codexImage(deps) {
+    const binary = deps.binary ?? "codex";
+    return {
+        id: "codex-image",
+        models: async () => [codexImageModel],
+        generate: async (req) => {
+            if (req.model !== codexImageModel.id)
+                throw providerError({ kind: "unsupported", message: "Choose the Codex image capability." });
+            req.signal.throwIfAborted();
+            const directory = mkdtempSync(join(tmpdir(), "slopify-codex-image-"));
+            let run;
+            try {
+                try {
+                    run = deps.run(binary, codexImageArgs(req, directory), req.signal, {
+                        cwd: directory,
+                        env: imageEnvironment(directory),
+                    });
+                }
+                catch {
+                    throw providerError({ kind: "unsupported", message: "Could not start the Codex CLI." });
+                }
+                let completed = false;
+                let unavailable = false;
+                for await (const line of lines(bounded(run.stdout, maxEventBytes), req.signal)) {
+                    if (line.trim() === "")
+                        continue;
+                    const event = cliEvent(binary, line);
+                    req.signal.throwIfAborted();
+                    if (event.type === "turn.completed")
+                        completed = true;
+                    else if (event.type === "turn.failed") {
+                        const message = cliShaped(binary, failure, event.value).error.message;
+                        const login = cliLoginError("codex", message);
+                        if (login)
+                            throw login;
+                        throw providerError({
+                            kind: /refus|content.policy|safety/i.test(message) ? "refusal" : "other",
+                            message: redact(message),
+                        });
+                    }
+                    else if (event.type === "error") {
+                        const message = cliShaped(binary, errorEvent, event.value).message;
+                        const login = cliLoginError("codex", message);
+                        if (login)
+                            throw login;
+                        throw providerError({
+                            kind: /image.generation|image tool|feature.*unavailable/i.test(message)
+                                ? "unsupported"
+                                : "other",
+                            message: redact(message),
+                        });
+                    }
+                    else if (event.type === "item.completed") {
+                        const { item: value } = cliShaped(binary, item, event.value);
+                        if (value.type === "agent_message" &&
+                            /image.generation.*unavailable|cannot generate images|no image tool/i.test(value.text ?? ""))
+                            unavailable = true;
+                    }
+                }
+                req.signal.throwIfAborted();
+                const ended = await run.ended;
+                req.signal.throwIfAborted();
+                if (ended.error !== null)
+                    throw providerError({ kind: "unsupported", message: "Could not start the Codex CLI." });
+                if (ended.code !== 0 || !completed)
+                    throw (cliLoginError("codex", run.stderr()) ??
+                        providerError({
+                            kind: unavailable ? "unsupported" : "other",
+                            message: endedWithout(binary, ended, run.stderr()),
+                        }));
+                if (unavailable)
+                    throw providerError({
+                        kind: "unsupported",
+                        message: "This Codex install cannot generate images.",
+                    });
+                return exactImage(join(directory, "result.png"));
+            }
+            catch (error) {
+                req.signal.throwIfAborted();
+                throw error;
+            }
+            finally {
+                try {
+                    if (run !== undefined)
+                        await stopCliRun(run);
+                }
+                finally {
+                    rmSync(directory, { recursive: true, force: true, maxRetries: 3, retryDelay: 50 });
+                }
+            }
+        },
+    };
+}
+async function* bounded(source, maximum) {
+    let size = 0;
+    for await (const chunk of source) {
+        size += chunk.byteLength;
+        if (size > maximum)
+            throw providerError({
+                kind: "other",
+                message: "Codex wrote too much image progress output.",
+            });
+        yield chunk;
+    }
+}
+function exactImage(path) {
+    const entry = lstatSync(path, { throwIfNoEntry: false });
+    if (entry === undefined)
+        throw providerError({
+            kind: "unsupported",
+            message: "Codex did not save an image at the requested path.",
+        });
+    if (!entry.isFile() || entry.isSymbolicLink() || entry.size === 0 || entry.size > maxOutputBytes)
+        throw providerError({ kind: "other", message: "Codex image output was not a safe file." });
+    let fd;
+    try {
+        fd = openSync(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+        const status = fstatSync(fd);
+        if (!status.isFile() || status.size === 0 || status.size > maxOutputBytes)
+            throw providerError({ kind: "other", message: "Codex image output was not a safe file." });
+        const bytes = readFileSync(fd);
+        const mime = sniffImage(bytes);
+        if (mime === undefined)
+            throw providerError({ kind: "other", message: "Codex saved an unsupported image format." });
+        return { bytes, mime };
+    }
+    finally {
+        if (fd !== undefined)
+            closeSync(fd);
+    }
+}
+function imageEnvironment(directory) {
+    const env = { PWD: directory };
+    const allowed = [
+        "HOME",
+        "PATH",
+        "CODEX_HOME",
+        "XDG_CONFIG_HOME",
+        "XDG_DATA_HOME",
+        "XDG_CACHE_HOME",
+        "TMPDIR",
+        "TEMP",
+        "TMP",
+        "LANG",
+        "LC_ALL",
+        "USER",
+        "LOGNAME",
+        "SYSTEMROOT",
+        "SSL_CERT_FILE",
+        "NODE_EXTRA_CA_CERTS",
+    ];
+    for (const key of allowed)
+        if (process.env[key] !== undefined)
+            env[key] = process.env[key];
+    return env;
+}

package/dist/adapters/llm/claude-code-models.js

@@ -51,6 +51,7 @@ function discoveryEnv() {
         "XDG_CONFIG_HOME",
         "XDG_DATA_HOME",
         "XDG_CACHE_HOME",
+        "CLAUDE_CONFIG_DIR",
         "PATH",
         "PATHEXT",
         "LANG",