@gentbajko/slopify 0.1.0

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

@@ -0,0 +1,134 @@
+import { spawn } from "node:child_process";
+import { z } from "zod";
+import { redact } from "../../kernel/log.js";
+import { providerError } from "../../kernel/ports/model.js";
+// ceiling: the last 8 KiB of stderr is kept. A CLI that writes megabytes of progress there
+// would otherwise be held in memory for the length of a run, and the tail is the part that
+// 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 function nodeRunCli(binary, args, signal) {
+    // 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 because `codex exec` appends piped stdin to the prompt, and a pipe
+    // nobody closes would leave it waiting for an EOF that never comes.
+    // `signal` is how the child dies: Node sends it SIGTERM when the stage is cancelled, so
+    // no agent session outlives the run that started it (`logic/13`).
+    const child = spawn(binary, [...args], {
+        signal,
+        stdio: ["ignore", "pipe", "pipe"],
+        windowsHide: true,
+    });
+    let stderr = "";
+    const errorStream = child.stderr;
+    if (errorStream !== null) {
+        errorStream.setEncoding("utf8");
+        errorStream.on("data", (piece) => {
+            stderr = (stderr + piece).slice(-stderrMax);
+        });
+    }
+    let spawnError = null;
+    // A process that could not be spawned emits `error`, and an unlistened `error` is thrown
+    // at the process. It is recorded rather than rethrown so the one place that reports a
+    // failed run is the caller reading `ended`.
+    child.on("error", (error) => {
+        spawnError = error;
+    });
+    const ended = new Promise((resolve) => {
+        const settle = (code) => {
+            resolve({ code, error: spawnError });
+        };
+        child.once("close", settle);
+        // `close` follows `error` when the streams were opened; this is the belt for the case
+        // where they were not.
+        child.once("error", () => {
+            setImmediate(() => {
+                settle(null);
+            });
+        });
+    });
+    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();
+            }
+        },
+    };
+}
+// ceiling: both CLIs take one prompt string, so a system or assistant turn is flattened
+// into it under a header rather than being sent as its own message. Claude Code's
+// `--append-system-prompt` is the upgrade if a stage ever needs a real system turn; today
+// `logic/06` and `logic/07` each compose exactly one user message.
+export function promptOf(messages) {
+    return messages
+        .map((message) => message.role === "user" ? message.content : `[${message.role}]\n${message.content}`)
+        .join("\n\n");
+}
+// A bare non-zero exit tells the user nothing, so whatever the CLI put on stderr is what
+// the stage shows (`logic/01` unhappy paths: the provider's error text verbatim).
+export function endedWithout(binary, ended, stderr) {
+    const said = redact(stderr.trim());
+    const how = ended.error === null
+        ? `exited ${ended.code === null ? "on a signal" : String(ended.code)}`
+        : `could not be started (${redact(ended.error.message)})`;
+    return said === ""
+        ? `the ${binary} CLI ${how} without answering`
+        : `the ${binary} CLI ${how} without answering: ${said}`;
+}
+// Unreachable while stdio names `pipe` for fd 1; it is here so the type carries no null
+// and no non-null assertion is needed to read the stream.
+const nothing = {
+    [Symbol.asyncIterator]: () => ({
+        next: () => Promise.resolve({ done: true, value: undefined }),
+    }),
+};
+const typed = z.object({ type: z.string() });
+// A JSONL line off a CLI's stdout. The raw value travels with its `type` because a schema
+// that names only `type` strips every other key, and each event's own shape is checked
+// against the schema that knows it.
+export function cliEvent(binary, line) {
+    const value = safeJson(line);
+    const parsed = typed.safeParse(value);
+    if (!parsed.success) {
+        // A line that will not parse is a stream cut mid-write or a format this app does not
+        // know. The text is not echoed back: half a JSON object is noise to the user.
+        throw providerError({
+            kind: "other",
+            message: `the ${binary} CLI wrote a line this app could not read`,
+        });
+    }
+    return { type: parsed.data.type, value };
+}
+export function cliShaped(binary, schema, value) {
+    const parsed = schema.safeParse(value);
+    if (!parsed.success) {
+        throw providerError({
+            kind: "other",
+            message: `the ${binary} CLI wrote an event this app could not read`,
+        });
+    }
+    return parsed.data;
+}
+async function* bytesOf(source) {
+    for await (const piece of source) {
+        if (typeof piece === "string") {
+            yield new TextEncoder().encode(piece);
+            continue;
+        }
+        if (piece instanceof Uint8Array) {
+            yield piece;
+        }
+    }
+}
+function safeJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/adapters/llm/sse-lines.js

@@ -0,0 +1,46 @@
+// Bytes off a socket or off a child's stdout, turned into the units above them. One file
+// for both because OpenRouter's SSE and the two CLIs' JSONL differ only in what a line
+// means, and 05-dependencies records the decision: global `fetch` at rung 3, this reader
+// at rung 6, no SDK for any of the three providers.
+// A chunk boundary lands wherever the network or the pipe put it: between two lines, in
+// the middle of one, or inside a multi-byte character. TextDecoder's streaming mode holds
+// back the tail of a split UTF-8 sequence instead of emitting a replacement character,
+// and the leftover buffer holds back a split line.
+export async function* lines(chunks, signal) {
+    const decoder = new TextDecoder("utf-8");
+    let buffer = "";
+    for await (const chunk of chunks) {
+        signal?.throwIfAborted();
+        buffer += decoder.decode(chunk, { stream: true });
+        for (let at = buffer.indexOf("\n"); at !== -1; at = buffer.indexOf("\n")) {
+            yield withoutCr(buffer.slice(0, at));
+            buffer = buffer.slice(at + 1);
+        }
+    }
+    buffer += decoder.decode();
+    // A producer that ends without a trailing newline still wrote a whole line, and one cut
+    // off mid-line wrote a broken one. Both are handed on: the caller's parse is what tells
+    // a complete last line from a truncated stream, and it must not be robbed of the
+    // evidence by a reader that quietly drops the remainder.
+    if (buffer !== "") {
+        yield withoutCr(buffer);
+    }
+}
+// The `data:` payloads of an SSE stream, in order. Comment lines - which is what
+// OpenRouter's ": OPENROUTER PROCESSING" keep-alive is - and the blank lines between
+// events carry nothing, and neither do the `id:`, `event:` and `retry:` fields.
+// ceiling: one `data:` line is one payload. The spec folds consecutive `data:` lines of
+// an event into one value joined by newlines; no provider here sends them, and buffering
+// until the blank line is the upgrade when one does.
+export async function* sseData(chunks, signal) {
+    for await (const line of lines(chunks, signal)) {
+        if (!line.startsWith("data:")) {
+            continue;
+        }
+        // The spec strips one leading space after the colon and nothing else.
+        yield line.slice(5).replace(/^ /, "");
+    }
+}
+function withoutCr(line) {
+    return line.endsWith("\r") ? line.slice(0, -1) : line;
+}

package/dist/adapters/retry-after.js

@@ -0,0 +1,21 @@
+// `logic/01` §Q4: a 429 naming a Retry-After replaces the fixed backoff for that wait.
+// RFC 9110 allows seconds or an HTTP date; `Date.parse` is the platform's own reader for
+// the second form, so no date parsing is written here.
+//
+// It sits beside the adapters rather than inside one because the rule is the retry
+// policy's, not any provider's: four adapters read the same header off the same kind of
+// response. Nothing else is shared between them.
+export function retryAfter(header) {
+    if (header === null) {
+        return undefined;
+    }
+    const value = header.trim();
+    if (/^\d+$/.test(value)) {
+        return Number(value) * 1000;
+    }
+    const at = Date.parse(value);
+    if (Number.isNaN(at)) {
+        return undefined;
+    }
+    return Math.max(0, at - Date.now());
+}

package/dist/adapters/tts/cartesia.js

@@ -0,0 +1,105 @@
+import { z } from "zod";
+import { redact } from "../../kernel/log.js";
+import { providerError } from "../../kernel/ports/model.js";
+import { retryAfter } from "../retry-after.js";
+// The HTTP gateway adapter for Cartesia (01-architecture Module boundaries). `fetch` and
+// nothing else; `/tts/bytes` streams the audio it renders, so the response body is
+// already the stream the port asks for.
+export const cartesiaBase = "https://api.cartesia.ai";
+// Cartesia pins behaviour to a dated version header and refuses a request without one.
+// This is the version the request bodies below are written against, so it is sent as a
+// constant rather than left to the account's default.
+export const cartesiaVersion = "2026-03-01";
+export const cartesiaModel = "sonic-3.5";
+// mp3 is the port's container; `bit_rate` is required for it and `sample_rate` fixes the
+// rate the concatenation of `logic/08` step 4 then keeps.
+const outputFormat = { container: "mp3", bit_rate: 128_000, sample_rate: 44_100 };
+// The structured error of API version 2026-03-01 and newer.
+const errorBody = z.object({
+    error_code: z.string().optional(),
+    title: z.string().optional(),
+    message: z.string().optional(),
+});
+export function cartesiaTts(deps) {
+    return {
+        id: "cartesia",
+        capabilities: { streams: true },
+        synthesize: async (req) => {
+            const response = await deps.fetch(`${cartesiaBase}/tts/bytes`, {
+                method: "POST",
+                signal: req.signal,
+                headers: {
+                    "X-API-Key": keyOf(deps),
+                    "Cartesia-Version": cartesiaVersion,
+                    "Content-Type": "application/json",
+                },
+                // `logic/08` §Q69: no pre-check on length; Cartesia's own limit surfaces as its
+                // error. `language` is left out so the model reads it off the transcript.
+                body: JSON.stringify({
+                    model_id: cartesiaModel,
+                    transcript: req.text,
+                    voice: { mode: "id", id: req.voiceId },
+                    output_format: outputFormat,
+                }),
+            });
+            if (!response.ok) {
+                throw await failure(response, req.voiceId);
+            }
+            if (response.body === null) {
+                throw providerError({ kind: "other", message: "Cartesia answered with no audio" });
+            }
+            return { audio: response.body, container: "mp3" };
+        },
+    };
+}
+function keyOf(deps) {
+    const key = deps.key();
+    // `logic/02` §Q13: an absent key is terminal, so it never becomes a request.
+    if (key === undefined || key === "") {
+        throw providerError({ kind: "missing_key", message: "no Cartesia key is stored" });
+    }
+    return key;
+}
+function kindOf(status) {
+    if (status === 401 || status === 403) {
+        return "auth";
+    }
+    // `concurrency_limited` is the plan's own limit and arrives as a 429 like any other, so
+    // the status is enough and the code below only reaches the message.
+    if (status === 429) {
+        return "rate_limit";
+    }
+    // ceiling: as in the other two adapters, everything else is `other` and is retried.
+    return "other";
+}
+async function failure(response, voiceId) {
+    const text = await response.text().catch(() => "");
+    const message = redact(detailOf(text) || response.statusText);
+    const retryAfterMs = retryAfter(response.headers.get("retry-after"));
+    return providerError({
+        kind: kindOf(response.status),
+        // `logic/02` §Q14: `voice_not_found` has to say which voice was asked for; Cartesia's
+        // own message does not repeat the id.
+        message: `Cartesia answered ${response.status} for voice ${voiceId}: ${message}`,
+        ...(retryAfterMs === undefined ? {} : { retryAfterMs }),
+    });
+}
+function detailOf(text) {
+    const parsed = errorBody.safeParse(safeJson(text));
+    if (!parsed.success) {
+        return text.trim();
+    }
+    const { error_code: code, message } = parsed.data;
+    // The code is what an integration is told to switch on and the message is the sentence;
+    // both are the provider's own words, so both are shown.
+    const parts = [code, message].filter((part) => part !== undefined && part !== "");
+    return parts.length === 0 ? text.trim() : parts.join(": ");
+}
+function safeJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/adapters/tts/elevenlabs.js

@@ -0,0 +1,107 @@
+import { z } from "zod";
+import { redact } from "../../kernel/log.js";
+import { providerError } from "../../kernel/ports/model.js";
+import { retryAfter } from "../retry-after.js";
+// The HTTP gateway adapter for ElevenLabs (01-architecture Module boundaries). `fetch`
+// and nothing else: 05-dependencies records global `fetch` at rung 3, and the response
+// body already is the `ReadableStream<Uint8Array>` the port asks for, so an SDK would buy
+// nothing but a dependency.
+export const elevenLabsBase = "https://api.elevenlabs.io/v1";
+// The /stream endpoint rather than the plain one: `capabilities.streams` is true, and the
+// attempt wrapper measures its 120 s as an idle timeout between chunks only when bytes
+// keep arriving (`logic/01` §Q62).
+export const elevenLabsModel = "eleven_multilingual_v2";
+// mp3 at the port's container, 44.1 kHz, 128 kbps: `kernel/ports/tts.ts` fixes mp3 and
+// `logic/08` step 4 keeps the provider's own sample rate through the concatenation.
+export const elevenLabsFormat = "mp3_44100_128";
+// A wire payload is narrowed, never cast. `detail` is an object on a handled failure and
+// a string on the framework's own; anything else falls back to the raw text.
+const errorBody = z.object({
+    detail: z.union([
+        z.object({ status: z.string().optional(), message: z.string().optional() }),
+        z.string(),
+    ]),
+});
+export function elevenLabsTts(deps) {
+    return {
+        id: "elevenlabs",
+        capabilities: { streams: true },
+        synthesize: async (req) => {
+            const voice = encodeURIComponent(req.voiceId);
+            const response = await deps.fetch(`${elevenLabsBase}/text-to-speech/${voice}/stream?output_format=${elevenLabsFormat}`, {
+                method: "POST",
+                signal: req.signal,
+                headers: { "xi-api-key": keyOf(deps), "Content-Type": "application/json" },
+                // `logic/08` §Q69: no pre-check on length. A text past the model's limit comes
+                // back as the provider's own 400 and that is what the stage shows.
+                body: JSON.stringify({ text: req.text, model_id: elevenLabsModel }),
+            });
+            if (!response.ok) {
+                throw await failure(response, req.voiceId);
+            }
+            if (response.body === null) {
+                throw providerError({ kind: "other", message: "ElevenLabs answered with no audio" });
+            }
+            return { audio: response.body, container: "mp3" };
+        },
+    };
+}
+function keyOf(deps) {
+    const key = deps.key();
+    // `logic/02` §Q13: an attempt that finds no key fails rather than calling anonymously.
+    // `missing_key` rather than `auth` because the same rule makes it terminal.
+    if (key === undefined || key === "") {
+        throw providerError({ kind: "missing_key", message: "no ElevenLabs key is stored" });
+    }
+    return key;
+}
+// Only the adapter can read a vendor's status code, so only the adapter names the kind;
+// the attempt wrapper maps it and nothing downstream classifies again (03-conventions).
+function kindOf(status) {
+    if (status === 401 || status === 403) {
+        return "auth";
+    }
+    if (status === 429) {
+        return "rate_limit";
+    }
+    // ceiling: everything else is `other` and is retried, so a text past the character
+    // limit fails the same way four times over. A terminal kind for "this request will
+    // never work" would have to be added to the port's error contract first, which is not
+    // this adapter's to widen.
+    return "other";
+}
+async function failure(response, voiceId) {
+    const text = await response.text().catch(() => "");
+    // The provider's own words, verbatim, through the same redactor the wrapper uses: an
+    // error body is free to quote the key back and this is the first place it is held.
+    const message = redact(detailOf(text) || response.statusText);
+    const retryAfterMs = retryAfter(response.headers.get("retry-after"));
+    return providerError({
+        kind: kindOf(response.status),
+        // `logic/02` §Q14: a rejected voice ID has to be named, and it is the one part of the
+        // request the user chose. It is not secret, unlike everything else on the wire.
+        message: `ElevenLabs answered ${response.status} for voice ${voiceId}: ${message}`,
+        ...(retryAfterMs === undefined ? {} : { retryAfterMs }),
+    });
+}
+function detailOf(text) {
+    const parsed = errorBody.safeParse(safeJson(text));
+    if (!parsed.success) {
+        return text.trim();
+    }
+    const { detail } = parsed.data;
+    if (typeof detail === "string") {
+        return detail;
+    }
+    // Both halves are kept: the status is the machine-readable reason
+    // (`max_character_limit_exceeded`, `voice_not_found`) and the message is the sentence.
+    return [detail.status, detail.message].filter((part) => part !== undefined).join(": ");
+}
+function safeJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/adapters/tts/openai.js

@@ -0,0 +1,95 @@
+import { z } from "zod";
+import { redact } from "../../kernel/log.js";
+import { providerError } from "../../kernel/ports/model.js";
+import { retryAfter } from "../retry-after.js";
+// The HTTP gateway adapter for OpenAI's speech endpoint (01-architecture Module
+// boundaries). `fetch` and nothing else; the response body is already the stream the port
+// asks for.
+export const openAiAudioBase = "https://api.openai.com/v1";
+// 05-dependencies lists gpt-4o-mini-tts, tts-1 and tts-1-hd; the first is the current one
+// and the cheapest of the three per character.
+export const openAiTtsModel = "gpt-4o-mini-tts";
+const errorBody = z.object({
+    error: z.object({ message: z.string(), code: z.string().nullish() }),
+});
+// A voice the user cloned is addressed as an object rather than by name: the request
+// schema takes either a built-in name (`alloy`, `nova`, ...) or `{ id: "voice_1234" }`,
+// and a custom id sent as a bare string is refused. The prefix is what tells them apart.
+const customVoice = /^voice_/;
+export function openAiTts(deps) {
+    return {
+        id: "openai-tts",
+        capabilities: { streams: true },
+        synthesize: async (req) => {
+            const response = await deps.fetch(`${openAiAudioBase}/audio/speech`, {
+                method: "POST",
+                signal: req.signal,
+                headers: {
+                    Authorization: `Bearer ${keyOf(deps)}`,
+                    "Content-Type": "application/json",
+                },
+                // `logic/08` §Q69: the 4096-character cap is not checked here. A longer text
+                // comes back as OpenAI's own 400 and that is what the stage shows, so a user who
+                // chose Whole text learns the limit from the provider that set it.
+                body: JSON.stringify({
+                    model: openAiTtsModel,
+                    input: req.text,
+                    voice: voiceOf(req.voiceId),
+                    response_format: "mp3",
+                }),
+            });
+            if (!response.ok) {
+                throw await failure(response, req.voiceId);
+            }
+            if (response.body === null) {
+                throw providerError({ kind: "other", message: "OpenAI answered with no audio" });
+            }
+            return { audio: response.body, container: "mp3" };
+        },
+    };
+}
+function voiceOf(voiceId) {
+    return customVoice.test(voiceId) ? { id: voiceId } : voiceId;
+}
+function keyOf(deps) {
+    const key = deps.key();
+    // `logic/02` §Q13: an absent key is terminal, so it never becomes a request.
+    if (key === undefined || key === "") {
+        throw providerError({ kind: "missing_key", message: "no OpenAI key is stored" });
+    }
+    return key;
+}
+function kindOf(status) {
+    if (status === 401 || status === 403) {
+        return "auth";
+    }
+    if (status === 429) {
+        return "rate_limit";
+    }
+    // ceiling: as in the OpenRouter adapter, a 400 is retried three more times because the
+    // port's error contract has no terminal kind for a request that cannot be repaired.
+    return "other";
+}
+async function failure(response, voiceId) {
+    const text = await response.text().catch(() => "");
+    const parsed = errorBody.safeParse(safeJson(text));
+    // Verbatim, through the same redactor the wrapper uses: OpenAI's own 401 quotes the
+    // start of the key back at the caller.
+    const message = redact(parsed.success ? parsed.data.error.message : text.trim() || response.statusText);
+    const retryAfterMs = retryAfter(response.headers.get("retry-after"));
+    return providerError({
+        kind: kindOf(response.status),
+        // `logic/02` §Q14: the voice ID is named, so a rejected voice reads differently from
+        // a rejected key.
+        message: `OpenAI answered ${response.status} for voice ${voiceId}: ${message}`,
+        ...(retryAfterMs === undefined ? {} : { retryAfterMs }),
+    });
+}
+function safeJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/edge/cli.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+import { parseArgs } from "node:util";
+import { configFrom } from "../kernel/config/index.js";
+import { boot } from "../main.js";
+import { openBrowser } from "./open-browser.js";
+const { values } = parseArgs({
+    options: {
+        port: { type: "string" },
+        host: { type: "string" },
+        "data-dir": { type: "string" },
+        "no-open": { type: "boolean" },
+    },
+});
+try {
+    const config = configFrom(values, process.env);
+    const { paths, url, stop } = await boot(config);
+    console.log(`Slopify is running at ${url}`);
+    console.log(`Slopify data directory: ${paths.dataDir}`);
+    console.log(`Database: ${paths.db}`);
+    console.log(`Logs: ${paths.logs}`);
+    if (config.host !== "127.0.0.1") {
+        console.warn(`WARNING: bound to ${config.host} - anyone who reaches this port controls the app and its keys (no login).`);
+    }
+    if (config.open) {
+        openBrowser(url, (message) => {
+            console.warn(message);
+        });
+    }
+    process.on("SIGINT", () => {
+        stop().then(() => process.exit(0), () => process.exit(1));
+    });
+}
+catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+}

package/dist/edge/events/hub.js

@@ -0,0 +1,76 @@
+export function createHub(deps) {
+    const projects = new Map();
+    const globals = new Set();
+    // The tally a page needs before anything else happens. The runner emits it when it
+    // changes, so the newest one is kept here and replayed to whoever opens next; a page
+    // that loads mid-render would otherwise be told nothing is running.
+    let tally = { type: "running.count", count: 0 };
+    const send = (subscriber, event) => {
+        // writeSSE rejects on a socket that is already gone, asynchronously and long after
+        // emit() returned, so a dead subscriber is dropped here instead of at the call site.
+        subscriber.stream
+            .writeSSE({ event: event.type, data: JSON.stringify(event), id: deps.ids.next() })
+            .catch((error) => {
+            subscriber.drop();
+            deps.log.write("warn", "sse.write", { detail: `${event.type}: ${messageOf(error)}` });
+        });
+    };
+    const join = (set, stream, signal, prune) => {
+        let finish = () => { };
+        const done = new Promise((resolve) => {
+            finish = resolve;
+        });
+        const subscriber = {
+            stream,
+            done,
+            drop: () => {
+                if (set.delete(subscriber)) {
+                    prune();
+                }
+                finish();
+            },
+        };
+        set.add(subscriber);
+        if (signal.aborted) {
+            subscriber.drop();
+        }
+        else {
+            signal.addEventListener("abort", subscriber.drop, { once: true });
+        }
+        return subscriber;
+    };
+    return {
+        subscribe: (projectId, stream, signal) => {
+            const set = projects.get(projectId) ?? new Set();
+            projects.set(projectId, set);
+            return join(set, stream, signal, () => {
+                if (set.size === 0) {
+                    projects.delete(projectId);
+                }
+            }).done;
+        },
+        subscribeGlobal: (stream, signal) => {
+            const subscriber = join(globals, stream, signal, () => { });
+            if (globals.has(subscriber)) {
+                send(subscriber, tally);
+            }
+            return subscriber.done;
+        },
+        emit: (projectId, event) => {
+            for (const subscriber of projects.get(projectId) ?? []) {
+                send(subscriber, event);
+            }
+        },
+        emitGlobal: (event) => {
+            if (event.type === "running.count") {
+                tally = event;
+            }
+            for (const subscriber of globals) {
+                send(subscriber, event);
+            }
+        },
+    };
+}
+function messageOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}