@gentbajko/slopify 0.4.2 → 0.5.0

package/README.md

@@ -35,6 +35,11 @@ Everything lives in one SQLite file and one directory tree under the data direct
 Slopify renders video with ffmpeg. The `ffmpeg-static` dependency downloads a
 prebuilt binary to `node_modules/ffmpeg-static/` at install time.
 
+Slopify checks that ffmpeg runs before starting. If the install-time download is
+missing, it downloads the same platform build into `<data-dir>/bin/`, keeping the
+licence and source notice beside it. Later launches reuse that copy. If recovery
+fails, check your connection and antivirus quarantine, or choose your own executable.
+
 That binary is a separate program, run as a child process with an argument array. It
 is licensed under the **GPL-3.0-or-later**. Slopify does not link against it, does not
 embed it, and does not distribute it inside this package; its licence text and the
@@ -44,6 +49,13 @@ GPL's obligations for it, including offering that corresponding source.
 
 Point `SLOPIFY_FFMPEG` at your own build to use that instead.
 
+In Windows PowerShell:
+
+```powershell
+$env:SLOPIFY_FFMPEG = 'C:\tools\ffmpeg\bin\ffmpeg.exe'
+npx @gentbajko/slopify@latest
+```
+
 ## Telemetry
 
 Slopify sends anonymous counters to a collector: installs, projects created, stages

package/dist/adapters/ffmpeg.js

@@ -0,0 +1,78 @@
+import { execFile } from "node:child_process";
+import { existsSync, mkdirSync, mkdtempSync, renameSync, rmSync } from "node:fs";
+import { createRequire } from "node:module";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { z } from "zod";
+import { redact } from "../kernel/log.js";
+// ffmpeg-static exports a path even when npm skipped its install script. Recover using
+// that dependency's own downloader, including its source notice and license, without
+// writing into an npx cache or requiring dependency lifecycle scripts to be enabled.
+export async function prepareFfmpeg(deps) {
+    const override = deps.env.SLOPIFY_FFMPEG?.trim() || deps.env.FFMPEG_BIN?.trim();
+    if (override) {
+        await verify(override);
+        return override;
+    }
+    if (typeof deps.bundled !== "string" || deps.bundled === "") {
+        throw new Error(`No ffmpeg build is available for this platform. ${remedy}`);
+    }
+    if (existsSync(deps.bundled)) {
+        await verify(deps.bundled);
+        return deps.bundled;
+    }
+    const require = createRequire(import.meta.url);
+    const version = deps.version ??
+        z.object({ version: z.string() }).parse(require("ffmpeg-static/package.json")).version;
+    const installer = deps.installer ?? require.resolve("ffmpeg-static/install.js");
+    const root = join(deps.dataDir, "bin");
+    const cached = join(root, `ffmpeg-static-${version}-${process.platform}-${process.arch}`);
+    const name = process.platform === "win32" ? "ffmpeg.exe" : "ffmpeg";
+    const bin = join(cached, name);
+    if (existsSync(bin)) {
+        await verify(bin);
+        return bin;
+    }
+    deps.report?.("Slopify's ffmpeg download is missing. Downloading it before starting…");
+    mkdirSync(root, { recursive: true, mode: 0o700 });
+    const staging = mkdtempSync(join(root, ".ffmpeg-"));
+    try {
+        const target = join(staging, name);
+        await promisify(execFile)(process.execPath, [installer], {
+            env: { ...deps.env, FFMPEG_BIN: target },
+            windowsHide: true,
+            timeout: 180_000,
+            maxBuffer: 1024 * 1024,
+        });
+        await verify(target);
+        // Antivirus may remove just the cached executable, leaving its notices behind.
+        rmSync(cached, { recursive: true, force: true });
+        renameSync(staging, cached);
+        return bin;
+    }
+    catch (error) {
+        throw new Error(`Slopify could not download and start ffmpeg. Check your connection and antivirus quarantine, then restart Slopify. ${remedy} ${detail(error)}`);
+    }
+    finally {
+        // A failed or interrupted download must never be mistaken for an installed binary.
+        rmSync(staging, { recursive: true, force: true });
+    }
+}
+const remedy = "You can also set SLOPIFY_FFMPEG (or FFMPEG_BIN) to a working ffmpeg executable.";
+async function verify(bin) {
+    try {
+        const { stdout } = await promisify(execFile)(bin, ["-version"], {
+            windowsHide: true,
+            timeout: 10_000,
+            maxBuffer: 1024 * 1024,
+        });
+        if (!stdout.startsWith("ffmpeg version "))
+            throw new Error("the executable did not identify itself as ffmpeg");
+    }
+    catch (error) {
+        throw new Error(`ffmpeg at ${bin} could not be started. ${remedy} ${detail(error)}`);
+    }
+}
+function detail(error) {
+    return redact(error instanceof Error ? error.message : String(error));
+}

package/dist/adapters/image/google.js

@@ -42,7 +42,13 @@ const errorBody = z.object({
     error: z.object({
         message: z.string().nullish(),
         status: z.string().nullish(),
-        code: z.number().nullish(),
+        code: z.union([z.number(), z.string()]).nullish(),
+        details: z
+            .array(z.object({
+            "@type": z.string().optional(),
+            retryDelay: z.string().optional(),
+        }))
+            .nullish(),
     }),
 });
 // A content-policy refusal is the provider's final answer and is never retried. Google
@@ -129,6 +135,11 @@ function kindOf(status, named, message) {
         return "auth";
     }
     if (status === 429) {
+        // Interactions wraps quota failures in a string-coded error and exposes the limit
+        // in the message. Zero allocated capacity cannot be fixed by waiting and retrying.
+        if (/quota exceeded for metric:[^\r\n]*?\blimit:\s*0\s*(?:,|$)/im.test(message)) {
+            return "unsupported";
+        }
         return "rate_limit";
     }
     // ceiling: everything else is `other` and is retried, so a prompt past the model's limit
@@ -142,13 +153,28 @@ async function failure(response) {
     // The provider's own words, through the redactor - an error body may quote the key back.
     const named = parsed.success ? parsed.data.error.status : undefined;
     const message = redact((parsed.success ? parsed.data.error.message : undefined) ?? text.trim() ?? response.statusText);
-    const retryAfterMs = retryAfter(response.headers.get("retry-after"));
+    const kind = kindOf(response.status, named, message);
+    const delay = parsed.success
+        ? parsed.data.error.details?.find((one) => one["@type"] === "type.googleapis.com/google.rpc.RetryInfo")?.retryDelay
+        : undefined;
+    const retryAfterMs = retryAfter(response.headers.get("retry-after")) ?? googleRetryDelay(delay, message);
+    const guidance = kind === "unsupported"
+        ? "Google reports zero image quota for this model. Check the API key's project, billing and model quota in Google AI Studio, or choose another image provider. Retrying will not help until quota is available. "
+        : "";
     return providerError({
-        kind: kindOf(response.status, named, message),
-        message: `Google answered ${String(response.status)}: ${message || response.statusText}`,
+        kind,
+        message: `${guidance}Google answered ${String(response.status)}: ${message || response.statusText}`,
         ...(retryAfterMs === undefined ? {} : { retryAfterMs }),
     });
 }
+function googleRetryDelay(delay, message) {
+    const seconds = delay?.match(/^(\d+(?:\.\d+)?)s$/)?.[1] ??
+        message.match(/\bPlease retry in (\d+(?:\.\d+)?)s\b/i)?.[1];
+    if (seconds === undefined)
+        return undefined;
+    const ms = Math.ceil(Number(seconds) * 1000);
+    return Number.isFinite(ms) ? ms : undefined;
+}
 function parse(text) {
     const parsed = interaction.safeParse(safeJson(text));
     if (!parsed.success) {

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

@@ -18,6 +18,12 @@ export const claudeCodeModels = [
     { id: "sonnet", name: "Claude Sonnet (latest)" },
     { id: "haiku", name: "Claude Haiku (latest)" },
 ];
+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.";
 // Measured on 2.1.258, not assumed: with the built-in tools left alone, a `-p` run of this CLI
 // still reached for ToolSearch and WebFetch, and the machine's MCP servers were loaded into the
 // session. Neither belongs in a content pipeline - grounding on the web is an explicit ask,
@@ -31,6 +37,11 @@ export function claudeCodeArgs(req) {
         "stream-json",
         // stream-json output is refused without it.
         "--verbose",
+        // `claude --help` 2.1.263: safe mode excludes CLAUDE.md, output styles, skills and
+        // hooks while retaining login and managed policy. --bare would discard OAuth.
+        "--safe-mode",
+        "--system-prompt",
+        writingRole,
         "--strict-mcp-config",
         ...(req.webSearch === true
             ? ["--tools", "WebSearch", "--allowedTools", "WebSearch"]

package/dist/main.js

@@ -2,6 +2,7 @@ import { fileURLToPath } from "node:url";
 import { serve } from "@hono/node-server";
 import ffmpegStatic from "ffmpeg-static";
 import { buildRegistry } from "./adapter-registry.js";
+import { prepareFfmpeg } from "./adapters/ffmpeg.js";
 import { nodeRunCli } from "./adapters/llm/run-cli.js";
 import { createHub } from "./edge/events/hub.js";
 import { createApp } from "./edge/http/app.js";
@@ -27,7 +28,6 @@ import { collectorEndpoint, httpPostEvents } from "./slices/telemetry/collector-
 import { createFlusher } from "./slices/telemetry/flush.js";
 import { record } from "./slices/telemetry/record.js";
 import { runThumbnail } from "./slices/thumbnail/run.js";
-import { resolveFfmpeg } from "./slices/video/ffmpeg.js";
 import { renderVideo } from "./slices/video/run.js";
 // ceiling: a burst of finished stages coalesces into one delivery a second later, and the
 // collector gets ten seconds to answer before the attempt is abandoned and the events
@@ -42,6 +42,12 @@ export async function boot(config) {
     const lock = acquireInstanceLock(paths.lock);
     let db;
     try {
+        const ffmpeg = await prepareFfmpeg({
+            dataDir: paths.dataDir,
+            env: process.env,
+            bundled: ffmpegStatic,
+            report: (message) => console.warn(message),
+        });
         db = openDb(paths.db);
         migrate(db, clock);
         const interrupted = markInterruptedStages(db, clock);
@@ -66,7 +72,7 @@ export async function boot(config) {
             clock,
             probe: nodeCliProbe,
         });
-        const runner = wire({ db, paths, clock, ids, log, hub, telemetry, flusher, registry });
+        const runner = wire({ db, paths, clock, ids, log, hub, telemetry, flusher, registry, ffmpeg });
         const app = createApp({
             db,
             paths,
@@ -116,10 +122,7 @@ export async function boot(config) {
         throw error;
     }
 }
-function wire({ db, paths, clock, ids, log, hub, telemetry, flusher, registry }) {
-    // Resolved once at boot rather than per render, so a machine with no usable binary
-    // fails at start with one message instead of on every project's last stage.
-    const ffmpeg = resolveFfmpeg(process.env, ffmpegStatic);
+function wire({ db, paths, clock, ids, log, hub, telemetry, flusher, registry, ffmpeg, }) {
     // A stage counts what it did and the queue is flushed after each new event. `record`
     // swallows its own failures, so this can neither fail a stage nor widen what leaves the
     // machine - the payload allow-list is checked inside it.

package/dist/slices/video/ffmpeg.js

@@ -120,7 +120,10 @@ export function runFfmpeg(run) {
             reject(new Error("the render was canceled before it started"));
             return;
         }
-        const child = spawn(run.bin, [...run.args], { stdio: ["ignore", "pipe", "pipe"] });
+        const child = spawn(run.bin, [...run.args], {
+            stdio: ["ignore", "pipe", "pipe"],
+            windowsHide: true,
+        });
         const errors = [];
         let pending = "";
         // A throw out of a stream listener is an uncaughtException, not a rejection: it would