@gentbajko/slopify 1.2.1 → 1.4.0

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

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { redact } from "../../kernel/log.js";
 import { providerError } from "../../kernel/ports/model.js";
 import { nodeClaudeCodeModels } from "./claude-code-models.js";
+import { cliLoginError } from "./cli-login-error.js";
 import { cliEvent, cliShaped, endedWithout, promptOf, stopCliRun } from "./run-cli.js";
 import { lines } from "./sse-lines.js";
 // The local-agent adapter for Claude Code: spawned non-interactively, authenticated by the
@@ -95,6 +96,9 @@ export function claudeCodeLlm(deps) {
                 }
                 const result = cliShaped(binary, resultEvent, event.value);
                 if (result.is_error === true || result.subtype !== "success") {
+                    const login = cliLoginError("claude-code", result.result ?? result.subtype);
+                    if (login)
+                        throw login;
                     throw providerError({
                         kind: kindOf(result.api_error_status ?? null),
                         message: redact(result.result ?? result.subtype),
@@ -124,6 +128,9 @@ export function claudeCodeLlm(deps) {
         // be reported as the provider failing.
         req.signal.throwIfAborted();
         // The stream ended with no result event at all.
+        const login = cliLoginError("claude-code", run.stderr());
+        if (login)
+            throw login;
         throw providerError({
             kind: "other",
             message: ended === undefined

package/dist/adapters/llm/cli-login-error.js

@@ -0,0 +1,16 @@
+import { providerError } from "../../kernel/ports/model.js";
+export function cliLoginError(provider, text) {
+    if (/invalid api key/i.test(text))
+        return undefined;
+    if (!/not logged in|please (?:run|use)\s+\/login|run\s+codex\s+login|authentication required|(?:access|refresh) token.*(?:expired|could not be refreshed|already used)/i.test(text))
+        return undefined;
+    const command = provider === "claude-code"
+        ? "claude auth login"
+        : provider === "gemini"
+            ? "gemini"
+            : "codex login";
+    return providerError({
+        kind: "missing_key",
+        message: `${provider}: sign in on the machine running the CLI with ${command}, then review the affected rebuild.`,
+    });
+}

package/dist/adapters/llm/codex.js

@@ -4,6 +4,7 @@ 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 "./cli-login-error.js";
 import { nodeCodexModels } from "./codex-models.js";
 import { cliEvent, cliShaped, endedWithout, promptOf, stopCliRun } from "./run-cli.js";
 import { lines } from "./sse-lines.js";
@@ -137,12 +138,18 @@ export function codexLlm(deps) {
                     return;
                 }
                 if (event.type === "turn.failed") {
+                    const login = cliLoginError("codex", cliShaped(binary, turnFailed, event.value).error.message);
+                    if (login)
+                        throw login;
                     throw providerError({
                         kind: "other",
                         message: redact(cliShaped(binary, turnFailed, event.value).error.message),
                     });
                 }
                 if (event.type === "error") {
+                    const login = cliLoginError("codex", cliShaped(binary, errorEvent, event.value).message);
+                    if (login)
+                        throw login;
                     throw providerError({
                         kind: "other",
                         message: redact(cliShaped(binary, errorEvent, event.value).message),
@@ -168,6 +175,9 @@ export function codexLlm(deps) {
         // be reported as the provider failing.
         req.signal.throwIfAborted();
         // The stream ended with neither a completed turn nor a failure.
+        const login = cliLoginError("codex", run.stderr());
+        if (login)
+            throw login;
         throw providerError({
             kind: "other",
             message: ended === undefined

package/dist/catalog/validate.js

@@ -1,3 +1,4 @@
+import { usesNarrationPreparation } from "../slices/admission/rules.js";
 import { isLocalCliProvider } from "../slices/settings/model.js";
 export function modelFields(draft, catalogue) {
     if (!catalogue)
@@ -7,7 +8,8 @@ export function modelFields(draft, catalogue) {
         draft.sources.article === "generate" ||
         draft.sources.thumbnail === "prompt_by_llm" ||
         draft.intro?.mode === "llm" ||
-        draft.outro?.mode === "llm";
+        draft.outro?.mode === "llm" ||
+        usesNarrationPreparation(draft);
     const checks = [
         { field: "llm", family: "llm", choice: draft.llm, needed: needLlm },
         {

package/dist/edge/cli.js

@@ -1,5 +1,8 @@
 #!/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";
@@ -15,16 +18,49 @@ const { values } = parseArgs({
         "data-dir": { type: "string" },
         "no-open": { type: "boolean" },
         docker: { type: "boolean" },
+        "host-cli": { type: "string" },
+        "accept-host-cli": { type: "boolean" },
     },
 });
 try {
+    if ((values["host-cli"] !== undefined || values["accept-host-cli"] !== undefined) &&
+        !values.docker)
+        throw new Error("Host CLI options require --docker.");
+    if (values["host-cli"] !== undefined && values["host-cli"] !== "off")
+        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");
+        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();
+                }
+            },
+        });
+        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 }),
             },
         });

package/dist/edge/docker.js

@@ -0,0 +1,109 @@
+import { mkdir, rmdir } from "node:fs/promises";
+import { join } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { z } from "zod";
+import { installHostPackage } from "../host-cli/install.js";
+import { ensureBridgeToken, hasCode, prepareHostPaths } from "../host-cli/paths.js";
+import { ensureHostService, privateRead, privateWrite } from "../host-cli/service.js";
+import { resolveHostCommand } from "../host-cli/status.js";
+import { hostCliProtocol, hostLlmIds } from "../kernel/ports/host-cli.js";
+export async function prepareDockerHostCli(options) {
+    if (options.disabled)
+        return {};
+    let installed = false;
+    for (const id of hostLlmIds) {
+        try {
+            await resolveHostCommand(id, options.env);
+            installed = true;
+        }
+        catch (error) {
+            if (!hasCode(error, "ENOENT"))
+                throw new Error("Host CLI detection failed. No container was changed.");
+        }
+    }
+    if (!installed)
+        return {};
+    if (process.platform !== "linux")
+        throw new Error("Managed host CLI setup requires Linux/systemd. Use --host-cli=off for API-only Docker.");
+    const uid = process.getuid?.();
+    if (uid === undefined || uid === 0)
+        throw new Error("Run the Docker launcher as your logged-in user, not root; or use --host-cli=off.");
+    const receiptPath = join(options.root, "consent.json");
+    const existing = await privateRead(receiptPath, uid);
+    const receipt = z.object({ version: z.literal(1), automaticStartup: z.literal(true) }).strict();
+    let approved = options.accepted;
+    if (existing !== undefined) {
+        try {
+            approved ||= receipt.safeParse(JSON.parse(existing)).success;
+        }
+        catch {
+            throw new Error("Invalid host helper consent receipt.");
+        }
+    }
+    if (!approved) {
+        if (!options.interactive)
+            throw new Error("Host CLI setup needs confirmation. Use --accept-host-cli to approve, or --host-cli=off for API-only Docker.");
+        approved = await options.prompt("Allow Slopify to run your host Claude Code, Codex and Gemini CLIs using their existing logins? This installs a private helper and enables automatic startup. User lingering keeps your user services running after logout and at boot. Credentials stay on the host. [y/N] ");
+        if (!approved)
+            throw new Error("Host CLI setup declined. The container is unchanged. Use --host-cli=off for API-only Docker.");
+    }
+    const inspect = () => options.runner.exec("docker", [
+        "image",
+        "inspect",
+        "--format",
+        '{{index .Config.Labels "io.slopify.host-cli-protocol"}}',
+        options.image,
+    ], options.signal);
+    let image = await inspect();
+    if (image.code !== 0 || image.stdout.trim() !== String(hostCliProtocol)) {
+        const pulled = await options.runner.exec("docker", ["pull", options.image], options.signal);
+        if (pulled.code !== 0)
+            throw new Error("Could not pull a compatible Docker image. No helper or container was changed.");
+        image = await inspect();
+        if (image.code !== 0 || image.stdout.trim() !== String(hostCliProtocol))
+            throw new Error("This Docker image does not support the host helper. Update the image before retrying.");
+    }
+    const supported = await options.runner.exec("systemctl", ["--user", "list-units", "--no-legend", "--no-pager", "slopify-cli-bridge.service"], options.signal);
+    if (supported.code !== 0)
+        throw new Error("The systemd user service is unavailable. Use a normal Slopify install or --host-cli=off for API-only Docker.");
+    const paths = await prepareHostPaths(options.root);
+    const lock = join(paths.root, "setup.lock");
+    const deadline = Date.now() + 30_000;
+    for (;;) {
+        try {
+            await mkdir(lock, { mode: 0o700 });
+            break;
+        }
+        catch (error) {
+            if (!hasCode(error, "EEXIST"))
+                throw error;
+            if (Date.now() >= deadline)
+                throw new Error("Another host helper setup holds setup.lock. Wait for it to finish; the container is unchanged.");
+            await delay(100, undefined, { signal: options.signal });
+        }
+    }
+    try {
+        await ensureBridgeToken(paths.tokenFile);
+        const installed = await installHostPackage({
+            root: paths.root,
+            version: options.version,
+            runner: options.runner,
+            signal: options.signal,
+        });
+        await ensureHostService({
+            root: paths.root,
+            entry: installed.entry,
+            node: process.execPath,
+            uid,
+            version: options.version,
+            runner: options.runner,
+            signal: options.signal,
+            env: options.env,
+        });
+        await privateWrite(receiptPath, JSON.stringify({ version: 1, automaticStartup: true }));
+        return { directory: paths.share };
+    }
+    finally {
+        await rmdir(lock);
+    }
+}

package/dist/edge/host-cli.js

@@ -0,0 +1,58 @@
+import { constants } from "node:fs";
+import { open } from "node:fs/promises";
+import { join } from "node:path";
+import { parseArgs } from "node:util";
+import { nodeRunCli } from "../adapters/llm/run-cli.js";
+import { hostEnvironmentSchema } from "../host-cli/environment.js";
+import { ensureBridgeToken, prepareHostPaths } from "../host-cli/paths.js";
+import { createHostRuntime } from "../host-cli/runtime.js";
+import { startHostServer } from "../host-cli/server.js";
+import { resolveHostCommand } from "../host-cli/status.js";
+import { readVersion } from "../kernel/version.js";
+import { nodeCliProbe } from "../slices/settings/cli-status.js";
+const { values } = parseArgs({ options: { "state-dir": { type: "string" } }, strict: true });
+if (!values["state-dir"])
+    throw new Error("A host helper state directory is required.");
+const paths = await prepareHostPaths(values["state-dir"]);
+const file = await open(join(paths.root, "host-environment.json"), constants.O_RDONLY | constants.O_NOFOLLOW);
+try {
+    const stat = await file.stat();
+    if (!stat.isFile() ||
+        stat.size > 64 * 1024 ||
+        (stat.mode & 0o077) !== 0 ||
+        (process.getuid && stat.uid !== process.getuid()))
+        throw new Error("Unsafe host environment file.");
+    const buffer = Buffer.alloc(64 * 1024 + 1);
+    const { bytesRead } = await file.read(buffer, 0, buffer.length, 0);
+    if (bytesRead > 64 * 1024)
+        throw new Error("Host environment file is too large.");
+    const environment = hostEnvironmentSchema.parse(JSON.parse(buffer.subarray(0, bytesRead).toString("utf8")));
+    Object.assign(process.env, environment);
+}
+finally {
+    await file.close();
+}
+const server = await startHostServer({
+    directory: paths.share,
+    token: await ensureBridgeToken(paths.tokenFile),
+    version: readVersion(),
+    ports: createHostRuntime({
+        run: nodeRunCli,
+        probe: nodeCliProbe,
+        env: process.env,
+        now: Date.now,
+        resolve: (id) => resolveHostCommand(id, process.env),
+    }),
+});
+process.on("SIGHUP", server.pauseAdmissions);
+process.on("SIGUSR2", server.resumeAdmissions);
+const stop = () => {
+    void server.stop().then(() => {
+        process.exitCode = 0;
+    }, () => {
+        console.error("Host helper shutdown failed.");
+        process.exitCode = 1;
+    });
+};
+process.once("SIGINT", stop);
+process.once("SIGTERM", stop);

package/dist/edge/http/actions.js

@@ -56,7 +56,7 @@ export function actionRoutes(deps) {
         ...reruns,
         runner: deps.runner,
         emit: (projectId, event) => deps.hub.emit(projectId, event),
-        providers: () => providerStatuses({ db: deps.db, probe: deps.probe }),
+        providers: () => providerStatuses({ db: deps.db, probe: deps.probe, hostCliStatus: deps.hostCliStatus }),
         allowsCustomModels: deps.catalogue ? () => false : allowsCustomModel,
         modelsFor: deps.modelsFor ?? (() => Promise.reject(new Error("Model catalog unavailable"))),
     };

package/dist/edge/http/diagnostics.js

@@ -7,7 +7,11 @@ import { providerStatuses } from "../../slices/settings/readiness.js";
  */
 export function diagnosticsRoutes(deps) {
     return new Hono().get("/", async (c) => {
-        const providers = await providerStatuses({ db: deps.db, probe: deps.probe });
+        const providers = await providerStatuses({
+            db: deps.db,
+            probe: deps.probe,
+            hostCliStatus: deps.hostCliStatus,
+        });
         const projectCount = deps.db.prepare("SELECT count(*) AS count FROM projects").get();
         const schema = deps.db.prepare("SELECT max(version) AS version FROM schema_migrations").get();
         c.header("Cache-Control", "no-store");

package/dist/edge/http/host-cli.js

@@ -0,0 +1,247 @@
+import { timingSafeEqual } from "node:crypto";
+import { Hono } from "hono";
+import { bodyLimit } from "hono/body-limit";
+import { stream } from "hono/streaming";
+import { z } from "zod";
+import { sniffImage } from "../../adapters/image/bytes.js";
+import { redact } from "../../kernel/log.js";
+import { bridgeLimits, hostCliIds, hostCliProtocol, hostFrameSchema, hostImageSchema, hostLlmIds, hostLlmSchema, hostModelsSchema, hostStatusSchema, } from "../../kernel/ports/host-cli.js";
+import { isProviderError, providerError } from "../../kernel/ports/model.js";
+export function hostGate() {
+    let accepting = true;
+    let stopped = false;
+    const generation = new Set();
+    const metadata = new Set();
+    return {
+        get active() {
+            return generation.size;
+        },
+        get accepting() {
+            return accepting;
+        },
+        acquire: (kind) => {
+            const set = kind === "generation" ? generation : metadata;
+            if (!accepting || set.size >= bridgeLimits[kind])
+                return undefined;
+            const controller = new AbortController();
+            set.add(controller);
+            return {
+                signal: controller.signal,
+                abort: () => controller.abort(),
+                release: () => {
+                    set.delete(controller);
+                },
+            };
+        },
+        pause: () => {
+            accepting = false;
+        },
+        resume: () => {
+            if (!stopped)
+                accepting = true;
+        },
+        stop: () => {
+            stopped = true;
+            accepting = false;
+            for (const controller of [...generation, ...metadata])
+                controller.abort();
+        },
+    };
+}
+const unavailable = "Host CLI operation did not finish reliably; its result may be uncertain. Review the affected rebuild before retrying.";
+function fault(error, token) {
+    return {
+        type: "error",
+        kind: isProviderError(error) ? error.fault.kind : "unavailable",
+        message: redact(isProviderError(error)
+            ? error.message
+            : "Host helper operation failed. Check the host CLI and rerun the Docker launcher.")
+            .replaceAll(token, "[redacted]")
+            .slice(0, 4096),
+    };
+}
+export function hostCliRoutes(options) {
+    const app = new Hono();
+    const { gate, ports, token } = options;
+    app.use("*", async (c, next) => {
+        const supplied = Buffer.from(c.req.header("authorization") ?? "");
+        const expected = Buffer.from(`Bearer ${token}`);
+        if (supplied.length !== expected.length || !timingSafeEqual(supplied, expected))
+            return c.json({ type: "error", kind: "unavailable", message: "Host helper authorization failed." }, 401);
+        c.header("Cache-Control", "no-store");
+        await next();
+    });
+    app.get("/v1/health", (c) => c.json({
+        protocol: hostCliProtocol,
+        version: options.version,
+        active: gate.active,
+        accepting: gate.accepting,
+    }));
+    app.use("/v1/*", async (c, next) => {
+        const kind = c.req.method === "POST" ? "generation" : "metadata";
+        const job = gate.acquire(kind);
+        if (!job)
+            return c.json({
+                type: "error",
+                kind: "unavailable",
+                message: "The host helper is busy or restarting. Review the rebuild after it is ready.",
+            }, 503);
+        const outgoing = c.env?.outgoing;
+        let responseEnded = !outgoing;
+        let handlerEnded = false;
+        let streaming = false;
+        const releaseIfFinished = () => {
+            if (responseEnded && handlerEnded && !streaming)
+                job.release();
+        };
+        c.set("job", {
+            ...job,
+            holdStream: () => {
+                streaming = true;
+            },
+            release: () => {
+                streaming = false;
+                releaseIfFinished();
+            },
+        });
+        const finish = () => {
+            responseEnded = true;
+            releaseIfFinished();
+        };
+        const close = () => {
+            if (!outgoing?.writableFinished)
+                job.abort();
+            finish();
+        };
+        outgoing?.once("close", close);
+        outgoing?.once("finish", finish);
+        const abort = () => job.abort();
+        c.req.raw.signal.addEventListener("abort", abort, { once: true });
+        try {
+            await next();
+        }
+        finally {
+            c.req.raw.signal.removeEventListener("abort", abort);
+            handlerEnded = true;
+            releaseIfFinished();
+        }
+    });
+    app.use("/v1/*", bodyLimit({
+        maxSize: bridgeLimits.request,
+        onError: (c) => c.json({ type: "error", kind: "unavailable", message: "Host request is too large." }, 413),
+    }));
+    app.get("/v1/status/:provider", async (c) => {
+        const id = z.enum(hostCliIds).safeParse(c.req.param("provider"));
+        if (!id.success)
+            return c.notFound();
+        const status = hostStatusSchema.parse(await ports.status(id.data));
+        const text = JSON.stringify(status);
+        if (Buffer.byteLength(text) > bridgeLimits.status)
+            throw providerError({ kind: "unavailable", message: "Host status exceeded its limit." });
+        return c.json(status);
+    });
+    app.get("/v1/models/:provider", async (c) => {
+        const id = z.enum(hostCliIds).safeParse(c.req.param("provider"));
+        if (!id.success)
+            return c.notFound();
+        const result = hostModelsSchema.parse({
+            models: await (id.data === "codex-image" ? ports.image : ports.llm(id.data)).models(),
+        });
+        if (Buffer.byteLength(JSON.stringify(result)) > bridgeLimits.models)
+            throw providerError({ kind: "unavailable", message: "Host models exceeded their limit." });
+        return c.json(result);
+    });
+    app.post("/v1/llm/:provider", async (c) => {
+        const id = z.enum(hostLlmIds).safeParse(c.req.param("provider"));
+        if (!id.success)
+            return c.notFound();
+        const body = hostLlmSchema.safeParse(await json(c.req.raw));
+        if (!body.success)
+            return invalid(c);
+        const job = c.get("job");
+        job.holdStream();
+        const controller = new AbortController();
+        const signal = AbortSignal.any([job.signal, controller.signal]);
+        let timer = setTimeout(() => controller.abort(), 120_000);
+        let total = 0;
+        let done = false;
+        c.header("Content-Type", "application/x-ndjson");
+        return stream(c, async (output) => {
+            output.onAbort(() => controller.abort());
+            const abort = () => output.abort();
+            signal.addEventListener("abort", abort, { once: true });
+            try {
+                for await (const event of ports.llm(id.data).complete({ ...body.data, signal })) {
+                    signal.throwIfAborted();
+                    clearTimeout(timer);
+                    timer = setTimeout(() => controller.abort(), 120_000);
+                    const parsed = hostFrameSchema.parse(event);
+                    if (done || parsed.type === "error")
+                        throw new Error("Invalid provider stream.");
+                    const frame = `${JSON.stringify(parsed)}\n`;
+                    total += Buffer.byteLength(frame);
+                    if (Buffer.byteLength(frame) > bridgeLimits.frame || total > bridgeLimits.stream)
+                        throw new Error("Host stream exceeded its limit.");
+                    await output.write(frame);
+                    signal.throwIfAborted();
+                    done = parsed.type === "done";
+                }
+                if (!done)
+                    throw providerError({ kind: "unavailable", message: unavailable });
+            }
+            catch (error) {
+                if (!output.aborted)
+                    await output.write(`${JSON.stringify(fault(signal.aborted ? providerError({ kind: "unavailable", message: unavailable }) : error, token))}\n`);
+            }
+            finally {
+                clearTimeout(timer);
+                signal.removeEventListener("abort", abort);
+                controller.abort();
+                job.release();
+            }
+        }, async () => {
+            controller.abort();
+            job.release();
+        });
+    });
+    app.post("/v1/image", async (c) => {
+        const body = hostImageSchema.safeParse(await json(c.req.raw));
+        if (!body.success)
+            return invalid(c);
+        const job = c.get("job");
+        const controller = new AbortController();
+        const signal = AbortSignal.any([job.signal, controller.signal]);
+        const timer = setTimeout(() => controller.abort(), 300_000);
+        try {
+            const result = await ports.image.generate({ ...body.data, signal });
+            if (signal.aborted)
+                throw providerError({ kind: "unavailable", message: unavailable });
+            if (result.bytes.byteLength > bridgeLimits.image || sniffImage(result.bytes) !== result.mime)
+                throw new Error("Invalid host image.");
+            c.header("Content-Type", result.mime);
+            c.header("Content-Length", String(result.bytes.byteLength));
+            return c.body(new Uint8Array(result.bytes));
+        }
+        catch (error) {
+            throw signal.aborted ? providerError({ kind: "unavailable", message: unavailable }) : error;
+        }
+        finally {
+            clearTimeout(timer);
+            controller.abort();
+        }
+    });
+    app.onError((error, c) => c.json(fault(error, token), 503));
+    app.notFound((c) => c.json({ type: "error", kind: "unavailable", message: "Unknown host helper operation or protocol." }, 404));
+    return app;
+}
+async function json(request) {
+    try {
+        return await request.json();
+    }
+    catch {
+        return undefined;
+    }
+}
+function invalid(c) {
+    return c.json({ type: "error", kind: "unavailable", message: "Invalid host provider request." }, 400);
+}

package/dist/edge/http/providers.js

@@ -17,7 +17,11 @@ const keyBody = z.object({ key: z.string().min(1).max(4096) });
 // generated from; see stagingRoutes.
 export function providerRoutes(deps) {
     const keys = { db: deps.db, clock: deps.clock };
-    const readiness = { db: deps.db, probe: deps.probe };
+    const readiness = {
+        db: deps.db,
+        probe: deps.probe,
+        hostCliStatus: deps.hostCliStatus,
+    };
     const catalog = createModelCatalog({
         load: deps.modelsFor ?? (() => Promise.reject(new Error("Model catalog unavailable"))),
         fallback: deps.fallbackModelsFor ?? (() => []),

package/dist/host-cli/environment.js

@@ -0,0 +1,25 @@
+import { z } from "zod";
+const path = z
+    .string()
+    .max(16384)
+    .refine((value) => !/[\p{Cc}]/u.test(value));
+export const hostEnvironmentSchema = z
+    .object({
+    HOME: path,
+    PATH: path,
+    CODEX_HOME: path.optional(),
+    CLAUDE_CONFIG_DIR: path.optional(),
+    XDG_CONFIG_HOME: path.optional(),
+    XDG_DATA_HOME: path.optional(),
+    XDG_CACHE_HOME: path.optional(),
+    SSL_CERT_FILE: path.optional(),
+    NODE_EXTRA_CA_CERTS: path.optional(),
+})
+    .strict();
+export function hostEnvironment(env) {
+    const selected = {};
+    for (const key of Object.keys(hostEnvironmentSchema.shape))
+        if (env[key] !== undefined)
+            selected[key] = env[key];
+    return hostEnvironmentSchema.parse(selected);
+}