@gentbajko/slopify 3.23.0 → 3.25.0

package/dist/web/index.html

@@ -6,7 +6,7 @@
     <meta name="viewport" content="width=device-width, initial-scale=1" />
     <meta name="color-scheme" content="dark light" />
     <title>Slopify</title>
-    <script type="module" crossorigin src="/assets/index-D4ikiEys.js"></script>
+    <script type="module" crossorigin src="/assets/index-D8LqNsCl.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-BadsoORk.css">
   </head>
   <body>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gentbajko/slopify",
-  "version": "3.23.0",
+  "version": "3.25.0",
   "description": "Turn a prompt into a finished video, locally, with your own provider keys",
   "license": "Apache-2.0",
   "author": "Gent Bajko",
@@ -41,7 +41,6 @@
     "onnxruntime-web": "1.30.0",
     "remark": "^15.0.1",
     "remark-gfm": "^4.0.1",
-    "strip-json-comments": "^5.0.3",
     "strip-markdown": "^6.0.0",
     "ulid": "^3.0.2",
     "yaml": "^2.9.1",

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

@@ -1,127 +0,0 @@
-import { constants } from "node:fs";
-import { access, realpath } from "node:fs/promises";
-import { delimiter, dirname, isAbsolute, join } from "node:path";
-import { cliCommand } from "../../kernel/cli-command.js";
-import { readCatalogueFile } from "./catalogue-files.js";
-export async function nodeGeminiModels(binary) {
-    try {
-        const command = cliCommand(binary);
-        const entry = await executablePath(command.args[0] ?? command.file);
-        const candidates = new Set();
-        let directory = dirname(entry);
-        // npm and bun can install the core package nested under gemini-cli or
-        // hoisted beside it. Resolve the configured executable's symlinks first.
-        for (let depth = 0; depth < 10; depth += 1) {
-            const suffix = "gemini-cli-core/dist/src/config/models.js";
-            candidates.add(join(directory, "node_modules/@google", suffix));
-            candidates.add(join(directory, suffix));
-            const parent = dirname(directory);
-            if (parent === directory)
-                break;
-            directory = parent;
-        }
-        for (const candidate of candidates) {
-            try {
-                const models = parseGeminiModels(await readCatalogueFile(candidate, 256 * 1024));
-                if (models.length > 1)
-                    return models;
-            }
-            catch {
-                // A candidate is an optional package layout, not the final discovery result.
-            }
-        }
-        // Recent Gemini CLI releases ship only bundled chunks. Follow the entry
-        // point's literal chunk imports and read their model constants as text.
-        const bundled = await bundledModels(entry);
-        if (bundled.length > 1)
-            return bundled;
-        throw new Error("No installed model metadata");
-    }
-    catch {
-        throw new Error("Slopify could not get the model list from the Gemini CLI. Check the CLI is installed (Settings → Providers), then refresh the list, or type a model name the Gemini CLI accepts.");
-    }
-}
-async function bundledModels(entry) {
-    const source = await readCatalogueFile(entry, 256 * 1024);
-    const imports = new Set();
-    for (const match of source.matchAll(/\b(?:from\s+|import\s*)["']\.\/(chunk-[A-Za-z0-9-]+\.js)["']/g)) {
-        if (match[1] !== undefined)
-            imports.add(match[1]);
-    }
-    if (imports.size === 0 || imports.size > 32)
-        return [];
-    for (const name of imports) {
-        try {
-            const source = await readCatalogueFile(join(dirname(entry), name), 24 * 1024 * 1024);
-            if (!source.includes("packages/core/dist/src/config/models.js"))
-                continue;
-            const models = parseGeminiModels(source);
-            if (models.length > 1)
-                return models;
-        }
-        catch {
-            // Other chunks can be absent or too large; do not execute them.
-        }
-    }
-    return [];
-}
-function parseGeminiModels(source) {
-    const models = new Map();
-    // 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;
-    const uncommented = source.replace(/\/\*[\s\S]*?\*\//g, "");
-    for (const match of uncommented.matchAll(declarations)) {
-        const name = match[1];
-        const id = match[3];
-        if (name === undefined ||
-            id === undefined ||
-            !name.includes("MODEL") ||
-            name.includes("EMBEDDING") ||
-            !/^gemini-\d+(?:\.\d+)?-(?:pro|flash|flash-lite)(?:-preview(?:-\d{2}-\d{2})?)?$/.test(id))
-            continue;
-        // 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;
-        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 [];
-    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))
-        return realpath(binary);
-    const path = Object.entries(process.env).find(([key]) => key.toLowerCase() === "path")?.[1] ?? "";
-    for (const directory of path.split(delimiter).slice(0, 128)) {
-        if (directory === "")
-            continue;
-        const candidate = join(directory.replace(/^"|"$/g, ""), binary);
-        try {
-            await access(candidate, constants.X_OK);
-            return await realpath(candidate);
-        }
-        catch {
-            // Continue normal PATH lookup; no process is launched for discovery.
-        }
-    }
-    throw new Error("Gemini executable was not found");
-}

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

@@ -1,135 +0,0 @@
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { homedir, tmpdir } from "node:os";
-import { join } from "node:path";
-import stripJsonComments from "strip-json-comments";
-import { z } from "zod";
-import { providerError } from "../../kernel/ports/model.js";
-import { documentServerName, documentTool } from "./document-workspace.js";
-// Gemini 0.61 rejects non-root system settings and null context objects. Use a
-// request-owned CLI home instead. OAuth reads the host's existing credential file
-// through its supported ADC fallback; settings, hooks and memory are not inherited.
-export function geminiWorkspace(webSearch, request, documents, env = process.env) {
-    const directory = mkdtempSync(join(tmpdir(), "slopify-gemini-"));
-    try {
-        const state = join(directory, ".gemini");
-        mkdirSync(state, { mode: 0o700 });
-        const settings = join(state, "settings.json");
-        const originalState = join(env.GEMINI_CLI_HOME || env.HOME || env.USERPROFILE || homedir(), ".gemini");
-        let selectedType;
-        const originalSettings = join(originalState, "settings.json");
-        if (existsSync(originalSettings))
-            try {
-                selectedType = z
-                    .object({
-                    security: z
-                        .object({
-                        auth: z.object({ selectedType: z.string().max(128).optional() }).optional(),
-                    })
-                        .optional(),
-                })
-                    .parse(JSON.parse(stripJsonComments(readFileSync(originalSettings, "utf8")))).security
-                    ?.auth?.selectedType;
-            }
-            catch {
-                throw providerError({
-                    kind: "unavailable",
-                    message: "Slopify could not read the Gemini CLI's settings file (settings.json in the .gemini folder of your home directory), which says how it signs in. Fix or remove that file, run gemini in a terminal to sign in again, then use Try again.",
-                });
-            }
-        const oauth = join(originalState, "oauth_creds.json");
-        const system = join(directory, "writing.md");
-        const trust = join(directory, "trusted-folders.json");
-        const mcpAllowlist = documents
-            ? documentServerName
-            : `slopify-disabled-${directory.split(/[\\/]/).at(-1)}`;
-        writeFileSync(settings, JSON.stringify({
-            ...(selectedType ? { security: { auth: { selectedType } } } : {}),
-            ...(request?.thinkingConfig
-                ? {
-                    modelConfigs: {
-                        customOverrides: [
-                            {
-                                match: { model: request.model },
-                                modelConfig: {
-                                    generateContentConfig: {
-                                        thinkingConfig: {
-                                            ...(request.thinkingConfig.level === undefined
-                                                ? {}
-                                                : { thinkingLevel: request.thinkingConfig.level }),
-                                            ...(request.thinkingConfig.budget === undefined
-                                                ? {}
-                                                : { thinkingBudget: request.thinkingConfig.budget }),
-                                        },
-                                    },
-                                },
-                            },
-                        ],
-                    },
-                }
-                : {}),
-            tools: {
-                core: webSearch ? ["google_web_search"] : [],
-                allowed: webSearch ? ["google_web_search"] : [],
-                discoveryCommand: "",
-                callCommand: "",
-                enableHooks: false,
-            },
-            mcp: { allowed: [mcpAllowlist], serverCommand: "" },
-            ...(documents
-                ? {
-                    mcpServers: {
-                        [documentServerName]: {
-                            command: documents.command,
-                            args: documents.args,
-                            trust: true,
-                            includeTools: [documentTool],
-                        },
-                    },
-                }
-                : {}),
-            context: {
-                fileName: "SLOPIFY_NO_CONTEXT.md",
-                includeDirectories: [],
-                loadMemoryFromIncludeDirectories: false,
-            },
-            experimental: { codebaseInvestigatorSettings: { enabled: false } },
-            hooks: {},
-            hooksConfig: { enabled: false },
-            skills: { enabled: false },
-            ide: { enabled: false },
-            telemetry: { enabled: false },
-            privacy: { usageStatisticsEnabled: false },
-            advanced: { autoConfigureMemory: false },
-        }), { mode: 0o600 });
-        writeFileSync(system, "You are the writing and research component of Slopify, a video creation app. " +
-            "Write the requested articles, narration, research notes or image prompts. " +
-            "Follow the topic, language, tone, length and format. Return only the requested content. " +
-            "Use web search only when available and useful. Never read or modify other local files. " +
-            (documents ? "Use only the supplied research MCP tool to read request documents. " : "") +
-            "A backslash immediately before @ escapes a literal @ in the supplied text.\n", { mode: 0o600 });
-        writeFileSync(trust, JSON.stringify({ [directory]: "TRUST_FOLDER" }), { mode: 0o600 });
-        return {
-            mcpAllowlist,
-            options: {
-                cwd: directory,
-                env: {
-                    ...env,
-                    GEMINI_CLI_HOME: directory,
-                    ...(selectedType === "oauth-personal" && existsSync(oauth)
-                        ? { GOOGLE_APPLICATION_CREDENTIALS: oauth }
-                        : {}),
-                    GEMINI_CLI_TRUSTED_FOLDERS_PATH: trust,
-                    NO_BROWSER: "true",
-                    GEMINI_SYSTEM_MD: system,
-                    GEMINI_WRITE_SYSTEM_MD: "false",
-                    GEMINI_CLI_NO_RELAUNCH: "true",
-                },
-            },
-            remove: () => rmSync(directory, { recursive: true, force: true }),
-        };
-    }
-    catch (error) {
-        rmSync(directory, { recursive: true, force: true });
-        throw error;
-    }
-}

package/dist/adapters/llm/gemini.js

@@ -1,168 +0,0 @@
-import { z } from "zod";
-import { redact } from "../../kernel/log.js";
-import { providerError } from "../../kernel/ports/model.js";
-import { cliCheck, cliName, cliReported } from "../explain.js";
-import { documentWorkspace } from "./document-workspace.js";
-import { nodeGeminiModels } from "./gemini-models.js";
-import { geminiWorkspace } from "./gemini-workspace.js";
-import { noImages } from "./image-workspace.js";
-import { cliEvent, cliInput, cliShaped, deliveredInput, endedWithout, promptOf, stopCliRun, stuckCli, } from "./run-cli.js";
-import { lines } from "./sse-lines.js";
-export const geminiBinary = "gemini";
-// Verified against installed Gemini CLI 0.16.0's config/nonInteractiveCli sources.
-// Its --allowed-tools flag bypasses approval; tools.core in the isolated settings
-// actually restricts discovery. Never request yolo/auto_edit.
-export function geminiArgs(req, mcpAllowlist) {
-    return [
-        "--output-format",
-        "stream-json",
-        "--approval-mode",
-        "default",
-        "--extensions",
-        "none",
-        "--allowed-mcp-server-names",
-        mcpAllowlist,
-        ...(req.webSearch === true ? ["--allowed-tools", "google_web_search"] : []),
-        ...(req.model === "" ? [] : ["--model", req.model]),
-        "-p",
-        "Produce the requested content from the supplied conversation on stdin.",
-    ];
-}
-const messageSchema = z.object({
-    role: z.string(),
-    content: z.string(),
-    delta: z.boolean().optional(),
-});
-const errorSchema = z.object({ severity: z.string(), message: z.string() });
-const resultSchema = z.object({
-    status: z.string(),
-    error: z.object({ message: z.string(), type: z.string().optional() }).optional(),
-    stats: z.object({ input_tokens: z.number(), output_tokens: z.number() }).optional(),
-});
-export function geminiLlm(deps) {
-    const binary = deps.binary ?? geminiBinary;
-    async function* complete(req) {
-        req.signal.throwIfAborted();
-        // Its CLI has no image flag, and `@file` inclusion would need a file tool this adapter keeps off.
-        if (req.images?.length)
-            throw noImages("the Gemini CLI");
-        const documents = documentWorkspace(req.documents);
-        let workspace;
-        let run;
-        let ended;
-        try {
-            workspace = geminiWorkspace(req.webSearch === true, req, documents, deps.env ?? process.env);
-            run = deps.run(binary, geminiArgs(req, workspace.mcpAllowlist), req.signal, {
-                ...workspace.options,
-                stdin: cliInput(`Produce the requested content from this conversation:\n\n${[documents?.instructions, promptOf(req.messages)].filter(Boolean).join("\n\n").replaceAll("@", "\\@")}`),
-            });
-            for await (const line of lines(authChecked(run.stdout), req.signal)) {
-                if (line.trim() === "")
-                    continue;
-                const event = cliEvent(binary, line);
-                yield { type: "activity" };
-                req.signal.throwIfAborted();
-                if (event.type === "message") {
-                    const message = cliShaped(binary, messageSchema, event.value);
-                    if (message.role === "assistant" && message.content !== "")
-                        yield { type: "delta", text: message.content };
-                }
-                else if (event.type === "error") {
-                    const error = cliShaped(binary, errorSchema, event.value);
-                    if (error.severity !== "warning")
-                        throw failure(binary, error.message);
-                }
-                else if (event.type === "result") {
-                    const result = cliShaped(binary, resultSchema, event.value);
-                    if (result.status !== "success")
-                        throw failure(binary, result.error?.message ?? result.status);
-                    await deliveredInput(run);
-                    documents?.verifyRead();
-                    yield {
-                        type: "done",
-                        usage: result.stats === undefined
-                            ? null
-                            : {
-                                inputTokens: result.stats.input_tokens,
-                                outputTokens: result.stats.output_tokens,
-                            },
-                        finishReason: null,
-                    };
-                    return;
-                }
-            }
-        }
-        catch (error) {
-            req.signal.throwIfAborted();
-            throw error;
-        }
-        finally {
-            try {
-                if (run !== undefined)
-                    ended = await stopCliRun(run);
-            }
-            finally {
-                documents?.remove();
-                workspace?.remove();
-            }
-        }
-        req.signal.throwIfAborted();
-        if (run === undefined)
-            throw failure(binary, "", `The ${cliName(binary)} could not be started. Check it is installed and set up in Settings → Providers, then use Try again.`);
-        if (authRequired(run.stderr()))
-            throw authFailure();
-        throw failure(binary, run.stderr(), ended === undefined ? stuckCli(binary) : endedWithout(binary, ended, run.stderr()));
-    }
-    return {
-        id: "gemini",
-        capabilities: { streams: true, reportsUsage: true, webSearch: true },
-        models: deps.readModels ?? (() => nodeGeminiModels(binary)),
-        complete,
-    };
-}
-// `message` is what the CLI said, read for the two failures that need the user's hand;
-// `sentence` replaces the default wording when Slopify already knows what happened.
-function failure(binary, message, sentence) {
-    if (/(?:#?3501\b|do not have a valid licen[cs]e of this product)/i.test(message)) {
-        return providerError({
-            kind: "unsupported",
-            message: "Google refused the Gemini CLI because the signed-in account has no licence for it (#3501). Update the Gemini CLI, run gemini in a terminal to sign in again, then use Try again; for a work or school account, ask your administrator for a Gemini licence.",
-        });
-    }
-    // The daily allowance of a signed-in Gemini plan. The CLI names no reset time, so the wait
-    // checks again later; a per-minute quota is an ordinary rate limit and is retried as one.
-    if (/(?:daily|per.day).{0,40}quota|quota.{0,40}(?:daily|per.day)/i.test(message)) {
-        return providerError({
-            kind: "rate_limit",
-            message: `Your Gemini plan's daily quota is used up (the Gemini CLI said: ${redact(message)}). Slopify waits and tries again later by itself.`,
-            planLimit: { account: "gemini", resetsAt: null },
-        });
-    }
-    return authRequired(message)
-        ? authFailure()
-        : providerError({
-            kind: "other",
-            message: sentence ?? cliReported(binary, redact(message), cliCheck(binary)),
-        });
-}
-function authRequired(message) {
-    return /Code Assist login required|authorize the application|authorization code|Please set an Auth method|re-authenticate|reauthenticate/i.test(message);
-}
-function authFailure() {
-    return providerError({
-        kind: "missing_key",
-        message: 'The Gemini CLI is not signed in, or its sign-in has expired. Open a terminal on the computer running the CLI, run "gemini" and sign in, then use Try again.',
-    });
-}
-async function* authChecked(source) {
-    const decoder = new TextDecoder();
-    let tail = "";
-    for await (const bytes of source) {
-        tail = (tail + decoder.decode(bytes, { stream: true })).slice(-8192);
-        // NO_BROWSER prevents opening OAuth. A logged-out CLI instead writes this
-        // non-JSON prompt without a newline; fail before lines() waits for user input.
-        if (/^(?:Enter the authorization code:|Please visit the following URL to authorize)/m.test(tail))
-            throw authFailure();
-        yield bytes;
-    }
-}

package/dist/host-cli/gemini-login.js

@@ -1,83 +0,0 @@
-import { readFile } from "node:fs/promises";
-import { homedir } from "node:os";
-import { join } from "node:path";
-export function nodeGeminiLoginHost() {
-    return {
-        home: homedir(),
-        env: process.env,
-        read: (path) => readFile(path, "utf8").catch(() => undefined),
-    };
-}
-export async function readGeminiLogin(host) {
-    const folder = join(host.home, ".gemini");
-    const raw = await host.read(join(folder, "settings.json"));
-    const settings = parse(raw);
-    const method = selectedAuth(settings);
-    const hasKey = async (name) => nonEmpty(host.env[name]) || dotenvHas(await host.read(join(folder, ".env")), name);
-    const oauth = async () => {
-        const creds = parse(await host.read(join(folder, "oauth_creds.json")));
-        return typeof creds?.refresh_token === "string" && creds.refresh_token !== "";
-    };
-    switch (method) {
-        case "oauth-personal":
-        case "login-with-google":
-            return (await oauth()) ? "signed-in" : "signed-out";
-        case "gemini-api-key":
-            return (await hasKey("GEMINI_API_KEY")) ? "signed-in" : "signed-out";
-        case "vertex-ai":
-            return (await hasKey("GOOGLE_API_KEY")) || (await hasKey("GOOGLE_CLOUD_PROJECT"))
-                ? "signed-in"
-                : "signed-out";
-        case "cloud-shell":
-            return "signed-in";
-        case undefined:
-            // No choice saved yet: the CLI still starts without asking when a key or an earlier
-            // Google sign-in is there; otherwise it opens its sign-in menu.
-            if ((await hasKey("GEMINI_API_KEY")) || (await oauth()))
-                return "signed-in";
-            // Nothing saved says nothing either: the CLI can be signed in some other way (Vertex or
-            // a key in its own environment), so only a sign-in the files prove missing blocks a run.
-            return "unknown";
-        default:
-            // A method this version of Slopify doesn't know.
-            return "unknown";
-    }
-}
-function parse(text) {
-    if (text === undefined)
-        return undefined;
-    try {
-        const value = JSON.parse(text);
-        return typeof value === "object" && value !== null && !Array.isArray(value)
-            ? value
-            : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-function selectedAuth(settings) {
-    const security = settings?.security;
-    const auth = typeof security === "object" && security !== null
-        ? security.auth
-        : undefined;
-    const nested = typeof auth === "object" && auth !== null
-        ? auth.selectedType
-        : undefined;
-    if (typeof nested === "string" && nested !== "")
-        return nested;
-    const flat = settings?.selectedAuthType;
-    return typeof flat === "string" && flat !== "" ? flat : undefined;
-}
-function nonEmpty(value) {
-    return value !== undefined && value.trim() !== "";
-}
-// `NAME=value` in a .env file, optionally quoted or exported.
-function dotenvHas(text, name) {
-    if (text === undefined)
-        return false;
-    return text.split(/\r?\n/).some((line) => {
-        const match = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/.exec(line);
-        return match?.[1] === name && nonEmpty((match[2] ?? "").replace(/^["']|["']$/g, ""));
-    });
-}