@gentbajko/slopify 2.5.0 → 3.0.1

package/dist/slices/run-cost/meter.js

@@ -0,0 +1,47 @@
+import { planAccountOf } from "../../kernel/ports/plan-limits.js";
+import { resolveChannelId, scheduleChannel } from "../channels/repo.js";
+import { priceCall } from "./pricing.js";
+// Prices each call as it lands and keeps it with the rates it used; a CLI's plan windows go
+// beside it. Separate from the anonymous telemetry log: this is per project, never leaves the
+// machine, and is kept whether or not the usage-stats notice was dismissed.
+export function createUsageMeter(deps) {
+    return {
+        record: (call) => {
+            const priced = priceCall(call, deps.catalogue());
+            const at = deps.clock.now().toISOString();
+            deps.db
+                .prepare(`INSERT INTO provider_usage (id, project_id, stage, kind, provider, model, tokens_in, tokens_out, tokens_cached, characters, images, seconds, size, quality, wall_ms, on_plan, cost, api_model, api_cost, price_json, created_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(deps.ids.next(), call.projectId, call.stage, call.kind, call.provider, call.model, call.tokensIn ?? null, call.tokensOut ?? null, call.cachedTokens ?? null, call.characters ?? null, call.images ?? null, call.seconds ?? null, call.size ?? null, call.quality ?? null, Math.round(call.wallMs), priced.onPlan ? 1 : 0, priced.cost, priced.apiModel, priced.apiCost, priced.price === null ? null : JSON.stringify(priced.price), at);
+            const account = planAccountOf(call.provider);
+            if (account !== undefined && call.limits !== undefined)
+                deps.db
+                    .prepare("INSERT INTO plan_limit_readings (id, project_id, account, reading_json, created_at) VALUES (?, ?, ?, ?, ?)")
+                    .run(deps.ids.next(), call.projectId, account, JSON.stringify(call.limits), at);
+        },
+    };
+}
+// The same pricing for a call made outside a project (`kernel/runner/standalone.ts`), kept
+// against its schedule or channel with the channel it counts under on Home.
+export function createStandaloneMeter(deps) {
+    return {
+        record: (call) => {
+            const priced = priceCall(call, deps.catalogue());
+            const account = planAccountOf(call.provider);
+            const reading = account !== undefined && call.limits !== undefined
+                ? { account, json: JSON.stringify(call.limits) }
+                : undefined;
+            deps.db
+                .prepare(`INSERT INTO standalone_usage (id, owner_kind, owner_id, channel_id, purpose, kind, provider, model, tokens_in, tokens_out, tokens_cached, characters, images, seconds, size, quality, wall_ms, on_plan, cost, api_model, api_cost, price_json, account, reading_json, created_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(deps.ids.next(), call.owner.kind, call.owner.id, channelOf(deps.db, call.owner), call.purpose, call.kind, call.provider, call.model, call.tokensIn ?? null, call.tokensOut ?? null, call.cachedTokens ?? null, call.characters ?? null, call.images ?? null, call.seconds ?? null, call.size ?? null, call.quality ?? null, Math.round(call.wallMs), priced.onPlan ? 1 : 0, priced.cost, priced.apiModel, priced.apiCost, priced.price === null ? null : JSON.stringify(priced.price), reading?.account ?? null, reading?.json ?? null, deps.clock.now().toISOString());
+        },
+    };
+}
+// A schedule counts under its template's channel; one whose template is gone, like a channel
+// this install doesn't have, under the default channel.
+function channelOf(db, owner) {
+    return owner.kind === "schedule"
+        ? resolveChannelId(db, scheduleChannel(db, owner.id)?.id)
+        : resolveChannelId(db, owner.id);
+}

package/dist/slices/run-cost/panel.js

@@ -0,0 +1,256 @@
+import { z } from "zod";
+import { stageKinds } from "../../kernel/pipeline.js";
+import { planAccountNames, planAccountOf, planAccounts, } from "../../kernel/ports/plan-limits.js";
+const usageRow = z.object({
+    stage: z.enum(stageKinds),
+    kind: z.enum(["llm", "tts", "image", "video"]),
+    provider: z.string(),
+    model: z.string(),
+    tokens_in: z.number().nullable(),
+    tokens_out: z.number().nullable(),
+    tokens_cached: z.number().nullable(),
+    characters: z.number().nullable(),
+    images: z.number().nullable(),
+    seconds: z.number().nullable(),
+    on_plan: z.number(),
+    cost: z.number().nullable(),
+    api_model: z.string().nullable(),
+    api_cost: z.number().nullable(),
+    price_json: z.string().nullable(),
+});
+const windowSchema = z.object({
+    kind: z.enum(["five_hour", "weekly", "other"]),
+    usedPercent: z.number(),
+    resetsAt: z.string().nullable(),
+});
+const readingSchema = z.object({
+    before: z.array(windowSchema).optional(),
+    after: z.array(windowSchema).optional(),
+});
+const emptyTotals = {
+    tokensIn: 0,
+    tokensOut: 0,
+    cachedTokens: 0,
+    characters: 0,
+    images: 0,
+    seconds: 0,
+};
+const emptyLine = {
+    calls: 0,
+    cost: 0,
+    unpriced: 0,
+    apiEquivalent: null,
+    apiUnpriced: 0,
+};
+function add(into, row) {
+    const onPlan = row.on_plan === 1;
+    return {
+        ...into,
+        calls: into.calls + 1,
+        cost: into.cost + (row.cost ?? 0),
+        unpriced: into.unpriced + (row.cost === null ? 1 : 0),
+        apiEquivalent: onPlan ? (into.apiEquivalent ?? 0) + (row.api_cost ?? 0) : into.apiEquivalent,
+        apiUnpriced: into.apiUnpriced + (onPlan && row.api_cost === null ? 1 : 0),
+        tokensIn: into.tokensIn + (row.tokens_in ?? 0),
+        tokensOut: into.tokensOut + (row.tokens_out ?? 0),
+        cachedTokens: into.cachedTokens + (row.tokens_cached ?? 0),
+        characters: into.characters + (row.characters ?? 0),
+        images: into.images + (row.images ?? 0),
+        seconds: into.seconds + (row.seconds ?? 0),
+    };
+}
+export function runCostOf(db, projectId) {
+    const rows = db
+        .prepare("SELECT stage, kind, provider, model, tokens_in, tokens_out, tokens_cached, characters, images, seconds, on_plan, cost, api_model, api_cost, price_json FROM provider_usage WHERE project_id = ? ORDER BY created_at, rowid")
+        .all(projectId)
+        .map((row) => usageRow.parse(row));
+    const walls = stageWalls(db, projectId);
+    const stages = new Map();
+    const models = new Map();
+    let total = { ...emptyLine, ...emptyTotals };
+    let catalogueDate = null;
+    for (const row of rows) {
+        total = add(total, row);
+        stages.set(row.stage, add(stages.get(row.stage) ?? {
+            stage: row.stage,
+            wallMs: walls.get(row.stage) ?? null,
+            ...emptyLine,
+            ...emptyTotals,
+        }, row));
+        const key = JSON.stringify([row.provider, row.model, row.kind]);
+        models.set(key, add(models.get(key) ?? {
+            provider: row.provider,
+            model: row.model,
+            kind: row.kind,
+            onPlan: row.on_plan === 1,
+            apiModel: row.api_model,
+            ...emptyLine,
+            ...emptyTotals,
+        }, row));
+        catalogueDate = catalogueOf(row.price_json) ?? catalogueDate;
+    }
+    // A stage that ran with no provider call (a render, a document) still has its time.
+    for (const [stage, wallMs] of walls)
+        if (!stages.has(stage))
+            stages.set(stage, { stage, wallMs, ...emptyLine, ...emptyTotals });
+    const plans = planUses(db, projectId, rows);
+    return {
+        currency: "USD",
+        ...total,
+        totals: {
+            tokensIn: total.tokensIn,
+            tokensOut: total.tokensOut,
+            cachedTokens: total.cachedTokens,
+            characters: total.characters,
+            images: total.images,
+            seconds: total.seconds,
+            wallMs: [...walls.values()].reduce((sum, ms) => sum + ms, 0),
+        },
+        byStage: stageKinds.flatMap((kind) => {
+            const found = stages.get(kind);
+            return found === undefined ? [] : [found];
+        }),
+        byModel: [...models.values()].toSorted((left, right) => right.cost - left.cost ||
+            (right.apiEquivalent ?? 0) - (left.apiEquivalent ?? 0) ||
+            left.provider.localeCompare(right.provider) ||
+            left.model.localeCompare(right.model)),
+        plans,
+        waits: limitWaitsOf(db, projectId),
+        catalogueDate,
+    };
+}
+function catalogueOf(json) {
+    if (json === null)
+        return null;
+    const parsed = z.object({ catalogue: z.string() }).safeParse(JSON.parse(json));
+    return parsed.success ? parsed.data.catalogue : null;
+}
+function stageWalls(db, projectId) {
+    const walls = new Map();
+    for (const raw of db
+        .prepare("SELECT kind, started_at, finished_at FROM stages WHERE project_id = ?")
+        .all(projectId)) {
+        const row = z
+            .object({
+            kind: z.enum(stageKinds),
+            started_at: z.string().nullable(),
+            finished_at: z.string().nullable(),
+        })
+            .parse(raw);
+        if (row.started_at === null || row.finished_at === null)
+            continue;
+        const ms = Date.parse(row.finished_at) - Date.parse(row.started_at);
+        if (Number.isFinite(ms) && ms >= 0)
+            walls.set(row.kind, ms);
+    }
+    return walls;
+}
+// Two readings belong to the same window when their resets agree to within a few minutes;
+// a reset moving on means the window rolled over between them.
+const sameWindowMs = 5 * 60_000;
+export function windowUse(readings) {
+    const byKind = new Map();
+    for (const reading of readings)
+        for (const window of reading)
+            byKind.set(window.kind, [...(byKind.get(window.kind) ?? []), window]);
+    const uses = [];
+    for (const [kind, seen] of byKind) {
+        let used = 0;
+        for (let at = 1; at < seen.length; at += 1) {
+            const previous = seen[at - 1];
+            const current = seen[at];
+            if (previous === undefined || current === undefined)
+                continue;
+            const same = previous.resetsAt === current.resetsAt ||
+                (previous.resetsAt !== null &&
+                    current.resetsAt !== null &&
+                    Math.abs(Date.parse(previous.resetsAt) - Date.parse(current.resetsAt)) < sameWindowMs);
+            used += same ? Math.max(0, current.usedPercent - previous.usedPercent) : current.usedPercent;
+        }
+        const last = seen.at(-1);
+        if (last !== undefined)
+            uses.push({ kind, usedPercent: used, nowPercent: last.usedPercent, resetsAt: last.resetsAt });
+    }
+    const order = ["five_hour", "weekly", "other"];
+    return uses.toSorted((left, right) => order.indexOf(left.kind) - order.indexOf(right.kind));
+}
+function planUses(db, projectId, rows) {
+    const readings = db
+        .prepare("SELECT account, reading_json FROM plan_limit_readings WHERE project_id = ? ORDER BY created_at, rowid")
+        .all(projectId)
+        .map((row) => z.object({ account: z.string(), reading_json: z.string() }).parse(row));
+    return planAccounts.flatMap((account) => {
+        const calls = rows.filter((row) => planAccountOf(row.provider) === account).length;
+        if (calls === 0)
+            return [];
+        const sequence = [];
+        for (const row of readings) {
+            if (row.account !== account)
+                continue;
+            const parsed = readingSchema.safeParse(JSON.parse(row.reading_json));
+            if (!parsed.success)
+                continue;
+            if (parsed.data.before?.length)
+                sequence.push(parsed.data.before);
+            if (parsed.data.after?.length)
+                sequence.push(parsed.data.after);
+        }
+        return [
+            {
+                account,
+                name: planAccountNames[account],
+                calls,
+                reported: sequence.length > 0,
+                windows: windowUse(sequence),
+            },
+        ];
+    });
+}
+export function limitWaitsOf(db, projectId) {
+    return limitWaitRows(db, projectId).map((row) => row.wait);
+}
+// Every project's waits at once, for the lists that show "Waiting for Codex limits" on a row
+// (Projects, Home's Running now, the calendar) without asking once per project.
+export function limitWaitsByProject(db) {
+    const found = new Map();
+    for (const row of limitWaitRows(db)) {
+        const list = found.get(row.projectId) ?? [];
+        list.push(row.wait);
+        found.set(row.projectId, list);
+    }
+    return found;
+}
+// A wait as a list row carries it: the plan's name and times, not its account key.
+export function listingWait(wait) {
+    return { name: wait.name, stage: wait.stage, resetsAt: wait.resetsAt, retryAt: wait.retryAt };
+}
+function limitWaitRows(db, projectId) {
+    // Only a stage still running is waiting: a row left by a cancel or pause is not shown.
+    return db
+        .prepare(`SELECT w.project_id, w.account, w.stage, l.resets_at, l.retry_at FROM plan_limit_waiters w
+       JOIN plan_limit_waits l ON l.account = w.account
+       JOIN stages s ON s.project_id = w.project_id AND s.kind = w.stage AND s.state = 'running'
+       ${projectId === undefined ? "" : "WHERE w.project_id = ?"} ORDER BY w.since`)
+        .all(...(projectId === undefined ? [] : [projectId]))
+        .map((raw) => {
+        const row = z
+            .object({
+            project_id: z.string(),
+            account: z.enum(planAccounts),
+            stage: z.enum(stageKinds),
+            resets_at: z.string().nullable(),
+            retry_at: z.string(),
+        })
+            .parse(raw);
+        return {
+            projectId: row.project_id,
+            wait: {
+                account: row.account,
+                name: planAccountNames[row.account],
+                stage: row.stage,
+                resetsAt: row.resets_at,
+                retryAt: row.retry_at,
+            },
+        };
+    });
+}

package/dist/slices/run-cost/pricing.js

@@ -0,0 +1,95 @@
+import { isLocalCliProvider, systemVoiceProvider } from "../settings/model.js";
+// Per million tokens; cached input at its own rate when the catalogue gives one.
+export function tokenCost(rates, tokensIn, tokensOut, cachedTokens = 0) {
+    if (rates.inputPerMillionTokens === undefined || rates.outputPerMillionTokens === undefined)
+        return null;
+    const cached = Math.min(Math.max(0, cachedTokens), tokensIn);
+    return (((tokensIn - cached) * rates.inputPerMillionTokens +
+        cached * (rates.cachedInputPerMillionTokens ?? rates.inputPerMillionTokens) +
+        tokensOut * rates.outputPerMillionTokens) /
+        1_000_000);
+}
+// The API model a CLI's model is billed as when it is called through a key: Claude Code's
+// models are Anthropic's, Codex's are OpenAI's and Gemini's are Google's, all listed in the
+// catalogue under OpenRouter. A version the catalogue does not list has no API price.
+export function apiEquivalentOf(provider, model, catalogue) {
+    const listed = (id) => catalogue.llm.find((entry) => entry.provider === "openrouter" && entry.id === id);
+    // Context sizes ("[1m]") and dated snapshots ("-20251001") price as the model itself.
+    const bare = model
+        .replace(/\[[^\]]*\]/g, "")
+        .replace(/-\d{8}$/, "")
+        .trim();
+    if (provider === "claude-code") {
+        const family = /^(?:claude-)?(opus|sonnet|haiku|fable)(?:-(\d+)(?:-(\d{1,2}))?)?$/i.exec(bare);
+        if (family === null)
+            return undefined;
+        const name = (family[1] ?? "").toLowerCase();
+        if (family[2] !== undefined)
+            return listed(`anthropic/claude-${name}-${family[2]}${family[3] ? `.${family[3]}` : ""}`);
+        // An alias ("sonnet") is the newest of that family the catalogue lists.
+        return catalogue.llm
+            .filter((entry) => entry.provider === "openrouter" && entry.id.startsWith(`anthropic/claude-${name}-`))
+            .toSorted((left, right) => right.id.localeCompare(left.id, "en", { numeric: true }))[0];
+    }
+    if (bare === "" || bare === "codex-imagegen")
+        return undefined;
+    if (provider === "codex" || provider === "codex-image")
+        return listed(`openai/${bare}`);
+    if (provider === "gemini")
+        return listed(`google/${bare}`);
+    return undefined;
+}
+export function priceCall(call, catalogue) {
+    const date = catalogue.updatedAt;
+    if (isLocalCliProvider(call.provider)) {
+        // Only text is priced through the API: what a Codex image would cost there depends on
+        // how many drafts the agent drew, which the CLI does not say.
+        const api = call.kind === "llm" ? apiEquivalentOf(call.provider, call.model, catalogue) : undefined;
+        const apiCost = api === undefined || call.tokensIn === undefined || call.tokensOut === undefined
+            ? null
+            : tokenCost(api.pricing, call.tokensIn, call.tokensOut, call.cachedTokens);
+        return {
+            onPlan: true,
+            cost: 0,
+            apiModel: api?.id ?? null,
+            apiCost,
+            price: api === undefined ? null : { catalogue: date, model: api.id, ...api.pricing },
+        };
+    }
+    // The computer's own voice costs nothing.
+    if (call.provider === systemVoiceProvider)
+        return { onPlan: false, cost: 0, apiModel: null, apiCost: null, price: null };
+    const family = call.kind === "video" ? "image" : call.kind;
+    const entry = catalogue[family].find((model) => model.provider === call.provider && model.id === call.model);
+    const rates = entry?.pricing;
+    let cost = null;
+    if (rates !== undefined)
+        switch (call.kind) {
+            case "llm":
+                cost =
+                    call.tokensIn === undefined || call.tokensOut === undefined
+                        ? null
+                        : tokenCost(rates, call.tokensIn, call.tokensOut, call.cachedTokens);
+                break;
+            case "tts":
+                // ceiling: a per-minute voice is left unpriced rather than guessed from characters;
+                // the narration's measured length is known only after the stage writes the file.
+                cost =
+                    rates.perMillionCharacters === undefined || call.characters === undefined
+                        ? null
+                        : (call.characters / 1_000_000) * rates.perMillionCharacters;
+                break;
+            case "image":
+            case "video":
+                // An image-to-video model's perImage is the price of one clip.
+                cost = rates.perImage === undefined ? null : rates.perImage * (call.images ?? 1);
+                break;
+        }
+    return {
+        onPlan: false,
+        cost,
+        apiModel: null,
+        apiCost: null,
+        price: rates === undefined ? null : { catalogue: date, model: call.model, ...rates },
+    };
+}

package/dist/slices/run-cost/week.js

@@ -0,0 +1,108 @@
+import { z } from "zod";
+import { planAccountNames, planAccounts, } from "../../kernel/ports/plan-limits.js";
+import { defaultChannelId } from "../channels/model.js";
+import { projectChannels } from "../channels/repo.js";
+const usageRow = z.object({
+    project_id: z.string(),
+    on_plan: z.number(),
+    cost: z.number().nullable(),
+    api_cost: z.number().nullable(),
+});
+const standaloneRow = z.object({
+    channel_id: z.string(),
+    on_plan: z.number(),
+    cost: z.number().nullable(),
+    api_cost: z.number().nullable(),
+});
+const windowSchema = z.object({
+    kind: z.enum(["five_hour", "weekly", "other"]),
+    usedPercent: z.number(),
+    resetsAt: z.string().nullable(),
+});
+const readingSchema = z.object({
+    before: z.array(windowSchema).optional(),
+    after: z.array(windowSchema).optional(),
+});
+// `channelId` narrows the counts to one channel: its projects, and the calls made for its
+// schedules and itself. Plan standings are the account's whole allowance, which every channel
+// shares, so they are never narrowed.
+export function weekSummary(db, since, channelId) {
+    const known = channelId === undefined ? undefined : knownChannels(db);
+    const channels = channelId === undefined ? undefined : projectChannels(db);
+    const projectInScope = (projectId) => channels === undefined || (channels.get(projectId) ?? defaultChannelId) === channelId;
+    let calls = 0;
+    let cost = 0;
+    let unpriced = 0;
+    let apiEquivalent = null;
+    const count = (row) => {
+        calls += 1;
+        cost += row.cost ?? 0;
+        if (row.cost === null)
+            unpriced += 1;
+        if (row.on_plan === 1)
+            apiEquivalent = (apiEquivalent ?? 0) + (row.api_cost ?? 0);
+    };
+    for (const raw of db
+        .prepare("SELECT project_id, on_plan, cost, api_cost FROM provider_usage WHERE created_at >= ?")
+        .all(since)) {
+        const row = usageRow.parse(raw);
+        if (projectInScope(row.project_id))
+            count(row);
+    }
+    for (const raw of db
+        .prepare("SELECT channel_id, on_plan, cost, api_cost FROM standalone_usage WHERE created_at >= ?")
+        .all(since)) {
+        const row = standaloneRow.parse(raw);
+        // A channel deleted since counts under the default channel, as its projects do.
+        const channel = known === undefined || known.has(row.channel_id) ? row.channel_id : defaultChannelId;
+        if (channelId === undefined || channel === channelId)
+            count(row);
+    }
+    // A video is made when its file lands; a remade video counts again, as it was made again.
+    const videos = db
+        .prepare("SELECT project_id FROM outputs WHERE role = 'video' AND created_at >= ?")
+        .all(since)
+        .filter((row) => projectInScope(String(row.project_id))).length;
+    return { since, videos, calls, cost, unpriced, apiEquivalent, plans: planStandings(db) };
+}
+function knownChannels(db) {
+    return new Set(db
+        .prepare("SELECT id FROM channels")
+        .all()
+        .map((row) => String(row.id)));
+}
+function planStandings(db) {
+    return planAccounts.flatMap((account) => {
+        const rows = db
+            .prepare(`SELECT reading_json, created_at FROM (
+           SELECT reading_json, created_at, rowid AS n, 0 AS source FROM plan_limit_readings WHERE account = ?
+           UNION ALL
+           SELECT reading_json, created_at, rowid AS n, 1 AS source FROM standalone_usage WHERE account = ? AND reading_json IS NOT NULL
+         ) ORDER BY created_at DESC, source DESC, n DESC LIMIT 20`)
+            .all(account, account);
+        for (const raw of rows) {
+            const row = z.object({ reading_json: z.string(), created_at: z.string() }).parse(raw);
+            const parsed = readingSchema.safeParse(JSON.parse(row.reading_json));
+            if (!parsed.success)
+                continue;
+            const windows = parsed.data.after?.length
+                ? parsed.data.after
+                : (parsed.data.before ?? []);
+            if (windows.length === 0)
+                continue;
+            const weekly = windows.find((window) => window.kind === "weekly");
+            const fiveHour = windows.find((window) => window.kind === "five_hour");
+            return [
+                {
+                    account,
+                    name: planAccountNames[account],
+                    weeklyPercent: weekly?.usedPercent ?? null,
+                    fiveHourPercent: fiveHour?.usedPercent ?? null,
+                    weeklyResetsAt: weekly?.resetsAt ?? null,
+                    readAt: row.created_at,
+                },
+            ];
+        }
+        return [];
+    });
+}