@gentbajko/slopify 0.5.1 → 0.7.0

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/narration/live.js

@@ -0,0 +1,21 @@
+export function observeNarration(store, projectId, key, label) {
+    if (store === undefined)
+        return undefined;
+    let sink;
+    return (event) => {
+        switch (event.type) {
+            case "start":
+                sink = store.begin(projectId, key, label);
+                break;
+            case "chunk":
+                sink?.append(event.bytes);
+                break;
+            case "complete":
+                sink?.complete();
+                break;
+            case "interrupted":
+                sink?.interrupt();
+                break;
+        }
+    };
+}

package/dist/slices/narration/run.js

@@ -11,6 +11,7 @@ import { insertOutput, outputsOf } from "../storage/repo.js";
 import { probeDurationMs } from "../video/ffmpeg.js";
 import { chunkNarration, defaultChunking } from "./chunk.js";
 import { joinNarration } from "./concat.js";
+import { observeNarration } from "./live.js";
 // An empty narration source fails the stage immediately with no retries. Thrown from the
 // slice rather than from a provider call, so the attempt wrapper never sees it.
 export const nothingToNarrate = "nothing to narrate";
@@ -31,6 +32,7 @@ const segmentPayload = z.object({
 const chunkDir = "audio-chunks";
 export async function runNarration(deps, context, providers) {
     const { projectId } = context.stage;
+    deps.audioPreviews?.clear(projectId);
     const project = projectById(deps.db, projectId);
     if (project === undefined) {
         throw new Error(`project ${projectId} has no row`);
@@ -110,9 +112,10 @@ async function speakChunks(deps, context, providers, choice, pieces) {
         try {
             const spoken = await providers.forPiece(piece.id).tts({
                 provider: choice.provider,
+                model: choice.model,
                 voiceId: choice.voice,
                 text: carried.text,
-            });
+            }, observeNarration(deps.audioPreviews, projectId, piece.id, total === 1 ? "Body" : `Body part ${piece.idx} of ${total}`));
             write(deps, projectId, file, spoken.bytes);
             // The file is on disk before the row says so: a crash between the two leaves a
             // file the reconcile collects, where the other order would leave a `done` chunk
@@ -180,9 +183,10 @@ async function speakSegments(deps, context, providers, choice, outputs) {
         }
         const spoken = await providers.forPiece(piece.id).tts({
             provider: choice.provider,
+            model: choice.model,
             voiceId: choice.voice,
             text,
-        });
+        }, observeNarration(deps.audioPreviews, projectId, piece.id, segment.category === "intro" ? "Intro" : "Outro"));
         const name = outputFileName(role, 1, ".mp3", "audio");
         write(deps, projectId, name, spoken.bytes);
         // Measured the same way the body is, because the render adds all three and the gaps to
@@ -208,14 +212,13 @@ function segmentPieces(deps, projectId) {
     }
     return piecesOf(deps.db, article.id, "segment");
 }
-// Audio seconds come from the measured duration per segment, never from the text's length:
-// the real duration goes on the row and the video timeline is built from it. No model is
-// named because the TTS port carries none - the same reason `store` above leaves it off.
+// Audio seconds come from the measured duration per segment, never from the text's length.
 function counted(deps, segment, durationMs, choice) {
     deps.count("stage.completed", {
         stage: "audio",
         segment,
         provider: choice.provider,
+        model: choice.model,
         audioSeconds: durationMs / 1000,
     });
 }
@@ -246,9 +249,6 @@ function write(deps, projectId, path, bytes) {
     mkdirSync(dirname(target), { recursive: true, mode: 0o700 });
     writeFileSync(target, bytes, { mode: 0o600 });
 }
-// The provider and the voice are stored with the audio they made. The model is not:
-// the TTS port carries no model, so every request went to the adapter's own, and writing
-// the run's dropdown value here would record something that was never sent.
 function store(deps, projectId, role, path, durationMs, choice) {
     insertOutput(deps.db, {
         id: deps.ids.next(),
@@ -259,7 +259,7 @@ function store(deps, projectId, role, path, durationMs, choice) {
         originalFilename: null,
         bytes: statSync(outputPath(deps.paths, projectId, path)).size,
         durationMs,
-        meta: { provider: choice.provider, voice: choice.voice },
+        meta: { provider: choice.provider, model: choice.model, voice: choice.voice },
         createdAt: deps.clock.now().toISOString(),
     });
 }

package/dist/slices/research/run.js

@@ -53,6 +53,7 @@ async function research(deps, context, providers, choice, brief) {
         provider: choice.provider,
         model: choice.model,
         messages: synthesisMessages(brief, findings),
+        previewLabel: "Writing research notes",
         check: (given) => sourcedAnswer("the synthesis", given.text),
     });
     add(answer.usage);
@@ -89,6 +90,7 @@ async function plan(deps, context, providers, choice, brief, add) {
         provider: choice.provider,
         model: choice.model,
         messages: plannerMessages(brief),
+        previewLabel: "Planning research",
         // An empty answer, or one with no chapter in it, is a failed attempt.
         check: (given) => chaptersFrom(given.text).length === 0 ? "the planner named no chapters" : undefined,
     });
@@ -129,6 +131,7 @@ async function researchChapters(deps, context, providers, choice, brief, chapter
                 provider: choice.provider,
                 model: choice.model,
                 messages: subAgentMessages(brief, kept.title, outline),
+                previewLabel: kept.title,
                 // Grounding is asked for explicitly, so a model without it says so
                 // instead of answering from what it already knows.
                 webSearch: true,

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,9 +8,11 @@ export const providerIds = [
     "openrouter",
     "claude-code",
     "codex",
+    "gemini",
     "elevenlabs",
     "openai-tts",
     "cartesia",
+    "inworld",
     "fal",
     "replicate",
     "openai-image",
@@ -34,9 +36,18 @@ 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" },
+    { id: "inworld", family: "tts", displayName: "Inworld", auth: "key" },
     { id: "fal", family: "image", displayName: "fal.ai", auth: "key" },
     { id: "replicate", family: "image", displayName: "Replicate", auth: "key" },
     { id: "openai-image", family: "image", displayName: "OpenAI", auth: "key" },