@gentbajko/slopify 0.8.4 → 1.0.1

package/dist/slices/schedules/schema.js

@@ -0,0 +1,80 @@
+import { z } from "zod";
+import { cadenceSchema, validTimeZone } from "./calendar.js";
+const id = z.uuid();
+const keywordName = z
+    .string()
+    .min(1)
+    .max(200)
+    .refine((value) => value === value.trim(), "Keyword names cannot start or end with spaces.");
+const item = z
+    .object({
+    title: z.string().trim().min(1).max(200),
+    values: z.record(keywordName, z.string().max(10000)).readonly(),
+})
+    .strict()
+    .readonly();
+const policy = z.enum(["skip", "run-once"]);
+export const scheduleCreateSchema = z
+    .object({
+    id,
+    name: z.string().trim().min(1).max(200),
+    templateId: id,
+    templateVersion: z.number().int().positive(),
+    cadence: cadenceSchema,
+    timezone: z.string().min(1).max(100).refine(validTimeZone, "Choose a valid IANA timezone."),
+    missedPolicy: policy.default("skip"),
+    overlapPolicy: z.literal("skip").default("skip"),
+    spendLimitCents: z.number().int().nonnegative().nullable().default(null),
+    items: z.array(item).max(49).default([]).readonly(),
+})
+    .strict()
+    .readonly();
+export const scheduleUpdateSchema = scheduleCreateSchema
+    .unwrap()
+    .extend({ baseVersion: z.number().int().positive(), mutationId: id })
+    .strict()
+    .readonly();
+export const scheduleDeleteSchema = z
+    .object({ id, baseVersion: z.number().int().positive() })
+    .strict()
+    .readonly();
+export const scheduleControlSchema = z
+    .object({ id, baseVersion: z.number().int().positive() })
+    .strict()
+    .readonly();
+export const scheduleSummarySchema = z
+    .object({
+    id,
+    name: z.string(),
+    templateId: id,
+    templateVersion: z.number().int().positive(),
+    cadence: cadenceSchema,
+    timezone: z.string(),
+    missedPolicy: policy,
+    overlapPolicy: z.literal("skip"),
+    spendLimitCents: z.number().int().nonnegative().nullable(),
+    items: z.array(item).readonly(),
+    status: z.enum(["active", "paused", "completed", "canceled"]),
+    version: z.number().int().positive(),
+    nextRunAt: z.string().datetime({ offset: true }).nullable(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+    deletedAt: z.string().datetime({ offset: true }).nullable(),
+})
+    .strict()
+    .readonly();
+export const scheduleRunSchema = z
+    .object({
+    id,
+    scheduleId: id,
+    scheduledFor: z.string().datetime({ offset: true }),
+    status: z.enum(["running", "succeeded", "failed", "skipped"]),
+    requestId: id.nullable(),
+    projectIds: z.array(z.string()).readonly(),
+    estimate: z.unknown().nullable(),
+    startedAt: z.string().datetime({ offset: true }),
+    endedAt: z.string().datetime({ offset: true }).nullable(),
+    error: z.string().nullable(),
+})
+    .strict()
+    .readonly();

package/dist/slices/schedules/service.js

@@ -0,0 +1,178 @@
+import { z } from "zod";
+import { transact } from "../../kernel/db/tx.js";
+import { requestHash } from "../play-drafts/repo.js";
+import { nextOccurrence } from "./calendar.js";
+import { insertSchedule, runsForSchedule, scheduleById, scheduleRows, setScheduleStatus, tombstoneScheduleRow, updateScheduleRow, } from "./repo.js";
+import { scheduleControlSchema, scheduleCreateSchema, scheduleDeleteSchema, scheduleUpdateSchema, } from "./schema.js";
+export function listSchedules(deps) {
+    return scheduleRows(deps.db);
+}
+export function listScheduleRuns(deps, id) {
+    if (!z.uuid().safeParse(id).success)
+        return { ok: false, reason: "invalid-input" };
+    const runs = runsForSchedule(deps.db, id);
+    if (!scheduleById(deps.db, id) && runs.length === 0)
+        return { ok: false, reason: "not-found" };
+    return { ok: true, value: runs };
+}
+export function createSchedule(deps, input) {
+    const parsed = scheduleCreateSchema.safeParse(input);
+    if (!parsed.success)
+        return { ok: false, reason: "invalid-input" };
+    const hash = requestHash(parsed.data);
+    return transact(deps.db, () => {
+        const old = deps.db
+            .prepare("SELECT creation_hash,deleted_at FROM schedules WHERE id=?")
+            .get(parsed.data.id);
+        if (old !== undefined) {
+            const saved = z
+                .object({ creation_hash: z.string(), deleted_at: z.string().nullable() })
+                .parse(old);
+            if (saved.deleted_at !== null)
+                return { ok: false, reason: "conflict" };
+            return saved.creation_hash === hash
+                ? { ok: true, value: scheduleById(deps.db, parsed.data.id) }
+                : { ok: false, reason: "conflict" };
+        }
+        const checked = checkTemplate(deps, parsed.data.templateId, parsed.data.templateVersion);
+        if (!checked.ok)
+            return checked;
+        const now = deps.clock.now();
+        const next = nextOccurrence(parsed.data.cadence, parsed.data.timezone, now);
+        if (next === null)
+            return { ok: false, reason: "not-due" };
+        const value = summary(parsed.data, next.toISOString(), now.toISOString());
+        insertSchedule(deps.db, value, hash);
+        return { ok: true, value };
+    });
+}
+export function updateSchedule(deps, input) {
+    const parsed = scheduleUpdateSchema.safeParse(input);
+    if (!parsed.success)
+        return { ok: false, reason: "invalid-input" };
+    const hash = requestHash(parsed.data);
+    return transact(deps.db, () => {
+        const previous = scheduleById(deps.db, parsed.data.id);
+        if (!previous)
+            return { ok: false, reason: "not-found" };
+        const row = deps.db
+            .prepare("SELECT mutation_id,mutation_hash FROM schedules WHERE id=?")
+            .get(previous.id);
+        if (row !== undefined) {
+            const saved = z
+                .object({ mutation_id: z.string().nullable(), mutation_hash: z.string().nullable() })
+                .parse(row);
+            if (saved.mutation_id === parsed.data.mutationId)
+                return saved.mutation_hash === hash
+                    ? { ok: true, value: previous }
+                    : { ok: false, reason: "conflict" };
+        }
+        if (previous.deletedAt !== null)
+            return { ok: false, reason: "conflict" };
+        if (previous.version !== parsed.data.baseVersion)
+            return { ok: false, reason: "conflict" };
+        if (previous.status === "canceled" || previous.status === "completed")
+            return { ok: false, reason: "conflict" };
+        const checked = checkTemplate(deps, parsed.data.templateId, parsed.data.templateVersion);
+        if (!checked.ok)
+            return checked;
+        const now = deps.clock.now();
+        const next = previous.status === "active"
+            ? nextOccurrence(parsed.data.cadence, parsed.data.timezone, now)
+            : previous.nextRunAt === null
+                ? null
+                : nextOccurrence(parsed.data.cadence, parsed.data.timezone, now);
+        const value = summary(parsed.data, next?.toISOString() ?? null, now.toISOString(), previous.status, previous.version + 1);
+        if (!updateScheduleRow(deps.db, value, parsed.data.mutationId, hash, parsed.data.baseVersion))
+            return { ok: false, reason: "conflict" };
+        return { ok: true, value };
+    });
+}
+export function pauseSchedule(deps, input) {
+    return control(deps, input, "paused");
+}
+export function resumeSchedule(deps, input) {
+    const parsed = scheduleControlSchema.safeParse(input);
+    if (!parsed.success)
+        return { ok: false, reason: "invalid-input" };
+    const previous = scheduleById(deps.db, parsed.data.id);
+    if (!previous)
+        return { ok: false, reason: "not-found" };
+    if (previous.deletedAt !== null)
+        return { ok: false, reason: "conflict" };
+    if (previous.version !== parsed.data.baseVersion || previous.status !== "paused")
+        return { ok: false, reason: "conflict" };
+    const next = nextOccurrence(previous.cadence, previous.timezone, deps.clock.now());
+    const status = next === null ? "completed" : "active";
+    if (!setScheduleStatus(deps.db, previous.id, previous.version, status, next?.toISOString() ?? null, deps.clock.now().toISOString()))
+        return { ok: false, reason: "conflict" };
+    return { ok: true, value: scheduleById(deps.db, previous.id) };
+}
+export function cancelSchedule(deps, input) {
+    return control(deps, input, "canceled");
+}
+export function deleteSchedule(deps, input) {
+    const parsed = scheduleDeleteSchema.safeParse(input);
+    if (!parsed.success)
+        return { ok: false, reason: "invalid-input" };
+    const previous = scheduleById(deps.db, parsed.data.id);
+    if (!previous)
+        return { ok: false, reason: "not-found" };
+    if (previous.deletedAt !== null)
+        return { ok: true, value: { deleted: true } };
+    if (previous.version !== parsed.data.baseVersion)
+        return { ok: false, reason: "conflict" };
+    if (previous.status !== "completed" && previous.status !== "canceled")
+        return { ok: false, reason: "cancel-required" };
+    const deletedAt = deps.clock.now().toISOString();
+    return transact(deps.db, () => tombstoneScheduleRow(deps.db, previous.id, previous.version, deletedAt)
+        ? { ok: true, value: { deleted: true } }
+        : { ok: false, reason: "conflict" });
+}
+function control(deps, input, status) {
+    const parsed = scheduleControlSchema.safeParse(input);
+    if (!parsed.success)
+        return { ok: false, reason: "invalid-input" };
+    const previous = scheduleById(deps.db, parsed.data.id);
+    if (!previous)
+        return { ok: false, reason: "not-found" };
+    if (previous.deletedAt !== null)
+        return { ok: false, reason: "conflict" };
+    if (previous.version !== parsed.data.baseVersion ||
+        (previous.status !== "active" && !(status === "canceled" && previous.status === "paused")))
+        return { ok: false, reason: "conflict" };
+    const next = status === "canceled" ? null : previous.nextRunAt;
+    if (!setScheduleStatus(deps.db, previous.id, previous.version, status, next, deps.clock.now().toISOString()))
+        return { ok: false, reason: "conflict" };
+    return { ok: true, value: scheduleById(deps.db, previous.id) };
+}
+function checkTemplate(deps, id, version) {
+    const template = deps.template(id, version);
+    if (!template)
+        return { ok: false, reason: "missing-template" };
+    const sources = template.document.form.sources;
+    const mediaSources = ["audio", "images", "thumbnail"];
+    if (mediaSources.some((kind) => sources[kind] === "provide"))
+        return { ok: false, reason: "unsupported-media" };
+    return { ok: true, value: true };
+}
+function summary(input, nextRunAt, now, status = "active", version = 1) {
+    return {
+        id: input.id,
+        name: input.name,
+        templateId: input.templateId,
+        templateVersion: input.templateVersion,
+        cadence: input.cadence,
+        timezone: input.timezone,
+        missedPolicy: input.missedPolicy,
+        overlapPolicy: input.overlapPolicy,
+        spendLimitCents: input.spendLimitCents,
+        items: input.items,
+        status,
+        version,
+        nextRunAt,
+        createdAt: now,
+        updatedAt: now,
+        deletedAt: null,
+    };
+}

package/dist/slices/settings/cli-paths.js

@@ -77,7 +77,7 @@ async function save(deps, id, raw) {
     }
     const command = configured ?? provider.binary;
     const probed = await deps.probe(command, provider.versionArgs, cliProbeTimeoutMs);
-    const readiness = readinessFromProbe(probed);
+    const readiness = readinessFromProbe(probed, provider);
     if (configured !== null && readiness.kind === "cli" && !readiness.installed)
         return {
             ok: false,

package/dist/slices/settings/cli-status.js

@@ -3,6 +3,9 @@ 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;
+// The content adapter's isolation flags and feature gates were verified against this release.
+// Older Codex binaries must fail before admission instead of failing every generation attempt.
+export const minimumCodexCliVersion = "0.149.1";
 const probeOutputMax = 64 * 1024;
 // 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.
@@ -25,16 +28,53 @@ export function nodeCliProbe(binary, args, timeoutMs) {
     });
 }
 export async function cliReadiness(probe, provider) {
-    return readinessFromProbe(await probe(provider.binary, provider.versionArgs, cliProbeTimeoutMs));
+    return readinessFromProbe(await probe(provider.binary, provider.versionArgs, cliProbeTimeoutMs), provider);
 }
-export function readinessFromProbe(result) {
+export function readinessFromProbe(result, provider) {
     if (!result.ran) {
         return { kind: "cli", installed: false };
     }
     const version = versionFrom(result.stdout);
-    return version === undefined
-        ? { kind: "cli", installed: true }
-        : { kind: "cli", installed: true, version };
+    if (provider.id !== "codex")
+        return version === undefined
+            ? { kind: "cli", installed: true }
+            : { kind: "cli", installed: true, version };
+    if (version === undefined)
+        return {
+            kind: "cli",
+            installed: true,
+            issue: `Slopify could not verify this Codex CLI version. Install Codex CLI ${minimumCodexCliVersion} or newer, then try again.`,
+        };
+    if (!versionAtLeast(version, minimumCodexCliVersion))
+        return {
+            kind: "cli",
+            installed: true,
+            version,
+            issue: `Codex CLI ${minimumCodexCliVersion} or newer is required; version ${version} is installed. Update Codex CLI and try again.`,
+        };
+    return { kind: "cli", installed: true, version };
+}
+function versionAtLeast(version, minimum) {
+    const candidate = comparableVersion(version);
+    const floor = comparableVersion(minimum);
+    if (candidate === undefined || floor === undefined)
+        return false;
+    for (let index = 0; index < 3; index++) {
+        const current = candidate.parts[index] ?? 0n;
+        const required = floor.parts[index] ?? 0n;
+        if (current !== required)
+            return current > required;
+    }
+    return !(candidate.prerelease && !floor.prerelease);
+}
+function comparableVersion(version) {
+    const parsed = /^(\d+)\.(\d+)(?:\.(\d+))?(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/.exec(version);
+    if (parsed === null)
+        return undefined;
+    return {
+        parts: [BigInt(parsed[1] ?? "0"), BigInt(parsed[2] ?? "0"), BigInt(parsed[3] ?? "0")],
+        prerelease: parsed[4] !== undefined,
+    };
 }
 // `claude --version` answers "2.1.258 (Claude Code)" and `codex --version` answers
 // "codex-cli 0.149.1", so the version is the first dotted number on the output rather

package/dist/slices/settings/tutorial-schema.js

@@ -0,0 +1,39 @@
+import { z } from "zod";
+export const tutorialSessionSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    active: z.boolean(),
+    stepId: z.enum([
+        "text-key",
+        "audio-key",
+        "image-key",
+        "voice",
+        "article-name",
+        "article-body",
+        "article-keywords",
+        "article-save",
+        "image-prompt",
+        "image-save",
+        "play-options",
+        "play-article",
+        "play-keywords",
+        "play-audio",
+        "play-images",
+        "play-video",
+        "play-subtitles",
+        "play-start",
+        "project",
+        "download",
+    ]),
+    articleId: z.string().optional(),
+    imageId: z.string().optional(),
+    projectId: z.string().optional(),
+})
+    .strict();
+export const tutorialWriteSchema = z
+    .object({
+    baseVersion: z.number().int().nonnegative(),
+    mutationId: z.uuid(),
+    session: tutorialSessionSchema,
+})
+    .strict();

package/dist/slices/settings/tutorial.js

@@ -0,0 +1,66 @@
+import { z } from "zod";
+import { transact } from "../../kernel/db/tx.js";
+import { fingerprint } from "../../kernel/runner/work.js";
+import { readSetting, writeSetting } from "./repo.js";
+import { tutorialSessionSchema, tutorialWriteSchema, } from "./tutorial-schema.js";
+export { tutorialSessionSchema, tutorialWriteSchema, } from "./tutorial-schema.js";
+const recordSchema = z
+    .object({
+    version: z.number().int().positive(),
+    session: tutorialSessionSchema,
+    mutationId: z.uuid(),
+    requestHash: z.string().regex(/^[a-f0-9]{64}$/),
+})
+    .strict();
+function readRecord(db) {
+    const raw = readSetting(db, "tutorial.session");
+    if (raw === undefined)
+        return undefined;
+    let value;
+    try {
+        value = JSON.parse(raw);
+    }
+    catch (error) {
+        if (!(error instanceof SyntaxError))
+            throw error;
+        return null;
+    }
+    const result = recordSchema.safeParse(value);
+    return result.success ? result.data : null;
+}
+export function readTutorial(db) {
+    const record = readRecord(db);
+    return {
+        version: record?.version ?? 0,
+        session: record?.session ?? { schemaVersion: 1, active: false, stepId: "text-key" },
+        readable: record !== null,
+    };
+}
+export function saveTutorial(db, input) {
+    const parsed = tutorialWriteSchema.parse(input);
+    const { baseVersion, session, mutationId } = parsed;
+    const requestHash = fingerprint(z.json().parse(JSON.parse(JSON.stringify(parsed))));
+    return transact(db, () => {
+        const current = readRecord(db);
+        if (current === null)
+            return { ok: false, reason: "unreadable" };
+        if (current?.mutationId === mutationId) {
+            return current.requestHash === requestHash
+                ? {
+                    ok: true,
+                    value: { version: current.version, session: current.session, readable: true },
+                }
+                : { ok: false, reason: "conflict" };
+        }
+        if ((current?.version ?? 0) !== baseVersion || baseVersion === Number.MAX_SAFE_INTEGER)
+            return { ok: false, reason: "conflict" };
+        const next = { version: baseVersion + 1, session, mutationId, requestHash };
+        writeSetting(db, "tutorial.session", JSON.stringify(next));
+        return { ok: true, value: { version: next.version, session, readable: true } };
+    });
+}
+export function resetTutorial(db) {
+    transact(db, () => {
+        db.prepare("DELETE FROM settings WHERE key = ?").run("tutorial.session");
+    });
+}

package/dist/slices/storage/assets.js

@@ -0,0 +1,108 @@
+import { closeSync, fchmodSync, fstatSync, fsyncSync, mkdirSync, openSync, rmSync, writeFileSync, } from "node:fs";
+import { basename, dirname, isAbsolute, relative, sep } from "node:path";
+import { redact } from "../../kernel/log.js";
+import { outputPath } from "./layout.js";
+export function allocateAsset(deps, projectId, filename) {
+    requireBasename(filename);
+    const id = deps.ids.next();
+    requireBasename(id);
+    const path = `assets/${id}/${filename}`;
+    const absolutePath = outputPath(deps.paths, projectId, path);
+    const directory = outputPath(deps.paths, projectId, `assets/${id}`);
+    if (dirname(absolutePath) !== directory)
+        throw new Error("Asset filenames must be basenames.");
+    mkdirSync(outputPath(deps.paths, projectId, "assets"), { recursive: true, mode: 0o700 });
+    mkdirSync(directory, { mode: 0o700 });
+    return { id, projectId, path, absolutePath };
+}
+export function sealAsset(deps, pending) {
+    const file = openSync(pending.absolutePath, "r+");
+    try {
+        const stats = fstatSync(file);
+        if (!stats.isFile())
+            throw new Error("An asset must be a regular file.");
+        fchmodSync(file, 0o600);
+        fsyncSync(file);
+        return {
+            id: pending.id,
+            projectId: pending.projectId,
+            path: pending.path,
+            bytes: stats.size,
+            createdAt: deps.clock.now().toISOString(),
+        };
+    }
+    finally {
+        closeSync(file);
+    }
+}
+export function writeAsset(deps, projectId, filename, bytes) {
+    const pending = allocateAsset(deps, projectId, filename);
+    try {
+        writeFileSync(pending.absolutePath, bytes, { flag: "wx", mode: 0o600, flush: true });
+        return sealAsset(deps, pending);
+    }
+    catch (error) {
+        try {
+            rmSync(dirname(pending.absolutePath), { recursive: true, force: true });
+        }
+        catch (cleanupError) {
+            warnCleanup(deps, projectId, cleanupError);
+        }
+        throw error;
+    }
+}
+export function discardPreparedAssets(deps, assets) {
+    for (const asset of assets) {
+        try {
+            requireBasename(asset.id);
+            const filename = basename(asset.path);
+            requireBasename(filename);
+            if (asset.path !== `assets/${asset.id}/${filename}`) {
+                throw new Error("A prepared asset must belong to its allocated directory.");
+            }
+            const directory = outputPath(deps.paths, asset.projectId, `assets/${asset.id}`);
+            const registered = deps.db
+                .prepare("SELECT id,path FROM project_assets WHERE project_id=?")
+                .all(asset.projectId);
+            const retained = registered.some((row) => {
+                if (row.id === asset.id)
+                    return true;
+                if (typeof row.path !== "string")
+                    throw new Error("A registered asset must name a path.");
+                const inside = relative(directory, outputPath(deps.paths, asset.projectId, row.path));
+                return (inside === "" ||
+                    (inside !== ".." && !inside.startsWith(`..${sep}`) && !isAbsolute(inside)));
+            });
+            if (!retained)
+                rmSync(directory, { recursive: true, force: true });
+        }
+        catch (error) {
+            warnCleanup(deps, asset.projectId, error);
+        }
+    }
+}
+function requireBasename(filename) {
+    if (filename === "" ||
+        filename === "." ||
+        filename === ".." ||
+        /[<>:"/\\|?*]/.test(filename) ||
+        [...filename].some((character) => {
+            const code = character.codePointAt(0) ?? 0;
+            return code < 0x20 || code === 0x7f;
+        }) ||
+        /[. ]$/.test(filename) ||
+        /^(?:con|prn|aux|nul|conin\$|conout\$|com[1-9¹²³]|lpt[1-9¹²³])(?:\.|$)/i.test(filename))
+        throw new Error("Asset filenames must be portable basenames.");
+}
+function messageOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function warnCleanup(deps, projectId, error) {
+    try {
+        deps.log.write("warn", "asset.cleanup", { projectId, detail: messageOf(error) });
+    }
+    catch (loggingError) {
+        // A full disk can prevent both cleanup and file logging; preserve the write error.
+        process.emitWarning(redact(`asset.cleanup ${projectId}: ${messageOf(error)}; logging failed: ${messageOf(loggingError)}`));
+    }
+}

package/dist/slices/storage/delete-project.js

@@ -6,7 +6,8 @@ export function deleteProject(deps, projectId) {
     if (!projectExists(deps.db, projectId)) {
         return { ok: false, reason: "no-project" };
     }
-    if (derive(stagesOf(deps.db, projectId)) === "running") {
+    if (deps.hasInflight?.(projectId) === true ||
+        derive(stagesOf(deps.db, projectId)) === "running") {
         return { ok: false, reason: "running" };
     }
     // Files first, rows second. A folder that would not go leaves the project listed; rows

package/dist/slices/storage/downloads.js

@@ -62,7 +62,7 @@ export function findDownload(deps, projectId, asset) {
             path,
             filename: downloadName(slugOf(title), output),
             bytes: stats,
-            contentType: contentTypes[extname(output.path).toLowerCase()] ?? "application/octet-stream",
+            contentType: contentTypeOf(path),
         },
     };
 }
@@ -100,3 +100,6 @@ function sizeOf(path) {
     const stats = statSync(path, { throwIfNoEntry: false });
     return stats === undefined || !stats.isFile() ? undefined : stats.size;
 }
+export function contentTypeOf(path) {
+    return contentTypes[extname(path).toLowerCase()] ?? "application/octet-stream";
+}