@gentbajko/slopify 0.8.3 → 1.0.0

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/SUBTITLES.md

@@ -8,6 +8,8 @@
 
 For a completed project, open its final Video or Audio export section, set subtitles, and click **Save subtitles**. This rebuilds only the local export from saved narration and images. Changing font, size or position reuses word timing when the audio and spoken text are unchanged. A paused run saves these choices until Resume; pause an active run before editing. Failed alignment or rendering keeps the previous finished export.
 
+If narration omits a short phrase, alignment can skip that transcript span when the surrounding speech is a strong match, including omissions inside an alignment window. The export records the omitted text and audio position for review. Recovery stays bounded and never recreates missing speech.
+
 Audio Off disables subtitles. Video Off produces WAV audio with separate subtitle files. Uploaded audio must match the article; substantial mismatches fail with a message to correct the transcript. Review timing and spelling before publishing. English is supported first; unusual pronunciations and non-English passages can fail alignment.
 
 Fonts are copied into the completed project's caption assets, so an existing export can reuse its chosen font even after the original system font is removed. Installed fonts and uploaded fonts stay local. SRT/VTT are portable text/timing files and do not embed a font; the chosen font is used in burned video captions.

package/dist/adapters/alignment/window.js

@@ -1,15 +1,21 @@
 import { alignWindow, frameSeconds, mismatch } from "./ctc.js";
 import { agreesWithSpeech } from "./quality.js";
 import { letters } from "./vocabulary.js";
-// Recovery can only omit a short transcript prefix, never insert guessed words or times.
+// Recovery omits bounded transcript spans only after confirming surrounding speech.
 export function alignSpeechWindow(logits, frames, candidate, complete, cutoff, skipBudget) {
     try {
-        return { words: accepted(logits, frames, candidate, complete, cutoff), skipped: 0 };
+        return {
+            words: accepted(logits, frames, candidate, complete, cutoff),
+            skipped: 0,
+            omissionStart: 0,
+        };
     }
     catch (error) {
         if (!(error instanceof Error) || error.message !== mismatch)
             throw error;
     }
+    if (skipBudget <= 0)
+        throw new Error(mismatch);
     const heard = greedy(logits, frames).split(/\s+/);
     for (let skipped = 1; skipped <= Math.min(40, skipBudget, candidate.length - 4); skipped += 1) {
         const remaining = candidate.slice(skipped);
@@ -24,23 +30,58 @@ export function alignSpeechWindow(logits, frames, candidate, complete, cutoff, s
             const words = accepted(logits, frames, remaining, complete, cutoff);
             if (words.length < 4 || words.slice(0, 4).some((word) => (word.confidence ?? 0) < 0.75))
                 continue;
-            return { words, skipped };
+            return { words, skipped, omissionStart: 0 };
         }
         catch (error) {
             if (!(error instanceof Error) || error.message !== mismatch)
                 throw error;
         }
     }
+    const observed = greedy(logits, frames).replace(/[^A-Z']/g, "");
+    for (let start = candidate.length - 4; start >= 4; start -= 1) {
+        const prefix = candidate
+            .slice(0, start)
+            .map((word) => word.spoken)
+            .join("")
+            .replace(/[^A-Z']/g, "");
+        if (prefix.length > observed.length)
+            continue;
+        if (!agreesWithSpeech(prefix, observed.slice(0, prefix.length), 0.2))
+            continue;
+        for (let skipped = 1; skipped <= Math.min(40, skipBudget, candidate.length - start - 4); skipped += 1) {
+            const remaining = [...candidate.slice(0, start), ...candidate.slice(start + skipped)];
+            const anchor = remaining
+                .slice(start, start + 4)
+                .map((word) => word.spoken)
+                .join("")
+                .replace(/[^A-Z']/g, "");
+            if (anchor.length < 20 ||
+                !agreesWithSpeech(anchor, observed.slice(prefix.length, prefix.length + anchor.length), 0.2) ||
+                !agreesWithSpeech(prefix + anchor, observed.slice(0, prefix.length + anchor.length), 0.15))
+                continue;
+            try {
+                const words = accepted(logits, frames, remaining, complete, cutoff, 0.2);
+                if (words.length < start + 4 ||
+                    words.slice(start - 4, start + 4).some((word) => (word.confidence ?? 0) < 0.75))
+                    continue;
+                return { words, skipped, omissionStart: start };
+            }
+            catch (error) {
+                if (!(error instanceof Error) || error.message !== mismatch)
+                    throw error;
+            }
+        }
+    }
     throw new Error(mismatch);
 }
-function accepted(logits, frames, candidate, complete, cutoff) {
+function accepted(logits, frames, candidate, complete, cutoff, maximumError = 0.42) {
     const words = alignWindow(logits, frames, candidate, complete).words.filter((word) => word.end <= cutoff);
     const last = words.at(-1);
     if (last === undefined ||
         !agreesWithSpeech(candidate
             .slice(0, words.length)
             .map((word) => word.spoken)
-            .join(" "), greedy(logits, Math.min(frames, Math.ceil(last.end / frameSeconds)))))
+            .join(" "), greedy(logits, Math.min(frames, Math.ceil(last.end / frameSeconds))), maximumError))
         throw new Error(mismatch);
     return words;
 }

package/dist/adapters/alignment/worker.js

@@ -73,9 +73,9 @@ async function run(input) {
                 omitted += recovered.skipped;
                 send({
                     type: "omission",
-                    start: sampleAt / sampleRate,
+                    start: sampleAt / sampleRate + (accepted[recovered.omissionStart - 1]?.end ?? 0),
                     text: candidate
-                        .slice(0, recovered.skipped)
+                        .slice(recovered.omissionStart, recovered.omissionStart + recovered.skipped)
                         .map((word) => word.text)
                         .join(" "),
                 });

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}`