@gentbajko/slopify 0.5.1 → 0.6.1

package/dist/slices/fonts/discovery.js

@@ -0,0 +1,81 @@
+import { createHash } from "node:crypto";
+import { opendir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { extname, join, posix, win32 } from "node:path";
+import { readFontFile, unavailable } from "./files.js";
+import { readFontMetadata } from "./sfnt.js";
+export function systemFontDirectories(platform, env, home) {
+    if (platform === "win32")
+        return [
+            win32.join(env.WINDIR ?? "C:\\Windows", "Fonts"),
+            ...(env.LOCALAPPDATA ? [win32.join(env.LOCALAPPDATA, "Microsoft", "Windows", "Fonts")] : []),
+        ];
+    if (platform === "darwin")
+        return ["/System/Library/Fonts", "/Library/Fonts", posix.join(home, "Library/Fonts")];
+    return [
+        "/usr/share/fonts",
+        "/usr/local/share/fonts",
+        posix.join(env.XDG_DATA_HOME ?? posix.join(home, ".local/share"), "fonts"),
+        posix.join(home, ".fonts"),
+    ];
+}
+export async function discoverSystemFonts() {
+    return scanFontDirectories(systemFontDirectories(process.platform, process.env, homedir()));
+}
+// Fixed roots only, no symlink traversal. Bounds also cover nested font-manager
+// folders and damaged font files, without making the Settings request unbounded.
+export async function scanFontDirectories(roots) {
+    const pending = [...new Set(roots)].map((path) => ({ path, depth: 0 }));
+    const files = new Set();
+    let entries = 0;
+    for (let at = 0; at < pending.length && entries < 10000 && files.size < 2048; at += 1) {
+        const dir = pending[at];
+        if (dir === undefined)
+            continue;
+        try {
+            for await (const entry of await opendir(dir.path)) {
+                entries += 1;
+                const path = join(dir.path, entry.name);
+                if (entry.isDirectory() && dir.depth < 8)
+                    pending.push({ path, depth: dir.depth + 1 });
+                else if (entry.isFile() &&
+                    [".ttf", ".otf", ".ttc"].includes(extname(entry.name).toLowerCase()))
+                    files.add(path);
+                if (entries >= 10000 || files.size >= 2048)
+                    break;
+            }
+        }
+        catch (error) {
+            if (!unavailable(error))
+                throw error;
+        }
+    }
+    const fonts = [];
+    let bytesRead = 0;
+    for (const path of [...files].sort()) {
+        if (bytesRead >= 256 * 1024 * 1024)
+            break;
+        const bytes = await readFontFile(path);
+        if (bytes === undefined)
+            continue;
+        bytesRead += bytes.length;
+        for (const face of readFontMetadata(bytes) ?? []) {
+            const id = createHash("sha256")
+                .update(path)
+                .update("\0")
+                .update(String(face.index))
+                .digest("hex");
+            fonts.push({
+                id: `system-${id}`,
+                name: face.name,
+                family: face.family,
+                source: "system",
+                path,
+                extension: face.extension,
+                assName: face.assName,
+                faceIndex: face.index,
+            });
+        }
+    }
+    return fonts;
+}

package/dist/slices/fonts/files.js

@@ -0,0 +1,37 @@
+import { constants } from "node:fs";
+import { lstat, open } from "node:fs/promises";
+import { fontMaxBytes } from "./model.js";
+export function unavailable(error) {
+    return (error instanceof Error &&
+        "code" in error &&
+        ["ENOENT", "ENOTDIR", "EACCES", "EPERM", "ELOOP"].includes(String(error.code)));
+}
+export async function readFontFile(path) {
+    try {
+        if (!(await lstat(path)).isFile())
+            return undefined;
+        const file = await open(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+        try {
+            const stat = await file.stat();
+            if (!stat.isFile() || stat.size < 12 || stat.size > fontMaxBytes)
+                return undefined;
+            const bytes = Buffer.alloc(stat.size);
+            let offset = 0;
+            while (offset < bytes.length) {
+                const result = await file.read(bytes, offset, bytes.length - offset, offset);
+                if (result.bytesRead === 0)
+                    return undefined;
+                offset += result.bytesRead;
+            }
+            return bytes;
+        }
+        finally {
+            await file.close();
+        }
+    }
+    catch (error) {
+        if (unavailable(error))
+            return undefined;
+        throw error;
+    }
+}

package/dist/slices/fonts/index.js

@@ -0,0 +1,5 @@
+export { fontIdPattern, isMissingFont, listFonts, resolveFont } from "./catalog.js";
+export { fontMaxBytes } from "./model.js";
+export { previewFont } from "./preview.js";
+export { standaloneFont } from "./sfnt.js";
+export { uploadFont } from "./upload.js";

package/dist/slices/fonts/model.js

@@ -0,0 +1,4 @@
+export const fontMaxBytes = 32 * 1024 * 1024;
+export function fontSummary(font) {
+    return { id: font.id, name: font.name, family: font.family, source: font.source };
+}

package/dist/slices/fonts/preview.js

@@ -0,0 +1,14 @@
+import { missingFont, resolveFont } from "./catalog.js";
+import { readFontFile } from "./files.js";
+import { standaloneFont } from "./sfnt.js";
+export async function previewFont(paths, id) {
+    const font = await resolveFont(paths, id);
+    const bytes = await readFontFile(font.path);
+    const content = bytes === undefined ? undefined : standaloneFont(bytes, font.faceIndex);
+    if (content === undefined)
+        throw missingFont();
+    return {
+        content,
+        contentType: Buffer.from(content).readUInt32BE(0) === 0x4f54544f ? "font/otf" : "font/ttf",
+    };
+}

package/dist/slices/fonts/sfnt.js

@@ -0,0 +1,262 @@
+import { fontMaxBytes } from "./model.js";
+const trueType = 0x00010000;
+const openType = 0x4f54544f;
+const collection = 0x74746366;
+// Metadata only: outlines remain FreeType's responsibility. Every read and allocation
+// is bounded before using file-controlled offsets, lengths or counts.
+export function readFontMetadata(content) {
+    const bytes = Buffer.from(content.buffer, content.byteOffset, content.byteLength);
+    const faces = directories(bytes);
+    if (faces === undefined)
+        return undefined;
+    const result = [];
+    for (const [index, face] of faces.entries()) {
+        const names = fontNames(bytes, face.tables.get("name"));
+        if (names === undefined)
+            return undefined;
+        const family = names.get(1) ?? names.get(16);
+        const name = names.get(4) ?? family;
+        const cff = face.tables.has("CFF ") || face.tables.has("CFF2");
+        const assName = cff ? (names.get(6) ?? family) : (names.get(4) ?? names.get(1));
+        if (!usable(family) || !usable(name) || !usable(assName))
+            return undefined;
+        result.push({
+            family,
+            name,
+            assName,
+            index,
+            extension: bytes.readUInt32BE(0) === collection ? ".ttc" : cff ? ".otf" : ".ttf",
+        });
+    }
+    return result;
+}
+// Browsers do not consistently address individual TTC faces. Repackage just the
+// selected face, retaining its original tables and names, with fresh SFNT checksums.
+export function standaloneFont(content, index) {
+    const bytes = Buffer.from(content.buffer, content.byteOffset, content.byteLength);
+    const face = directories(bytes)?.[index];
+    if (face === undefined || readFontMetadata(content) === undefined)
+        return undefined;
+    if (bytes.readUInt32BE(0) !== collection)
+        return Buffer.from(bytes);
+    const tables = [...face.tables.entries()].filter(([tag]) => tag !== "DSIG");
+    const header = 12 + tables.length * 16;
+    const size = tables.reduce((sum, [, table]) => sum + padded(table.length), header);
+    if (size > fontMaxBytes)
+        return undefined;
+    const result = Buffer.alloc(size);
+    result.writeUInt32BE(bytes.readUInt32BE(face.offset), 0);
+    result.writeUInt16BE(tables.length, 4);
+    const power = Math.floor(Math.log2(tables.length));
+    result.writeUInt16BE(2 ** power * 16, 6);
+    result.writeUInt16BE(power, 8);
+    result.writeUInt16BE(tables.length * 16 - 2 ** power * 16, 10);
+    let offset = header;
+    let head = 0;
+    for (const [index, [tag, table]] of tables.entries()) {
+        const record = 12 + index * 16;
+        result.write(tag, record, 4, "ascii");
+        bytes.copy(result, offset, table.offset, table.offset + table.length);
+        if (tag === "head") {
+            head = offset;
+            result.writeUInt32BE(0, head + 8);
+        }
+        result.writeUInt32BE(checksum(result.subarray(offset, offset + padded(table.length))), record + 4);
+        result.writeUInt32BE(offset, record + 8);
+        result.writeUInt32BE(table.length, record + 12);
+        offset += padded(table.length);
+    }
+    result.writeUInt32BE((0xb1b0afba - checksum(result)) >>> 0, head + 8);
+    return result;
+}
+function directories(bytes) {
+    if (bytes.length < 12 || bytes.length > fontMaxBytes)
+        return undefined;
+    const offsets = [0];
+    if (bytes.readUInt32BE(0) === collection) {
+        const version = bytes.readUInt32BE(4);
+        const count = bytes.readUInt32BE(8);
+        if (![0x00010000, 0x00020000].includes(version) ||
+            count < 1 ||
+            count > 256 ||
+            12 + count * 4 > bytes.length)
+            return undefined;
+        offsets.splice(0);
+        for (let at = 0; at < count; at += 1)
+            offsets.push(bytes.readUInt32BE(12 + at * 4));
+        if (new Set(offsets).size !== offsets.length)
+            return undefined;
+    }
+    const faces = [];
+    for (const offset of offsets) {
+        if (!within(bytes, offset, 12) || ![trueType, openType].includes(bytes.readUInt32BE(offset)))
+            return undefined;
+        const count = bytes.readUInt16BE(offset + 4);
+        if (count < 1 || count > 256 || !within(bytes, offset + 12, count * 16))
+            return undefined;
+        const tables = new Map();
+        for (let at = 0; at < count; at += 1) {
+            const record = offset + 12 + at * 16;
+            const tag = bytes.toString("ascii", record, record + 4);
+            const table = {
+                offset: bytes.readUInt32BE(record + 8),
+                length: bytes.readUInt32BE(record + 12),
+            };
+            if (tables.has(tag) || table.offset % 4 !== 0 || !within(bytes, table.offset, table.length))
+                return undefined;
+            tables.set(tag, table);
+        }
+        const spans = [...tables.values()]
+            .filter((table) => table.length > 0)
+            .toSorted((a, b) => a.offset - b.offset);
+        if (spans.some((table, at) => at > 0 && (spans[at - 1]?.offset ?? 0) + (spans[at - 1]?.length ?? 0) > table.offset))
+            return undefined;
+        const cff = tables.has("CFF ") || tables.has("CFF2");
+        if ((bytes.readUInt32BE(offset) === openType) !== cff || !validTables(bytes, tables))
+            return undefined;
+        faces.push({ offset, tables });
+    }
+    return faces;
+}
+function validTables(bytes, tables) {
+    const minimum = {
+        head: 54,
+        maxp: 6,
+        cmap: 4,
+        hhea: 36,
+        hmtx: 4,
+        name: 6,
+    };
+    for (const [tag, size] of Object.entries(minimum))
+        if ((tables.get(tag)?.length ?? 0) < size)
+            return false;
+    const head = tables.get("head");
+    const maxp = tables.get("maxp");
+    const hhea = tables.get("hhea");
+    const hmtx = tables.get("hmtx");
+    if (!head || !maxp || !hhea || !hmtx)
+        return false;
+    const glyphs = bytes.readUInt16BE(maxp.offset + 4);
+    const metrics = bytes.readUInt16BE(hhea.offset + 34);
+    const units = bytes.readUInt16BE(head.offset + 18);
+    if (bytes.readUInt32BE(head.offset + 12) !== 0x5f0f3cf5 ||
+        units < 16 ||
+        units > 16384 ||
+        glyphs === 0 ||
+        metrics === 0 ||
+        metrics > glyphs ||
+        hmtx.length < metrics * 4 + (glyphs - metrics) * 2)
+        return false;
+    const cff = tables.get("CFF ") ?? tables.get("CFF2");
+    if (!validCmap(bytes, tables.get("cmap")))
+        return false;
+    if (cff)
+        return cff.length >= 4 && [1, 2].includes(bytes[cff.offset] ?? 0);
+    const glyf = tables.get("glyf");
+    const loca = tables.get("loca");
+    const format = bytes.readInt16BE(head.offset + 50);
+    if (!glyf ||
+        !loca ||
+        (format !== 0 && format !== 1) ||
+        loca.length < (glyphs + 1) * (format === 0 ? 2 : 4))
+        return false;
+    let previous = 0;
+    for (let at = 0; at <= glyphs; at += 1) {
+        const next = format === 0
+            ? bytes.readUInt16BE(loca.offset + at * 2) * 2
+            : bytes.readUInt32BE(loca.offset + at * 4);
+        if (next < previous || next > glyf.length)
+            return false;
+        previous = next;
+    }
+    return true;
+}
+function validCmap(bytes, table) {
+    if (!table || table.length < 4 || bytes.readUInt16BE(table.offset) !== 0)
+        return false;
+    const count = bytes.readUInt16BE(table.offset + 2);
+    if (count < 1 || count > 512 || table.length < 4 + count * 8)
+        return false;
+    let supported = false;
+    for (let at = 0; at < count; at += 1) {
+        const offset = bytes.readUInt32BE(table.offset + 4 + at * 8 + 4);
+        if (offset < 4 + count * 8 || offset + 4 > table.length)
+            return false;
+        const format = bytes.readUInt16BE(table.offset + offset);
+        const long = [8, 10, 12, 13].includes(format);
+        if (long && offset + 8 > table.length)
+            return false;
+        const length = format === 14
+            ? offset + 6 <= table.length
+                ? bytes.readUInt32BE(table.offset + offset + 2)
+                : 0
+            : long
+                ? bytes.readUInt32BE(table.offset + offset + 4)
+                : bytes.readUInt16BE(table.offset + offset + 2);
+        if (length < 4 || offset + length > table.length)
+            return false;
+        if ([0, 4, 6, 10, 12, 13].includes(format))
+            supported = true;
+    }
+    return supported;
+}
+function fontNames(bytes, table) {
+    if (!table || table.length < 6)
+        return undefined;
+    const format = bytes.readUInt16BE(table.offset);
+    const count = bytes.readUInt16BE(table.offset + 2);
+    const storage = bytes.readUInt16BE(table.offset + 4);
+    if (format > 1 || count > 4096 || storage < 6 + count * 12 || storage > table.length)
+        return undefined;
+    const names = new Map();
+    for (let at = 0; at < count; at += 1) {
+        const record = table.offset + 6 + at * 12;
+        const platform = bytes.readUInt16BE(record);
+        const encoding = bytes.readUInt16BE(record + 2);
+        const language = bytes.readUInt16BE(record + 4);
+        const id = bytes.readUInt16BE(record + 6);
+        const length = bytes.readUInt16BE(record + 8);
+        const offset = bytes.readUInt16BE(record + 10);
+        if (storage + offset + length > table.length)
+            return undefined;
+        if (![1, 4, 6, 16].includes(id) ||
+            (platform !== 0 && !(platform === 3 && [0, 1, 10].includes(encoding))))
+            continue;
+        if (length === 0 || length > 1024 || length % 2 !== 0)
+            return undefined;
+        const score = (platform === 3 ? 2 : 0) + (language === 0x409 ? 1 : 0);
+        if ((names.get(id)?.score ?? -1) > score)
+            continue;
+        let value;
+        try {
+            value = new TextDecoder("utf-16be", { fatal: true }).decode(bytes.subarray(table.offset + storage + offset, table.offset + storage + offset + length));
+        }
+        catch {
+            return undefined;
+        }
+        names.set(id, { value, score });
+    }
+    return new Map([...names].map(([id, entry]) => [id, entry.value]));
+}
+function usable(value) {
+    return (value !== undefined &&
+        value.length > 0 &&
+        value.length <= 256 &&
+        !value.includes(",") &&
+        ![...value].some((character) => {
+            const point = character.codePointAt(0) ?? 0;
+            return point < 0x20 || (point >= 0x7f && point <= 0x9f);
+        }));
+}
+function within(bytes, offset, length) {
+    return offset >= 0 && length >= 0 && offset <= bytes.length && length <= bytes.length - offset;
+}
+function padded(value) {
+    return Math.ceil(value / 4) * 4;
+}
+function checksum(bytes) {
+    let sum = 0;
+    for (let at = 0; at < bytes.length; at += 4)
+        sum = (sum + bytes.readUInt32BE(at)) >>> 0;
+    return sum;
+}

package/dist/slices/fonts/upload.js

@@ -0,0 +1,40 @@
+import { createHash, randomUUID } from "node:crypto";
+import { lstat, mkdir, rename, rm, writeFile } from "node:fs/promises";
+import { extname, join } from "node:path";
+import { z } from "zod";
+import { fontMaxBytes } from "./model.js";
+import { readFontMetadata } from "./sfnt.js";
+const filename = z
+    .string()
+    .min(1)
+    .max(255)
+    .refine((value) => !value.includes("/") &&
+    !value.includes("\\") &&
+    !value.includes(":") &&
+    ![...value].some((character) => (character.codePointAt(0) ?? 0) < 32));
+export async function uploadFont(paths, input) {
+    if (!filename.safeParse(input.filename).success)
+        return { ok: false, reason: "unsafe-filename" };
+    if (![".ttf", ".otf"].includes(extname(input.filename).toLowerCase()))
+        return { ok: false, reason: "unsupported-format" };
+    if (input.content.byteLength > fontMaxBytes)
+        return { ok: false, reason: "too-large" };
+    const metadata = readFontMetadata(input.content);
+    const face = metadata?.[0];
+    if (face === undefined || metadata?.length !== 1 || face.extension === ".ttc")
+        return { ok: false, reason: "invalid-font" };
+    const id = `uploaded-${createHash("sha256").update(input.content).digest("hex")}`;
+    const root = join(paths.dataDir, "fonts");
+    await mkdir(root, { recursive: true, mode: 0o700 });
+    if (!(await lstat(root)).isDirectory())
+        throw new Error("The font storage directory is unavailable.");
+    const temporary = join(root, `.upload-${randomUUID()}`);
+    try {
+        await writeFile(temporary, input.content, { mode: 0o600, flag: "wx" });
+        await rename(temporary, join(root, `${id}${face.extension}`));
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+    return { ok: true, font: { id, name: face.name, family: face.family, source: "uploaded" } };
+}

package/dist/slices/settings/cli-paths.js

@@ -0,0 +1,98 @@
+import { constants } from "node:fs";
+import { access, stat } from "node:fs/promises";
+import { extname, isAbsolute } from "node:path";
+import { z } from "zod";
+import { cliProbeTimeoutMs, readinessFromProbe } from "./cli-status.js";
+import { providerById } from "./model.js";
+import { readSetting, writeSetting } from "./repo.js";
+export const cliPathMaxLength = 4096;
+const pathSchema = z
+    .string()
+    .trim()
+    .max(cliPathMaxLength)
+    .refine((value) => value === "" || (isAbsolute(value) && !/[\p{Cc}]/u.test(value)));
+const storedPathSchema = z.string().max(cliPathMaxLength).nullable();
+const saves = new WeakMap();
+export function cliPathStatus(db, id) {
+    const provider = providerById(id);
+    if (provider.auth !== "cli")
+        throw new Error(`${id} is not a CLI provider`);
+    const stored = readSetting(db, `cli.path.${id}`);
+    const configured = stored === undefined ? null : storedPathSchema.parse(JSON.parse(stored));
+    return { configured, command: configured ?? provider.binary };
+}
+// Read on each attempt, so a saved path reaches the next invocation without a restart.
+export function cliBinary(db, id) {
+    return cliPathStatus(db, id).command;
+}
+export async function saveCliPath(deps, id, raw) {
+    // A slow version probe must not overwrite a later Save or Reset from another tab.
+    let queue = saves.get(deps.db);
+    if (queue === undefined) {
+        queue = new Map();
+        saves.set(deps.db, queue);
+    }
+    const previous = queue.get(id) ?? Promise.resolve();
+    const next = previous.then(() => save(deps, id, raw));
+    const settled = next.then(() => { }, () => { });
+    queue.set(id, settled);
+    try {
+        return await next;
+    }
+    finally {
+        if (queue.get(id) === settled)
+            queue.delete(id);
+    }
+}
+async function save(deps, id, raw) {
+    const provider = providerById(id);
+    if (provider.auth !== "cli")
+        return { ok: false, message: `${provider.displayName} uses an API key, not a CLI executable.` };
+    const parsed = pathSchema.safeParse(raw);
+    if (!parsed.success)
+        return {
+            ok: false,
+            message: "Enter an absolute executable file path without quotes or arguments, or leave it blank to use PATH.",
+        };
+    const configured = parsed.data === "" ? null : parsed.data;
+    if (configured !== null) {
+        try {
+            if (!(await stat(configured)).isFile())
+                return { ok: false, message: "Choose an executable file, not a directory." };
+            await access(configured, process.platform === "win32" ||
+                [".js", ".mjs", ".cjs"].includes(extname(configured).toLowerCase())
+                ? constants.R_OK
+                : constants.X_OK);
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                "code" in error &&
+                ["ENOENT", "ENOTDIR", "EACCES", "EPERM", "ELOOP"].includes(String(error.code)))
+                return {
+                    ok: false,
+                    message: "That executable file cannot be found or run. Check its path and permissions.",
+                };
+            throw error;
+        }
+    }
+    const command = configured ?? provider.binary;
+    const probed = await deps.probe(command, provider.versionArgs, cliProbeTimeoutMs);
+    const readiness = readinessFromProbe(probed);
+    if (configured !== null && readiness.kind === "cli" && !readiness.installed)
+        return {
+            ok: false,
+            message: probed.error ??
+                `${provider.displayName} did not answer --version successfully within ${cliProbeTimeoutMs / 1000} seconds. Choose its executable file without arguments.`,
+        };
+    writeSetting(deps.db, `cli.path.${id}`, JSON.stringify(configured));
+    return {
+        ok: true,
+        status: {
+            id,
+            family: provider.family,
+            displayName: provider.displayName,
+            readiness,
+            cliPath: { configured, command },
+        },
+    };
+}

package/dist/slices/settings/cli-status.js

@@ -1,24 +1,33 @@
 import { execFile } from "node:child_process";
-// ceiling: readiness is computed at request time, so nothing is cached and a hung CLI costs the
-// settings page this long. Both probes run in parallel, so the page waits 2 s in the worst
-// case. Caching the answer for a few seconds is the upgrade if a slow machine makes the status
-// line flap.
-export const cliProbeTimeoutMs = 2000;
+import { cliCommand } from "../../kernel/cli-command.js";
+// Gemini's Node startup can take several seconds on Windows. Providers are probed in
+// parallel; a hung process is bounded without treating ordinary startup as missing.
+export const cliProbeTimeoutMs = 15_000;
 const probeOutputMax = 64 * 1024;
-// The real probe: an argument array, never a shell string, so nothing in a binary name or an
-// argument can be interpreted as a command. It resolves for every outcome; a missing CLI is an
-// answer, not a failure. ceiling: POSIX only. A Windows install puts `claude` on PATH as a
-// `.cmd` shim, which execFile cannot run without a shell; a shim-aware lookup is the upgrade
-// when Windows is supported.
+// Known Windows package-manager shims are resolved to an executable plus fixed args;
+// user input never becomes a shell command. Missing/unsupported commands mean not ready.
 export function nodeCliProbe(binary, args, timeoutMs) {
+    let command;
+    try {
+        command = cliCommand(binary);
+    }
+    catch (error) {
+        return Promise.resolve({
+            ran: false,
+            stdout: "",
+            error: error instanceof Error ? error.message : "The CLI launcher could not be resolved.",
+        });
+    }
     return new Promise((resolve) => {
-        execFile(binary, [...args], { timeout: timeoutMs, maxBuffer: probeOutputMax, windowsHide: true }, (error, stdout) => {
+        execFile(command.file, [...command.args, ...args], { timeout: timeoutMs, maxBuffer: probeOutputMax, windowsHide: true }, (error, stdout) => {
             resolve(error === null ? { ran: true, stdout } : { ran: false, stdout: "" });
         });
     });
 }
 export async function cliReadiness(probe, provider) {
-    const result = await probe(provider.binary, provider.versionArgs, cliProbeTimeoutMs);
+    return readinessFromProbe(await probe(provider.binary, provider.versionArgs, cliProbeTimeoutMs));
+}
+export function readinessFromProbe(result) {
     if (!result.ran) {
         return { kind: "cli", installed: false };
     }

package/dist/slices/settings/model.js

@@ -8,6 +8,7 @@ export const providerIds = [
     "openrouter",
     "claude-code",
     "codex",
+    "gemini",
     "elevenlabs",
     "openai-tts",
     "cartesia",
@@ -34,6 +35,14 @@ export const providers = [
         binary: "codex",
         versionArgs: ["--version"],
     },
+    {
+        id: "gemini",
+        family: "llm",
+        displayName: "Gemini CLI",
+        auth: "cli",
+        binary: "gemini",
+        versionArgs: ["--version"],
+    },
     { id: "elevenlabs", family: "tts", displayName: "ElevenLabs", auth: "key" },
     { id: "openai-tts", family: "tts", displayName: "OpenAI", auth: "key" },
     { id: "cartesia", family: "tts", displayName: "Cartesia", auth: "key" },

package/dist/slices/settings/readiness.js

@@ -1,19 +1,23 @@
+import { cliPathStatus } from "./cli-paths.js";
 import { cliReadiness } from "./cli-status.js";
 import { providers } from "./model.js";
 import { keyedProviders } from "./repo.js";
 // Every supported provider is listed, keyed or not, found or not, so Play can grey one out with
 // a reason instead of hiding it. A keyed provider is ready when a key is stored; a CLI provider
-// when its binary answers. Readiness is computed per request and nothing about a CLI is stored.
+// when its binary answers. Readiness is computed per request using the latest saved executable override.
 export async function providerStatuses(deps) {
     const keyed = keyedProviders(deps.db);
-    return await Promise.all(providers.map(async (provider) => ({
-        id: provider.id,
-        family: provider.family,
-        displayName: provider.displayName,
-        readiness: provider.auth === "cli"
-            ? await cliReadiness(deps.probe, provider)
-            : keyedReadiness(keyed, provider.id),
-    })));
+    return await Promise.all(providers.map(async (provider) => {
+        const base = { id: provider.id, family: provider.family, displayName: provider.displayName };
+        if (provider.auth !== "cli")
+            return { ...base, readiness: keyedReadiness(keyed, provider.id) };
+        const cliPath = cliPathStatus(deps.db, provider.id);
+        return {
+            ...base,
+            cliPath,
+            readiness: await cliReadiness(deps.probe, { ...provider, binary: cliPath.command }),
+        };
+    }));
 }
 function keyedReadiness(keyed, id) {
     return { kind: "keyed", hasKey: keyed.has(id) };

package/dist/slices/storage/downloads.js

@@ -19,6 +19,8 @@ const contentTypes = {
     ".ogg": "audio/ogg",
     ".opus": "audio/opus",
     ".mp4": "video/mp4",
+    ".srt": "application/x-subrip; charset=utf-8",
+    ".vtt": "text/vtt; charset=utf-8",
 };
 // Leaves room for "-<asset>.<ext>" inside a 255-byte filename, and keeps a download
 // folder readable when a title runs to the 200 characters the schema allows.