@gentbajko/slopify 1.1.1 → 1.2.1

package/README.md

@@ -30,6 +30,14 @@ slopify
 
 Both commands launch the same local app.
 
+For Docker on Linux, 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.
+
 ## How to use it
 
 1. Add provider keys and voices in Settings. They stay in your local Slopify database.
@@ -72,6 +80,7 @@ for account limits. Both model IDs are bundled; Inworld's LLM catalogue does not
 | `--host` | `SLOPIFY_HOST` | `127.0.0.1` |
 | `--data-dir` | `SLOPIFY_DATA_DIR` | `~/.slopify` |
 | `--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 |
 
 There is no login. Binding to anything but `127.0.0.1` hands the app and every key in

package/dist/adapter-registry.js

@@ -36,7 +36,13 @@ export function buildRegistry(deps) {
                 readModels: () => nodeClaudeCodeModels(cliBinary(deps.db, "claude-code")),
             }),
         ],
-        ["codex", codexLlm({ run: cliFor("codex"), readModels: () => nodeCodexModels() })],
+        [
+            "codex",
+            codexLlm({
+                run: cliFor("codex"),
+                readModels: () => nodeCodexModels(process.env, cliBinary(deps.db, "codex")),
+            }),
+        ],
         [
             "gemini",
             geminiLlm({

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

@@ -27,6 +27,8 @@ const responseSchema = z.object({
                 value: modelId,
                 resolvedModel: modelId.optional(),
                 displayName: modelName,
+                description: z.string().max(4096).optional(),
+                disabled: z.boolean().optional(),
                 supportedEffortLevels: z.array(z.string()).max(10).optional(),
             }))
                 .min(1)
@@ -73,27 +75,36 @@ function choices(event, requestId) {
         throw unavailable();
     const models = new Map();
     for (const row of parsed.data.response.response.models) {
+        if (row.disabled)
+            continue;
         const modes = row.supportedEffortLevels?.filter((value) => supportedEfforts.includes(value));
         const thinking = modes?.length ? { thinkingModes: modes } : {};
-        if (!models.has(row.value))
-            models.set(row.value, {
+        const target = row.resolvedModel ?? row.value;
+        const context = /\[([^\]]+)\]/.exec(row.value)?.[1] ?? /\[([^\]]+)\]/.exec(target)?.[1];
+        const key = target.replace(/\[[^\]]+\]/g, "") + (context ? `[${context}]` : "");
+        // Default and Opus can resolve to the same model. Keep the named CLI choice,
+        // preserving its accepted value (including context modifiers) for generation.
+        if (!models.has(key) || models.get(key)?.id === "default")
+            models.set(key, {
                 id: row.value,
-                name: row.resolvedModel === undefined || row.resolvedModel === row.value
-                    ? row.displayName
-                    : `${row.displayName} → ${row.resolvedModel}`,
-                ...thinking,
-            });
-        // Claude advertises stable aliases and their current concrete targets.
-        // Offer both so the user can choose a moving alias or pin a version.
-        if (row.resolvedModel !== undefined && !models.has(row.resolvedModel))
-            models.set(row.resolvedModel, {
-                id: row.resolvedModel,
-                name: `${row.resolvedModel} (exact model)`,
+                name: claudeModelName(target, row.description, row.displayName) +
+                    (context ? ` (${context.toUpperCase()} context)` : ""),
                 ...thinking,
             });
     }
+    if (models.size === 0)
+        throw unavailable();
     return [...models.values()];
 }
+function claudeModelName(target, description, fallback) {
+    const version = /^claude-(opus|sonnet|haiku|fable)-(\d+)(?:-(\d{1,2})(?=-|\[|$))?/i.exec(target);
+    if (version) {
+        const family = version[1] ?? "";
+        return `${family[0]?.toUpperCase()}${family.slice(1)} ${version[2]}${version[3] ? `.${version[3]}` : ""}`;
+    }
+    const advertised = /\b(?:Opus|Sonnet|Haiku|Fable) \d+(?:\.\d+)?\b/i.exec(description ?? "");
+    return advertised?.[0] ?? fallback.replace(/\s*\([^)]*context\)/i, "");
+}
 // The installed CLI has no model-list command; initialize is a no-prompt
 // stream-JSON control exchange. Treat protocol drift as unavailable metadata.
 export async function nodeClaudeCodeModels(binary, timeoutMs = 15_000) {

package/dist/adapters/llm/codex-models.js

@@ -2,6 +2,7 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { z } from "zod";
 import { readCatalogueFile } from "./catalogue-files.js";
+import { codexModelName, nodeCodexServerModels } from "./codex-server-models.js";
 const safeText = z
     .string()
     .trim()
@@ -22,10 +23,11 @@ const model = z.object({
         .max(20)
         .optional(),
 });
-export async function nodeCodexModels(env = process.env) {
+export async function nodeCodexModels(env = process.env, binary = "codex", timeoutMs = 15_000) {
     try {
         const directory = env.CODEX_HOME?.trim() || join(homedir(), ".codex");
-        const source = await readCatalogueFile(join(directory, "models_cache.json"), 8 * 1024 * 1024);
+        const path = env.SLOPIFY_CODEX_MODELS_FILE?.trim() || join(directory, "models_cache.json");
+        const source = await readCatalogueFile(path, 8 * 1024 * 1024);
         const parsed = cache.parse(JSON.parse(source));
         const models = parsed.models
             .flatMap((entry) => {
@@ -41,7 +43,7 @@ export async function nodeCodexModels(env = process.env) {
                     .filter((level) => ["off", "low", "medium", "high", "xhigh"].includes(level));
                 unique.set(item.slug, {
                     id: item.slug,
-                    name: item.display_name ?? item.slug,
+                    name: codexModelName(item.display_name ?? item.slug),
                     ...(thinkingModes?.length ? { thinkingModes } : {}),
                 });
             }
@@ -51,7 +53,12 @@ export async function nodeCodexModels(env = process.env) {
         return [...unique.values()];
     }
     catch {
-        // Do not expose cache contents, home paths or raw JSON errors to the browser.
-        throw new Error("Codex model metadata is unavailable. Open Codex once to refresh its model list, or enter a custom model ID.");
+        try {
+            return await nodeCodexServerModels(binary, env, timeoutMs);
+        }
+        catch {
+            // Do not expose cache contents, home paths or raw JSON errors to the browser.
+            throw new Error("Codex model metadata is unavailable. Check the CLI and refresh, or enter a custom model ID.");
+        }
     }
 }

package/dist/adapters/llm/codex-server-models.js

@@ -0,0 +1,150 @@
+import { spawn } from "node:child_process";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { z } from "zod";
+import { cliCommand } from "../../kernel/cli-command.js";
+const text = z
+    .string()
+    .trim()
+    .min(1)
+    .max(256)
+    .refine((value) => !/[\p{Cc}]/u.test(value));
+const pageSchema = z.object({
+    data: z
+        .array(z.object({
+        model: text.regex(/^\S+$/),
+        displayName: text,
+        hidden: z.boolean().optional(),
+        supportedReasoningEfforts: z
+            .array(z.object({ reasoningEffort: z.string() }))
+            .max(20)
+            .optional(),
+    }))
+        .max(1000),
+    nextCursor: z.string().max(4096).nullish(),
+});
+// model/list is a metadata-only app-server exchange: no thread, turn or tool is started.
+export async function nodeCodexServerModels(binary, env, timeoutMs = 15_000) {
+    const command = cliCommand(binary);
+    const directory = await mkdtemp(join(tmpdir(), "slopify-codex-models-"));
+    const child = spawn(command.file, [...command.args, "app-server", "--listen", "stdio://"], {
+        cwd: directory,
+        env: { ...env, PWD: directory },
+        stdio: ["pipe", "pipe", "pipe"],
+        windowsHide: true,
+        detached: process.platform !== "win32",
+    });
+    child.on("error", () => { });
+    child.stdin.on("error", () => { });
+    child.stderr.resume();
+    const closed = new Promise((resolve) => child.once("close", () => resolve()));
+    function terminate(signal) {
+        if (process.platform !== "win32" && child.pid !== undefined) {
+            try {
+                process.kill(-child.pid, signal);
+                return;
+            }
+            catch {
+                /* The process may already have exited. */
+            }
+        }
+        child.kill(signal);
+    }
+    const timer = setTimeout(() => terminate("SIGKILL"), timeoutMs);
+    const send = (message) => child.stdin.write(`${JSON.stringify(message)}\n`);
+    let expectedId = 1;
+    let pages = 0;
+    let bytes = 0;
+    let buffer = "";
+    const models = new Map();
+    const cursors = new Set();
+    try {
+        send({
+            id: expectedId,
+            method: "initialize",
+            params: {
+                clientInfo: { name: "slopify_model_discovery", version: "1.0" },
+            },
+        });
+        child.stdout.setEncoding("utf8");
+        for await (const piece of child.stdout) {
+            bytes += Buffer.byteLength(piece);
+            if (bytes > 4 * 1024 * 1024)
+                throw new Error("Oversized metadata");
+            buffer += piece;
+            let newline = buffer.indexOf("\n");
+            while (newline >= 0) {
+                const line = buffer.slice(0, newline).trim();
+                buffer = buffer.slice(newline + 1);
+                newline = buffer.indexOf("\n");
+                if (line === "")
+                    continue;
+                const event = z
+                    .object({
+                    id: z.unknown().optional(),
+                    result: z.unknown().optional(),
+                    error: z.unknown().optional(),
+                })
+                    .parse(JSON.parse(line));
+                if (event.id !== expectedId)
+                    continue;
+                if (event.error !== undefined)
+                    throw new Error("Discovery refused");
+                let cursor;
+                if (expectedId === 1) {
+                    send({ method: "initialized" });
+                }
+                else {
+                    const page = pageSchema.parse(event.result);
+                    for (const row of page.data) {
+                        if (row.hidden === true || models.has(row.model))
+                            continue;
+                        const thinkingModes = row.supportedReasoningEfforts
+                            ?.map((item) => item.reasoningEffort)
+                            .filter((effort) => ["off", "low", "medium", "high", "xhigh"].includes(effort));
+                        models.set(row.model, {
+                            id: row.model,
+                            name: codexModelName(row.displayName),
+                            ...(thinkingModes?.length ? { thinkingModes } : {}),
+                        });
+                    }
+                    cursor = page.nextCursor;
+                    if (!cursor) {
+                        if (models.size === 0)
+                            throw new Error("No visible models");
+                        return [...models.values()];
+                    }
+                    if (cursors.has(cursor) || ++pages >= 20)
+                        throw new Error("Invalid pagination");
+                    cursors.add(cursor);
+                }
+                send({
+                    id: ++expectedId,
+                    method: "model/list",
+                    params: { limit: 100, includeHidden: false, ...(cursor ? { cursor } : {}) },
+                });
+            }
+        }
+        throw new Error("Discovery ended before its reply");
+    }
+    finally {
+        clearTimeout(timer);
+        terminate("SIGTERM");
+        let grace;
+        await Promise.race([
+            closed,
+            new Promise((resolve) => {
+                grace = setTimeout(() => {
+                    terminate("SIGKILL");
+                    resolve();
+                }, 500);
+            }),
+        ]);
+        clearTimeout(grace);
+        await rm(directory, { recursive: true, force: true, maxRetries: 3, retryDelay: 50 });
+    }
+}
+export function codexModelName(name) {
+    return name.replace(/^(GPT-\d+(?:\.\d+)?)-/i, "$1 ");
+}

package/dist/adapters/llm/codex.js

@@ -179,7 +179,7 @@ export function codexLlm(deps) {
         id: "codex",
         // Prose arrives as whole messages; other JSONL events carry activity separately.
         capabilities: { streams: true, reportsUsage: true, webSearch: true },
-        models: deps.readModels ?? (() => nodeCodexModels()),
+        models: deps.readModels ?? (() => nodeCodexModels(process.env, binary)),
         complete,
     };
 }

package/dist/adapters/llm/gemini-models.js

@@ -67,9 +67,6 @@ async function bundledModels(entry) {
 }
 function parseGeminiModels(source) {
     const models = new Map();
-    let pro = false;
-    let flash = false;
-    let flashLite = false;
     // Read literal model constants only. Never import or execute an
     // installed package, parse comments as entries, or inspect login/settings.
     const declarations = /^(?:export\s+)?(?:const|let|var)\s+([A-Z][A-Z0-9_]*)\s*=\s*(['"])([^'"\r\n]+)\2\s*;/gm;
@@ -81,27 +78,34 @@ function parseGeminiModels(source) {
             id === undefined ||
             !name.includes("MODEL") ||
             name.includes("EMBEDDING") ||
-            !/^(?:gemini|gemma)-[a-z0-9.-]+$/.test(id))
+            !/^gemini-\d+(?:\.\d+)?-(?:pro|flash|flash-lite)(?:-preview(?:-\d{2}-\d{2})?)?$/.test(id))
             continue;
-        if (!/^(?:(?:PREVIEW|DEFAULT|SECONDARY)_GEMINI_|GEMMA_)/.test(name))
+        // SECONDARY and CUSTOM_TOOLS constants are routing aliases, not separate
+        // picker choices. Gemma and embedding models use different availability rules.
+        // In 0.61+, DEFAULT_FLASH points at a BASE constant while new releases
+        // use LATEST constants. Read both literal sources without evaluating JS.
+        if (!/^(?:PREVIEW|DEFAULT|BASE|LATEST)_GEMINI_/.test(name) || name.includes("CUSTOM_TOOLS"))
             continue;
-        models.set(id, { id, name: id });
-        if (name.includes("FLASH_LITE") || id.includes("flash-lite"))
-            flashLite = true;
-        else if (name.includes("FLASH") || id.includes("flash"))
-            flash = true;
-        else if (name.includes("PRO") || id.includes("-pro"))
-            pro = true;
+        const parts = /^gemini-(\d+(?:\.\d+)?)-(pro|flash-lite|flash)/.exec(id);
+        if (!parts)
+            continue;
+        const tier = parts[2] === "pro" ? "Pro" : parts[2] === "flash-lite" ? "Flash-Lite" : "Flash";
+        models.set(id, {
+            id,
+            name: `Gemini ${parts[1]} ${tier}${id.includes("-preview") ? " (Preview)" : ""}`,
+        });
     }
     if (models.size === 0)
         return [];
-    return [
-        { id: "auto", name: "Gemini Auto (CLI default)" },
-        ...(pro ? [{ id: "pro", name: "Gemini Pro (CLI alias)" }] : []),
-        ...(flash ? [{ id: "flash", name: "Gemini Flash (CLI alias)" }] : []),
-        ...(flashLite ? [{ id: "flash-lite", name: "Gemini Flash-Lite (CLI alias)" }] : []),
-        ...models.values(),
-    ];
+    const sorted = [...models.values()].sort((a, b) => b.id.localeCompare(a.id, "en", { numeric: true }));
+    const tiers = new Set();
+    const choices = sorted.map((model) => {
+        const tier = /-(pro|flash-lite|flash)(?:-|$)/.exec(model.id)?.[1] ?? model.id;
+        const group = tiers.has(tier) ? "Other versions" : "Latest in installed CLI";
+        tiers.add(tier);
+        return { ...model, group };
+    });
+    return [{ id: "auto", name: "Automatic (CLI default)" }, ...choices];
 }
 async function executablePath(binary) {
     if (isAbsolute(binary) || /[\\/]/.test(binary))

package/dist/edge/cli.js

@@ -1,4 +1,6 @@
 #!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
 import { parseArgs } from "node:util";
 import { configFrom } from "../kernel/config/index.js";
 import { readVersion } from "../kernel/version.js";
@@ -12,9 +14,24 @@ const { values } = parseArgs({
         host: { type: "string" },
         "data-dir": { type: "string" },
         "no-open": { type: "boolean" },
+        docker: { type: "boolean" },
     },
 });
 try {
+    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 result = spawnSync("bash", [fileURLToPath(new URL("../../scripts/docker-run.sh", import.meta.url))], {
+            stdio: "inherit",
+            env: {
+                ...process.env,
+                ...(values.port === undefined ? {} : { SLOPIFY_DOCKER_HOST_PORT: values.port }),
+            },
+        });
+        if (result.error)
+            throw result.error;
+        process.exit(result.status ?? 1);
+    }
     const config = configFrom(values, process.env);
     const forwarded = await forwardManagedUpdate(config.dataDir, readVersion(), process.argv.slice(2));
     if (forwarded !== undefined)

package/dist/main.js

@@ -220,12 +220,16 @@ export async function boot(config) {
             currentVersion: version,
             previousUpdateFailed: process.env.SLOPIFY_UPDATE_FAILED === "1",
             now: () => Date.now(),
-            latest: () => publishedVersion(globalThis.fetch),
-            unsupported: () => !existsSync(oldEntry) || !existsSync(workerEntry)
-                ? "Run Slopify from its installed package to use in-app updates."
-                : npm === undefined
-                    ? "npm is unavailable. Install Node.js with npm to use in-app updates."
-                    : undefined,
+            latest: () => process.env.SLOPIFY_DISABLE_UPDATES === "1"
+                ? Promise.resolve(version)
+                : publishedVersion(globalThis.fetch),
+            unsupported: () => process.env.SLOPIFY_DISABLE_UPDATES === "1"
+                ? "This container is updated by pulling a new image and recreating it."
+                : !existsSync(oldEntry) || !existsSync(workerEntry)
+                    ? "Run Slopify from its installed package to use in-app updates."
+                    : npm === undefined
+                        ? "npm is unavailable. Install Node.js with npm to use in-app updates."
+                        : undefined,
             busy: () => updateDb.prepare("SELECT 1 FROM stages WHERE state = 'running' LIMIT 1").get() !==
                 undefined ||
                 updateDb

package/dist/slices/settings/models.js

@@ -82,9 +82,9 @@ function uniqueModels(models) {
 }
 function catalogNotice(provider) {
     const notices = {
-        codex: "Models come from Codex's local catalogue. Open Codex to refresh that catalogue, then refresh this list.",
-        gemini: "Models and aliases come from the installed Gemini CLI. Update that CLI to discover newer models.",
-        "claude-code": "These aliases follow Claude Code's model families. You can also enter an exact model ID.",
+        codex: "Models come from your Codex installation. Refresh to check again.",
+        gemini: "Models come from your installed Gemini CLI, not an account access check. Missing a new model? Update Gemini CLI, rerun the Docker launcher if applicable, then refresh this list.",
+        "claude-code": "Models come from Claude Code. Missing a new model? Update Claude Code, rerun the Docker launcher if applicable, then refresh this list. You can also enter an exact model ID.",
         inworld: "These are Inworld’s documented TTS models. You can also enter a compatible model ID.",
         cartesia: "Cartesia has no model-list API. These are bundled compatible choices; you can enter a newer model ID.",
         fal: "These models have input formats supported by Slopify's fal adapter.",