@gentbajko/slopify 0.8.4 → 1.0.1

package/README.md

@@ -13,17 +13,39 @@
 
 A prompt and a few keywords in. A narrated slideshow video out. Your keys, your machine, free.
 
+*Start contributing to the internet's enshittification today!*
+
 ```sh
 npx @gentbajko/slopify@latest
 ```
 
-That opens a browser at `http://127.0.0.1:6969`. Nothing to configure first; add
-provider keys on the Settings screen when you want a stage to generate rather than
-take what you paste in.
+That opens a browser at `http://127.0.0.1:6969`. Node 26 or newer is required.
+
+For a persistent install that makes `slopify` available everywhere:
+
+```sh
+npm install -g @gentbajko/slopify
+slopify
+```
+
+Both commands launch the same local app.
+
+## How to use it
+
+1. Add provider keys and voices in Settings. They stay in your local Slopify database.
+2. Write reusable article, image and thumbnail prompts in Prompts, using `{{keywords}}`
+   where each video's subject belongs.
+3. In Play, build an autosaved setup across Content, Outputs, Style and Review. Supply
+   or skip optional stages, preview subtitles, and inspect the estimated cost before Start.
+4. Follow total and per-stage progress in the project workspace. Pause unfinished work
+   to change providers, add review checkpoints, or edit a paused or completed project as
+   a retained revision. Saving does not rebuild until you explicitly ask.
+5. Save Play setups or project revisions as templates. Apply one to a fresh draft or
+   schedule one-off, daily or weekly jobs with keyword variants and a spend ceiling.
 
-Six stages run as a graph: research, article, narration, images, thumbnail, video.
-Generate any of them, or provide the output yourself and that stage is skipped. The
-video is a slideshow with alternating zoom over the narration, rendered with ffmpeg.
+The article is the only required output. Slopify can make a narrated or silent slideshow,
+an audio-only WAV, locally timed English subtitles, or just the intermediate results you
+select. Uploaded and already completed outputs are reused when their inputs still match.
 
 ## Inworld narration
 

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

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { redact } from "../../kernel/log.js";
 import { providerError } from "../../kernel/ports/model.js";
-import { cliEvent, cliShaped, endedWithout, promptOf } from "./run-cli.js";
+import { cliEvent, cliShaped, endedWithout, promptOf, stopCliRun } from "./run-cli.js";
 import { lines } from "./sse-lines.js";
 // The local-agent adapter for Claude Code: spawned non-interactively, authenticated by the
 // CLI's own login, no key anywhere in this file. Readiness is not computed here - `adapters/**`
@@ -76,6 +76,7 @@ export function claudeCodeLlm(deps) {
     const binary = deps.binary ?? claudeCodeBinary;
     async function* complete(req) {
         const run = deps.run(binary, claudeCodeArgs(req), req.signal);
+        let ended;
         try {
             for await (const line of lines(run.stdout, req.signal)) {
                 if (line.trim() === "") {
@@ -123,7 +124,7 @@ export function claudeCodeLlm(deps) {
         finally {
             // The consumer can also abandon the generator - a retry, a timeout - and an agent
             // session left running would keep spending the user's subscription.
-            run.kill();
+            ended = await stopCliRun(run);
         }
         // A cancelled run ends its stream the same way an exhausted one does: the child was
         // killed, so stdout simply stopped. An aborted call counts as nothing, so it must not
@@ -132,7 +133,9 @@ export function claudeCodeLlm(deps) {
         // The stream ended with no result event at all.
         throw providerError({
             kind: "other",
-            message: endedWithout(binary, await run.ended, run.stderr()),
+            message: ended === undefined
+                ? `the ${binary} CLI did not stop after forced termination`
+                : endedWithout(binary, ended, run.stderr()),
         });
     }
     return {

package/dist/adapters/llm/codex.js

@@ -1,7 +1,10 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { z } from "zod";
 import { redact } from "../../kernel/log.js";
 import { providerError } from "../../kernel/ports/model.js";
-import { cliEvent, cliShaped, endedWithout, promptOf } from "./run-cli.js";
+import { cliEvent, cliShaped, endedWithout, promptOf, stopCliRun } from "./run-cli.js";
 import { lines } from "./sse-lines.js";
 // The local-agent adapter for the Codex CLI. Same shape as Claude Code's and a different
 // vocabulary: Codex writes a JSONL thread of `thread.started`, `item.*` and `turn.*`
@@ -10,19 +13,73 @@ export const codexBinary = "codex";
 // Codex publishes its account-specific picker in models_cache.json. With no
 // cache, offer custom entry rather than pretending a pinned model is current.
 export const codexModels = [];
-// `codex exec --help` (0.149.1) for the flags. `-c web_search=<mode>` is a TOML override, and
-// the binary's own error names the modes: "unknown variant `bogus`, expected one of `disabled`,
-// `cached`, `indexed`, `live`". `live` is the grounded mode research asks for and `disabled` is
-// what every other stage runs under, so none grounds itself by accident. `--ephemeral` keeps no
-// session file, `--skip-git-repo-check` lets it run in the data directory, and the quotes in
-// the value are part of the argv element because the override is parsed as TOML, where a bare
-// `live` is not a string.
-export function codexArgs(req) {
+const writingRole = "You are the writing and research component of Slopify, a video creation app. " +
+    "Produce the text requested in the supplied conversation: articles, narration scripts, " +
+    "research notes or image prompts. Follow the requested topic, language, tone, length and format. " +
+    "Return only the requested content, without progress updates or introductory remarks. " +
+    "Use web search when it is available and needed for the requested research. " +
+    "Do not inspect or modify local files.";
+// Codex is a coding agent by default, while this adapter is a content provider. These supported
+// feature gates remove every local or account-connected tool exposed by 0.149.1. Native web
+// search is controlled separately below, so grounded research still works without a shell.
+const disabledFeatures = [
+    "shell_tool",
+    "unified_exec",
+    "code_mode_host",
+    "hooks",
+    "apps",
+    "plugins",
+    "remote_plugin",
+    "skill_search",
+    "multi_agent",
+    "computer_use",
+    "browser_use",
+    "image_generation",
+    "view_image",
+    "workspace_dependencies",
+];
+// `codex exec --help` (0.149.1) for the flags. `--ignore-user-config` retains authentication
+// while excluding config.toml, `--ignore-rules` excludes user/project exec policy, and strict
+// config makes an older CLI fail closed if it cannot apply a hardening override. A private cwd
+// plus a zero project-doc budget excludes AGENTS.md and project `.codex` context. Read-only is
+// defense in depth if a future release exposes a new filesystem tool. The TOML strings keep their
+// quotes because each `-c` value is parsed as TOML rather than as a shell expression.
+export function codexArgs(req, directory) {
     return [
         "exec",
         "--json",
         "--ephemeral",
+        "--ignore-user-config",
+        "--ignore-rules",
+        "--strict-config",
         "--skip-git-repo-check",
+        "--sandbox",
+        "read-only",
+        "--cd",
+        directory,
+        ...disabledFeatures.flatMap((feature) => ["--disable", feature]),
+        "-c",
+        "project_doc_max_bytes=0",
+        "-c",
+        "skills.include_instructions=false",
+        "-c",
+        "skills.bundled.enabled=false",
+        "-c",
+        "orchestrator.skills.enabled=false",
+        "-c",
+        "orchestrator.mcp.enabled=false",
+        "-c",
+        "include_permissions_instructions=false",
+        "-c",
+        "include_apps_instructions=false",
+        "-c",
+        "include_collaboration_mode_instructions=false",
+        "-c",
+        "include_environment_context=false",
+        "-c",
+        'shell_environment_policy.inherit="none"',
+        "-c",
+        `instructions=${JSON.stringify(writingRole)}`,
         "-c",
         `web_search="${req.webSearch === true ? "live" : "disabled"}"`,
         ...(req.thinkingConfig?.effort
@@ -49,8 +106,12 @@ const errorEvent = z.object({ message: z.string() });
 export function codexLlm(deps) {
     const binary = deps.binary ?? codexBinary;
     async function* complete(req) {
-        const run = deps.run(binary, codexArgs(req), req.signal);
+        req.signal.throwIfAborted();
+        const workspace = codexWorkspace();
+        let run;
+        let ended;
         try {
+            run = deps.run(binary, codexArgs(req, workspace.directory), req.signal, workspace.options);
             for await (const line of lines(run.stdout, req.signal)) {
                 if (line.trim() === "") {
                     continue;
@@ -96,7 +157,13 @@ export function codexLlm(deps) {
             throw error;
         }
         finally {
-            run.kill();
+            try {
+                if (run !== undefined)
+                    ended = await stopCliRun(run);
+            }
+            finally {
+                workspace.remove();
+            }
         }
         // A cancelled run ends its stream the same way an exhausted one does: the child was
         // killed, so stdout simply stopped. An aborted call counts as nothing, so it must not
@@ -105,7 +172,9 @@ export function codexLlm(deps) {
         // The stream ended with neither a completed turn nor a failure.
         throw providerError({
             kind: "other",
-            message: endedWithout(binary, await run.ended, run.stderr()),
+            message: ended === undefined
+                ? `the ${binary} CLI did not stop after forced termination`
+                : endedWithout(binary, ended, run.stderr()),
         });
     }
     return {
@@ -116,6 +185,27 @@ export function codexLlm(deps) {
         complete,
     };
 }
+function codexWorkspace() {
+    const directory = mkdtempSync(join(tmpdir(), "slopify-codex-"));
+    // npm sets INIT_CWD to the directory from which the app was launched. Do not hand that path,
+    // an old shell directory or Git's explicit worktree pointers to the content subprocess.
+    const env = { ...process.env };
+    delete env.INIT_CWD;
+    delete env.OLDPWD;
+    delete env.GIT_DIR;
+    delete env.GIT_WORK_TREE;
+    env.PWD = directory;
+    return {
+        directory,
+        options: { cwd: directory, env },
+        remove: () => rmSync(directory, {
+            recursive: true,
+            force: true,
+            maxRetries: 3,
+            retryDelay: 50,
+        }),
+    };
+}
 function usageOf(usage) {
     return usage === null || usage === undefined
         ? null

package/dist/adapters/llm/gemini.js

@@ -3,7 +3,7 @@ import { redact } from "../../kernel/log.js";
 import { providerError } from "../../kernel/ports/model.js";
 import { geminiModels } from "./gemini-models.js";
 import { geminiWorkspace } from "./gemini-workspace.js";
-import { cliEvent, cliShaped, endedWithout, promptOf } from "./run-cli.js";
+import { cliEvent, cliShaped, endedWithout, promptOf, stopCliRun } from "./run-cli.js";
 import { lines } from "./sse-lines.js";
 export const geminiBinary = "gemini";
 export { geminiModels } from "./gemini-models.js";
@@ -45,6 +45,7 @@ export function geminiLlm(deps) {
         req.signal.throwIfAborted();
         const workspace = geminiWorkspace(req.webSearch === true, req);
         let run;
+        let ended;
         try {
             run = deps.run(binary, geminiArgs(req, workspace.mcpAllowlist), req.signal, workspace.options);
             for await (const line of lines(authChecked(run.stdout), req.signal)) {
@@ -80,22 +81,24 @@ export function geminiLlm(deps) {
                     return;
                 }
             }
-            req.signal.throwIfAborted();
-            const ended = await run.ended;
-            if (authRequired(run.stderr()))
-                throw authFailure();
-            throw failure(endedWithout(binary, ended, run.stderr()));
         }
         catch (error) {
             req.signal.throwIfAborted();
             throw error;
         }
         finally {
-            run?.kill();
             if (run !== undefined)
-                await run.ended;
+                ended = await stopCliRun(run);
             workspace.remove();
         }
+        req.signal.throwIfAborted();
+        if (run === undefined)
+            throw failure(`the ${binary} CLI could not be started`);
+        if (authRequired(run.stderr()))
+            throw authFailure();
+        throw failure(ended === undefined
+            ? `the ${binary} CLI did not stop after forced termination`
+            : endedWithout(binary, ended, run.stderr()));
     }
     return {
         id: "gemini",

package/dist/adapters/llm/run-cli.js

@@ -8,6 +8,7 @@ import { providerError } from "../../kernel/ports/model.js";
 // says why it stopped. Streaming stderr to the log is the upgrade if a provider ever
 // buries its reason in the first line of a long report.
 export const stderrMax = 8192;
+export const cliTerminationGraceMs = 1_000;
 export function nodeRunCli(binary, args, signal, options) {
     // An argument array, never a shell string: a prompt carrying backticks, `$(...)`, quotes or
     // newlines is one argv element and nothing in it can become a command. stdin is /dev/null
@@ -16,9 +17,10 @@ export function nodeRunCli(binary, args, signal, options) {
     // SIGTERM when the stage is cancelled, so no agent session outlives the run that started it.
     const command = cliCommand(binary);
     const child = spawn(command.file, [...command.args, ...args], {
-        signal,
         stdio: ["ignore", "pipe", "pipe"],
         windowsHide: true,
+        // A private POSIX process group lets force cleanup include helpers spawned by a CLI.
+        detached: process.platform !== "win32",
         ...options,
     });
     let stderr = "";
@@ -36,25 +38,78 @@ export function nodeRunCli(binary, args, signal, options) {
     child.on("error", (error) => {
         spawnError = error;
     });
+    let settled = false;
     const ended = new Promise((resolve) => {
         const settle = (code) => {
+            settled = true;
             resolve({ code, error: spawnError });
         };
         child.once("close", settle);
         // Close follows an error too; waiting for it keeps cleanup behind process exit.
     });
+    const terminate = (force = false) => {
+        if (settled)
+            return;
+        const pid = child.pid;
+        if (process.platform === "win32") {
+            if (force && pid !== undefined) {
+                const killer = spawn("taskkill", ["/pid", String(pid), "/t", "/f"], {
+                    stdio: "ignore",
+                    windowsHide: true,
+                });
+                killer.on("error", () => { });
+                killer.unref();
+            }
+            child.kill(force ? "SIGKILL" : "SIGTERM");
+        }
+        else if (pid !== undefined) {
+            try {
+                process.kill(-pid, force ? "SIGKILL" : "SIGTERM");
+            }
+            catch {
+                child.kill(force ? "SIGKILL" : "SIGTERM");
+            }
+        }
+        if (force) {
+            child.stdout?.destroy();
+            child.stderr?.destroy();
+        }
+    };
+    const abort = () => terminate();
+    if (signal.aborted)
+        abort();
+    else
+        signal.addEventListener("abort", abort, { once: true });
+    void ended.then(() => signal.removeEventListener("abort", abort));
     return {
         pid: child.pid,
         stdout: child.stdout === null ? nothing : bytesOf(child.stdout),
         stderr: () => stderr,
         ended,
-        kill: () => {
-            if (child.exitCode === null && child.signalCode === null) {
-                child.kill();
-            }
-        },
+        kill: terminate,
     };
 }
+/** Stop a CLI without letting a resistant process wedge pause, cancel, or app shutdown. */
+export async function stopCliRun(run, graceMs = cliTerminationGraceMs, forceMs = cliTerminationGraceMs) {
+    run.kill();
+    const graceful = await endedWithin(run.ended, graceMs);
+    if (graceful !== undefined)
+        return graceful;
+    run.kill(true);
+    return endedWithin(run.ended, forceMs);
+}
+async function endedWithin(ended, timeoutMs) {
+    let timer;
+    const result = await Promise.race([
+        ended,
+        new Promise((resolve) => {
+            timer = setTimeout(() => resolve(undefined), timeoutMs);
+        }),
+    ]);
+    if (timer !== undefined)
+        clearTimeout(timer);
+    return result;
+}
 // ceiling: both CLIs take one prompt string, so a system or assistant turn is flattened
 // into it under a header. Claude Code's `--append-system-prompt` is the upgrade if a stage
 // ever needs a real system turn; today research and the article each compose one message.

package/dist/adapters/tts/inworld-async.js

@@ -13,16 +13,16 @@ const operationSchema = z.object({
 // A continuation survives automatic retries of this call; pausing/restarting a
 // stage stops local polling but cannot cancel an already accepted remote job.
 export async function* inworldAsync(deps, request, key) {
-    if (request.text.length > 100_000) {
+    const saved = request.continuation?.read();
+    if (saved !== undefined && !operationName.test(saved))
+        throw invalid("returned an invalid operation name");
+    if (saved === undefined && request.text.length > 100_000) {
         throw providerError({
             kind: "unsupported",
             message: "Inworld async accepts up to 100,000 characters per request (10,000 for On-Demand accounts). Select paragraph chunking for longer articles.",
         });
     }
     const headers = { Authorization: `Basic ${key}`, "Content-Type": "application/json" };
-    const saved = request.continuation?.read();
-    if (saved && !operationName.test(saved))
-        throw invalid("returned an invalid operation name");
     request.signal.throwIfAborted();
     let response = await deps.fetch(saved
         ? `https://api.inworld.ai/lro/v1alpha/${saved}`

package/dist/adapters/tts/inworld.js

@@ -3,7 +3,6 @@ import { redact } from "../../kernel/log.js";
 import { providerError } from "../../kernel/ports/model.js";
 import { retryAfter } from "../retry-after.js";
 import { inworldAsync } from "./inworld-async.js";
-import { inworldTextParts } from "./inworld-text.js";
 export const inworldModels = [
     { id: "inworld-tts-2", name: "Realtime TTS-2" },
     { id: "inworld-tts-2-flash", name: "Realtime TTS-2 Flash" },
@@ -26,7 +25,7 @@ export function inworldTts(deps) {
                 throw providerError({ kind: "missing_key", message: "No Inworld API key is stored." });
             const cancel = new AbortController();
             const signal = AbortSignal.any([request.signal, cancel.signal]);
-            const iterator = synthesizeParts(deps, { ...request, signal }, key);
+            const iterator = synthesizeRequest(deps, { ...request, signal }, key);
             return {
                 container: "mp3",
                 audio: new ReadableStream({
@@ -51,85 +50,91 @@ export function inworldTts(deps) {
         },
     };
 }
-async function* synthesizeParts(deps, request, key) {
-    if ((request.model ?? "inworld-tts-2") === "inworld-tts-2" && request.text.length > 4000) {
+async function* synthesizeRequest(deps, request, key) {
+    if (request.continuation?.read() !== undefined) {
         yield* inworldAsync(deps, request, key);
         return;
     }
-    const parts = inworldTextParts(request.text);
-    if (parts.length === 0)
+    if (request.text.trim().length === 0)
         throw providerError({ kind: "unsupported", message: "Inworld needs text to narrate." });
-    for (const text of parts) {
-        request.signal.throwIfAborted();
-        const response = await deps.fetch("https://api.inworld.ai/tts/v1/voice:stream", {
-            method: "POST",
-            redirect: "error",
-            signal: request.signal,
-            headers: { Authorization: `Basic ${key}`, "Content-Type": "application/json" },
-            body: JSON.stringify({
-                text,
-                voiceId: request.voiceId,
-                modelId: request.model ?? "inworld-tts-2",
-                audioConfig: { audioEncoding: "MP3", sampleRateHertz: 48_000, bitRate: 128_000 },
-            }),
+    if ((request.model ?? "inworld-tts-2") === "inworld-tts-2" && request.text.length > 4000) {
+        yield* inworldAsync(deps, request, key);
+        return;
+    }
+    if (request.text.length > 4000)
+        throw providerError({
+            kind: "unsupported",
+            message: "Inworld streaming accepts up to 4,000 characters per physical request. Rebuild narration with a supported request limit.",
         });
-        if (!response.ok) {
-            const detail = clean(await response.text().catch(() => ""), key);
-            const retryAfterMs = retryAfter(response.headers.get("retry-after"));
+    request.signal.throwIfAborted();
+    const response = await deps.fetch("https://api.inworld.ai/tts/v1/voice:stream", {
+        method: "POST",
+        redirect: "error",
+        signal: request.signal,
+        headers: { Authorization: `Basic ${key}`, "Content-Type": "application/json" },
+        body: JSON.stringify({
+            text: request.text,
+            voiceId: request.voiceId,
+            modelId: request.model ?? "inworld-tts-2",
+            audioConfig: { audioEncoding: "MP3", sampleRateHertz: 48_000, bitRate: 128_000 },
+        }),
+    });
+    if (!response.ok) {
+        const detail = clean(await response.text().catch(() => ""), key);
+        const retryAfterMs = retryAfter(response.headers.get("retry-after"));
+        throw providerError({
+            kind: response.status === 401 || response.status === 403
+                ? "auth"
+                : response.status === 429
+                    ? "rate_limit"
+                    : response.status === 400 || response.status === 404
+                        ? "unsupported"
+                        : "other",
+            message: clean(`Inworld answered ${response.status} for voice ${request.voiceId}: ${detail || response.statusText}`, key),
+            ...(retryAfterMs === undefined ? {} : { retryAfterMs }),
+        });
+    }
+    if (response.body === null)
+        throw invalid("answered with no audio");
+    let heard = false;
+    for await (const line of lines(response.body)) {
+        request.signal.throwIfAborted();
+        let raw;
+        try {
+            raw = JSON.parse(line);
+        }
+        catch {
+            throw invalid("sent an unreadable audio chunk");
+        }
+        const parsed = envelope.safeParse(raw);
+        if (!parsed.success || (!parsed.data.result && !parsed.data.error))
+            throw invalid("sent an unreadable audio chunk");
+        if (parsed.data.error) {
+            const { code, message } = parsed.data.error;
             throw providerError({
-                kind: response.status === 401 || response.status === 403
+                kind: code === 16 || code === 7
                     ? "auth"
-                    : response.status === 429
+                    : code === 8
                         ? "rate_limit"
-                        : response.status === 400 || response.status === 404
+                        : code === 3 || code === 5
                             ? "unsupported"
                             : "other",
-                message: clean(`Inworld answered ${response.status} for voice ${request.voiceId}: ${detail || response.statusText}`, key),
-                ...(retryAfterMs === undefined ? {} : { retryAfterMs }),
+                message: `Inworld stream failed: ${clean(message ?? "audio generation stopped", key)}`,
             });
         }
-        if (response.body === null)
-            throw invalid("answered with no audio");
-        let heard = false;
-        for await (const line of lines(response.body)) {
-            request.signal.throwIfAborted();
-            let raw;
-            try {
-                raw = JSON.parse(line);
-            }
-            catch {
-                throw invalid("sent an unreadable audio chunk");
-            }
-            const parsed = envelope.safeParse(raw);
-            if (!parsed.success || (!parsed.data.result && !parsed.data.error))
-                throw invalid("sent an unreadable audio chunk");
-            if (parsed.data.error) {
-                const { code, message } = parsed.data.error;
-                throw providerError({
-                    kind: code === 16 || code === 7
-                        ? "auth"
-                        : code === 8
-                            ? "rate_limit"
-                            : code === 3 || code === 5
-                                ? "unsupported"
-                                : "other",
-                    message: `Inworld stream failed: ${clean(message ?? "audio generation stopped", key)}`,
-                });
-            }
-            const encoded = parsed.data.result?.audioContent;
-            if (!encoded)
-                continue;
-            if (!/^[A-Za-z0-9+/]*={0,2}$/.test(encoded) || encoded.length % 4 === 1)
-                throw invalid("sent invalid encoded audio");
-            const audio = Buffer.from(encoded, "base64");
-            if (audio.length === 0)
-                continue;
-            heard = true;
-            yield audio;
-        }
-        if (!heard)
-            throw invalid("answered with no audio");
+        const encoded = parsed.data.result?.audioContent;
+        if (!encoded)
+            continue;
+        if (!/^[A-Za-z0-9+/]*={0,2}$/.test(encoded) || encoded.length % 4 === 1)
+            throw invalid("sent invalid encoded audio");
+        const audio = Buffer.from(encoded, "base64");
+        if (audio.length === 0)
+            continue;
+        heard = true;
+        yield audio;
     }
+    if (!heard)
+        throw invalid("answered with no audio");
 }
 async function* lines(body) {
     const reader = body.getReader();