@gentbajko/slopify 2.5.0 → 3.0.1

package/dist/edge/http/prompts.js

@@ -1,9 +1,12 @@
 import { zValidator } from "@hono/zod-validator";
 import { Hono } from "hono";
 import { z } from "zod";
+import { versionsOrCurrent } from "../../slices/library/history.js";
 import { promptKinds } from "../../slices/library/model.js";
-import { listPrompts } from "../../slices/library/repo.js";
-import { createPrompt, removePrompt, updatePrompt } from "../../slices/library/save.js";
+import { setPromptPhotorealistic, withPhotorealistic, } from "../../slices/library/photorealistic.js";
+import { listPrompts, promptById } from "../../slices/library/repo.js";
+import { createPrompt, removePrompt, restorePrompt, updatePrompt, } from "../../slices/library/save.js";
+import { usedBy } from "../../slices/library/used-by.js";
 import { onInvalid, problem, titleOf } from "./problem.js";
 const idParam = z.object({
     id: z
@@ -12,6 +15,8 @@ const idParam = z.object({
         .max(64)
         .regex(/^[0-9A-Za-z_-]+$/),
 });
+// History's Restore names the version by its number.
+export const versionParam = idParam.extend({ version: z.coerce.number().int().positive() });
 // Shape only. The rules - trimming, emptiness, length, the slot lint - are the slice's,
 // so one set of messages reaches the editor.
 const promptBody = z.object({
@@ -26,7 +31,7 @@ export function promptRoutes(deps) {
     return (new Hono()
         // Every kind in one list: 04 Prompts filters by tab, and Duplicate needs the body it
         // is copying.
-        .get("/", (c) => c.json({ prompts: listPrompts(deps.db) }))
+        .get("/", (c) => c.json({ prompts: withPhotorealistic(deps.db, listPrompts(deps.db)) }))
         .post("/", zValidator("json", promptBody, onInvalid), (c) => {
         const result = createPrompt(library, c.req.valid("json"));
         return result.ok ? c.json(result.value, 201) : refused(c, result, "prompt");
@@ -34,6 +39,38 @@ export function promptRoutes(deps) {
         .put("/:id", zValidator("param", idParam, onInvalid), zValidator("json", promptBody, onInvalid), (c) => {
         const result = updatePrompt(library, c.req.valid("param").id, c.req.valid("json"));
         return result.ok ? c.json(result.value) : refused(c, result, "prompt");
+    })
+        // An Image prompt's "Draws photorealistic pictures" tick (`slices/library/photorealistic.ts`).
+        .put("/:id/photorealistic", zValidator("param", idParam, onInvalid), zValidator("json", z.object({ photorealistic: z.boolean() }), onInvalid), (c) => {
+        const result = setPromptPhotorealistic(deps.db, c.req.valid("param").id, c.req.valid("json").photorealistic);
+        if (result.ok)
+            return c.body(null, 204);
+        return result.reason === "not-found"
+            ? refused(c, { ok: false, reason: "not-found" }, "prompt")
+            : problem(c, {
+                status: 400,
+                title: titleOf(400),
+                detail: "Only an Image prompt can be marked photorealistic. Open the prompt from the Image tab in Library → Prompts.",
+            });
+    })
+        // Every saved version, newest first (`slices/library/history.ts`).
+        .get("/:id/history", zValidator("param", idParam, onInvalid), (c) => {
+        const prompt = promptById(deps.db, c.req.valid("param").id);
+        return prompt === undefined
+            ? refused(c, { ok: false, reason: "not-found" }, "prompt")
+            : c.json({ versions: versionsOrCurrent(deps.db, "prompt", prompt) });
+    })
+        .post("/:id/history/:version/restore", zValidator("param", versionParam, onInvalid), (c) => {
+        const { id, version } = c.req.valid("param");
+        const result = restorePrompt(library, id, version);
+        return result.ok ? c.json(result.value) : refused(c, result, "prompt");
+    })
+        // The templates, schedules and projects that name it.
+        .get("/:id/used-by", zValidator("param", idParam, onInvalid), (c) => {
+        const prompt = promptById(deps.db, c.req.valid("param").id);
+        return prompt === undefined
+            ? refused(c, { ok: false, reason: "not-found" }, "prompt")
+            : c.json(usedBy(deps.db, { item: "prompt", kind: prompt.kind, name: prompt.name }));
     })
         // A project holds its own rendered text, so nothing cascades and a
         // template used by past projects is deleted like any other.

package/dist/edge/http/pronunciations.js

@@ -1,17 +1,36 @@
 import { zValidator } from "@hono/zod-validator";
 import { Hono } from "hono";
 import { z } from "zod";
+import { aliasCountMax } from "../../kernel/ports/narration-aliases.js";
+import { listNarrationAliases, saveNarrationAliases, } from "../../slices/narration/aliases-library.js";
 import { collectSharedGlossary } from "../../slices/narration/shared-glossary.js";
-import { onInvalid } from "./problem.js";
+import { onInvalid, problem, titleOf } from "./problem.js";
 // The pronunciations of every project's glossary, merged, for Edit project to copy into a
 // project that shares them. `except` leaves out the project being edited, whose own glossary
-// already comes first.
+// already comes first. Library → Aliases lives here too: the other way to change how a word
+// is said.
 export function pronunciationRoutes(deps) {
-    return new Hono().get("/shared", zValidator("query", z.object({
+    const library = { db: deps.db, ids: deps.ids, clock: deps.clock };
+    return (new Hono()
+        .get("/shared", zValidator("query", z.object({
         except: z
             .string()
             .max(64)
             .regex(/^[0-9A-Za-z_-]*$/)
             .optional(),
-    }), onInvalid), (c) => c.json(collectSharedGlossary(deps, c.req.valid("query").except)));
+    }), onInvalid), (c) => c.json(collectSharedGlossary(deps, c.req.valid("query").except)))
+        .get("/aliases", (c) => c.json({ aliases: listNarrationAliases(deps.db) }))
+        // The editor saves the whole ordered list at once; each row is checked in the slice, so
+        // the editor gets "Alias 3: …" sentences rather than schema paths.
+        .put("/aliases", zValidator("json", z.object({ aliases: z.array(z.unknown()).max(aliasCountMax * 2) }), onInvalid), (c) => {
+        const result = saveNarrationAliases(library, c.req.valid("json").aliases);
+        if (result.ok)
+            return c.json({ aliases: result.aliases });
+        return problem(c, {
+            status: 400,
+            title: titleOf(400),
+            detail: `These aliases can't be saved yet: ${result.fields.map((field) => field.message).join(" ")}`,
+            extensions: { fields: result.fields },
+        });
+    }));
 }

package/dist/edge/http/providers.js

@@ -1,19 +1,40 @@
+import { randomUUID } from "node:crypto";
 import { zValidator } from "@hono/zod-validator";
 import { Hono } from "hono";
 import { z } from "zod";
+import { keyProbes } from "../../adapters/key-probes.js";
 import { videoModelsOf } from "../../catalog/schema.js";
+import { defaultSpeechVoice, detectSpeechCached } from "../../kernel/ports/system-speech.js";
+import { switchAllRetired, switchRetiredModel } from "../../slices/model-upkeep/switch.js";
+import { retiredModelUsage, usageKinds, usageSlots } from "../../slices/model-upkeep/usage.js";
 import { cliPathMaxLength, saveCliPath } from "../../slices/settings/cli-paths.js";
+import { dismissFirstRun, firstRunStatus } from "../../slices/settings/first-run.js";
+import { checkProviderHealth } from "../../slices/settings/health.js";
+import { keyGuides } from "../../slices/settings/key-guides.js";
+import { testProviderKey } from "../../slices/settings/key-test.js";
 import { keyStatus, removeProviderKey, saveProviderKey } from "../../slices/settings/keys.js";
-import { isLocalCliProvider, providerById, providerIds } from "../../slices/settings/model.js";
+import { isUncataloguedProvider, providerById, providerIds } from "../../slices/settings/model.js";
 import { createModelCatalog } from "../../slices/settings/models.js";
 import { providerStatuses } from "../../slices/settings/readiness.js";
 import { onInvalid, problem, titleOf } from "./problem.js";
 const providerParam = z.object({ id: z.enum(providerIds) });
+const healthQuery = z.object({ provider: z.enum(providerIds).optional() });
 // ceiling: no format check is allowed on a key, so the only thing said about the value is
 // that it is a string of a length a key could plausibly have. Raise the bound if a provider
 // ever issues something longer.
 const pathBody = z.object({ path: z.string().max(cliPathMaxLength) });
 const keyBody = z.object({ key: z.string().min(1).max(4096) });
+const modelId = z.string().min(1).max(200);
+const switchBody = z
+    .object({
+    kind: z.enum(usageKinds),
+    id: z.string().min(1).max(64),
+    slot: z.enum(usageSlots),
+    from: z.object({ provider: z.string().min(1).max(64), model: modelId }).strict(),
+    to: modelId,
+})
+    .strict();
+const noFetch = "Slopify cannot reach the internet from here yet because it is still starting. Wait a moment, reload the page and try again.";
 // The return type is inferred so Hono keeps the route types the SPA's client is
 // generated from; see stagingRoutes.
 export function providerRoutes(deps) {
@@ -22,6 +43,7 @@ export function providerRoutes(deps) {
         db: deps.db,
         probe: deps.probe,
         hostCliStatus: deps.hostCliStatus,
+        host: deps.speechHost,
     };
     const catalog = createModelCatalog({
         load: deps.modelsFor ?? (() => Promise.reject(new Error("Model catalog unavailable"))),
@@ -29,7 +51,67 @@ export function providerRoutes(deps) {
         now: () => deps.clock.now().getTime(),
         report: (provider) => deps.log.write("warn", "model-catalog", { detail: `Could not load models for ${provider}` }),
     });
+    const upkeep = () => ({ ...deps, uuid: deps.drafts?.uuid ?? randomUUID });
     return (new Hono()
+        // The step lists Settings → Providers shows beside each key field.
+        .get("/key-guides", (c) => c.json({ guides: keyGuides }))
+        // What the first launch found, and the providers Play picks by default.
+        .get("/first-run", async (c) => {
+        c.header("Cache-Control", "no-store");
+        return c.json(await firstRunStatus({ db: deps.db, ...(deps.modelsFor === undefined ? {} : { modelsFor: deps.modelsFor }) }, await providerStatuses(readiness)));
+    })
+        .post("/first-run/dismiss", (c) => {
+        dismissFirstRun(deps.db);
+        return c.body(null, 204);
+    })
+        // "Check all": every CLI signed in, every key valid, every chosen model still offered and
+        // answering for the key. `?provider=codex` checks that one only (its row's Check again,
+        // or a sign-in fix-it's).
+        .post("/health", zValidator("query", healthQuery, onInvalid), async (c) => {
+        if (deps.fetch === undefined)
+            return problem(c, { status: 503, title: titleOf(503), detail: noFetch });
+        const catalogue = deps.catalogue;
+        return c.json(await checkProviderHealth({
+            ...readiness,
+            clock: deps.clock,
+            fetch: deps.fetch,
+            probes: keyProbes,
+            ...(catalogue === undefined ? {} : { catalogue: () => catalogue.read() }),
+            ...(deps.modelsFor === undefined ? {} : { modelsFor: deps.modelsFor }),
+            ...(deps.cliLogin === undefined ? {} : { login: deps.cliLogin }),
+        }, c.req.valid("query").provider));
+    })
+        // Checks for new, repriced and retired models now instead of waiting for the daily check.
+        .post("/catalogue/check", async (c) => {
+        if (!deps.catalogue?.sync)
+            return problem(c, {
+                status: 503,
+                title: titleOf(503),
+                detail: "The model list (models.yaml) is not loaded yet. Wait a moment and reload the page; if it stays like this, restart Slopify.",
+            });
+        await deps.catalogue.sync();
+        return c.json(deps.catalogue.status());
+    })
+        // Every template, schedule, draft and unfinished project still using a retired model.
+        .get("/catalogue/retired", (c) => {
+        c.header("Cache-Control", "no-store");
+        return c.json({
+            usages: deps.catalogue === undefined ? [] : retiredModelUsage(deps.db, deps.catalogue.read()),
+        });
+    })
+        .post("/catalogue/retired/switch", zValidator("json", switchBody, onInvalid), async (c) => {
+        if (deps.catalogue === undefined)
+            return problem(c, { status: 503, title: titleOf(503), detail: noFetch });
+        const result = await switchRetiredModel(upkeep(), deps.catalogue.read(), c.req.valid("json"));
+        if (!result.ok)
+            return problem(c, { status: 409, title: titleOf(409), detail: result.message });
+        return c.json(result);
+    })
+        .post("/catalogue/retired/switch-all", async (c) => {
+        if (deps.catalogue === undefined)
+            return problem(c, { status: 503, title: titleOf(503), detail: noFetch });
+        return c.json(await switchAllRetired(upkeep(), deps.catalogue.read()));
+    })
         .get("/catalogue", (c) => c.json(deps.catalogue?.status() ?? {
         warning: "The model list (models.yaml) is not loaded yet. Wait a moment and reload the page; if it stays like this, restart Slopify.",
     }))
@@ -55,6 +137,19 @@ export function providerRoutes(deps) {
         // What Settings draws its rails from and Play its dropdowns: every provider, with
         // the one fact that decides whether it is selectable.
         .get("/", async (c) => c.json({ providers: await providerStatuses(readiness) }))
+        // The system voice's speech programs and their voices, for Settings → Voices' picker.
+        .get("/system-voice/voices", async (c) => {
+        const found = await detectSpeechCached(deps.probe, deps.speechHost ?? process);
+        return c.json({
+            engines: found.engines.map((engine) => ({
+                id: engine.id,
+                name: engine.name,
+                voices: engine.voices,
+                defaultVoice: defaultSpeechVoice(engine)?.id ?? null,
+            })),
+            issue: found.issue ?? null,
+        });
+    })
         .get("/:id/models", zValidator("param", providerParam, onInvalid), async (c) => {
         const { id } = c.req.valid("param");
         // Animate images lists the provider's image-to-video models, which only the catalogue
@@ -64,7 +159,7 @@ export function providerRoutes(deps) {
                 models: deps.catalogue === undefined ? [] : videoModelsOf(deps.catalogue.read(), id),
                 allowsCustom: false,
             });
-        if (deps.catalogue && !isLocalCliProvider(id))
+        if (deps.catalogue && !isUncataloguedProvider(id))
             return c.json({
                 models: deps.catalogue.models(id, providerById(id).family).map((m) => ({
                     ...m,
@@ -101,6 +196,25 @@ export function providerRoutes(deps) {
         catalog.invalidate(id);
         // The response says a key is stored and shows the mask, never the value.
         return c.json(keyStatus(keys, id));
+    })
+        // The Test button: the cheapest read the provider offers, answered in plain words. With
+        // a `key` in the body, that pasted key is tried instead of the saved one and is neither
+        // stored nor logged; with no body, the saved key is.
+        .post("/:id/key/test", zValidator("param", providerParam, onInvalid), async (c) => {
+        const { id } = c.req.valid("param");
+        if (providerById(id).auth !== "key")
+            return refusal(c, id, "cli-provider");
+        if (deps.fetch === undefined)
+            return problem(c, { status: 503, title: titleOf(503), detail: noFetch });
+        const raw = await c.req.json().catch(() => undefined);
+        const candidate = raw === undefined ? undefined : keyBody.safeParse(raw);
+        if (candidate !== undefined && !candidate.success)
+            return problem(c, {
+                status: 400,
+                title: titleOf(400),
+                detail: `The pasted ${providerById(id).displayName} key could not be tested: it is empty or longer than any key. Paste the whole key in Settings → Providers → ${providerById(id).displayName}, then choose Test again.`,
+            });
+        return c.json(await testProviderKey({ db: deps.db, clock: deps.clock, fetch: deps.fetch, probes: keyProbes }, id, candidate?.data.key));
     })
         .delete("/:id/key", zValidator("param", providerParam, onInvalid), (c) => {
         const { id } = c.req.valid("param");
@@ -118,7 +232,9 @@ function refusal(c, id, reason) {
         return problem(c, {
             status: 400,
             title: titleOf(400),
-            detail: `${name} signs in through its own command-line tool, so it has no API key to save here. Sign in with that tool on your computer instead.`,
+            detail: providerById(id).auth === "local"
+                ? `${name} is your computer's own speech, so it has no API key to save. It works as soon as a speech program is installed.`
+                : `${name} signs in through its own command-line tool, so it has no API key to save here. Sign in with that tool on your computer instead.`,
         });
     }
     if (reason === "absent") {

package/dist/edge/http/reviews.js

@@ -0,0 +1,131 @@
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { z } from "zod";
+import { revisionControlSchema } from "../../slices/control/revision-control-schema.js";
+import { recoverProject } from "../../slices/rebuild/recovery.js";
+import { redoStarting } from "../../slices/rebuild/review-redo.js";
+import { actOnVerdict, listVerdicts, verdictById } from "../../slices/reviews/repo.js";
+import { latestReviews } from "../../slices/reviews/view.js";
+import { currentRevisionId } from "../../slices/revisions/repo.js";
+import { getRevisionView } from "../../slices/revisions/view.js";
+import { onInvalid, problem, titleOf } from "./problem.js";
+const id = z
+    .string()
+    .min(1)
+    .max(64)
+    .regex(/^[0-9A-Za-z_-]+$/);
+const projectParam = z.object({ id });
+const verdictParam = projectParam.extend({ verdictId: id });
+// The project page's review column: each reviewed item's latest verdict with its reasons,
+// Overrule to accept a failed item as it is, and Redo to have it made again through the
+// same path as More → make it again in its section.
+export function reviewRoutes(deps) {
+    const gone = (c) => problem(c, {
+        status: 404,
+        title: titleOf(404),
+        detail: "This review no longer exists; the project may have been deleted or restored from a backup. Reload the project page.",
+    });
+    const notify = (projectId) => {
+        try {
+            deps.hub.emit(projectId, { type: "project.updated", projectId });
+        }
+        catch (error) {
+            deps.log.write("error", "review.notify", {
+                projectId,
+                detail: error instanceof Error ? error.message : String(error),
+            });
+        }
+    };
+    return new Hono()
+        .get("/:id/reviews", zValidator("param", projectParam, onInvalid), (c) => {
+        const projectId = c.req.valid("param").id;
+        const head = currentRevisionId(deps.db, projectId);
+        const view = head === undefined ? undefined : getRevisionView(deps, projectId, head);
+        const outputs = (view?.outputs ?? [])
+            .filter((row) => row.selected)
+            .map((row) => ({
+            workKey: row.workKey,
+            fingerprint: row.fingerprint,
+            outputId: row.output.id,
+        }));
+        return c.json({ reviews: latestReviews(listVerdicts(deps.db, projectId), outputs) });
+    })
+        .post("/:id/reviews/:verdictId/overrule", zValidator("param", verdictParam, onInvalid), (c) => {
+        const { id: projectId, verdictId } = c.req.valid("param");
+        const busy = () => problem(c, {
+            status: 409,
+            title: titleOf(409),
+            detail: "This verdict can't be overruled: it passed, or Slopify has already started making the item again. Wait for the new version to land, then reload the project page and overrule its review if it fails again.",
+            extensions: { reason: "conflict" },
+        });
+        // Checked and changed in one synchronous step, so a redo cannot start in between.
+        if (redoStarting(verdictId))
+            return busy();
+        const result = actOnVerdict(deps.db, projectId, verdictId, "overruled", deps.clock.now().toISOString());
+        if (!result.ok)
+            return result.reason === "not-found" ? gone(c) : busy();
+        // A called-off redo released the work that was waiting on the item.
+        try {
+            deps.runner.tick(projectId);
+        }
+        catch {
+            // The next tick of this project picks the released work up.
+        }
+        notify(projectId);
+        return c.json({ review: result.value });
+    })
+        .post("/:id/reviews/:verdictId/redo", zValidator("param", verdictParam, onInvalid), zValidator("json", revisionControlSchema, onInvalid), async (c) => {
+        const { id: projectId, verdictId } = c.req.valid("param");
+        const verdict = verdictById(deps.db, projectId, verdictId);
+        if (verdict === undefined)
+            return gone(c);
+        if (deps.rebuild === undefined)
+            return problem(c, {
+                status: 503,
+                title: titleOf(503),
+                detail: "Redo is not ready yet because Slopify is still starting. Wait a moment, reload the page and try again.",
+            });
+        if (verdict.redoState === "pending" || verdict.redoState === "started")
+            return problem(c, {
+                status: 409,
+                title: titleOf(409),
+                detail: "Slopify is already making this item again. Wait for it to land, then reload the project page.",
+                extensions: { reason: "conflict" },
+            });
+        const result = await recoverProject(deps.rebuild, projectId, {
+            ...c.req.valid("json"),
+            action: { kind: "redo", item: verdict.itemKey },
+        });
+        if (!result.ok)
+            return refused(c, result, projectId);
+        actOnVerdict(deps.db, projectId, verdictId, "redone", deps.clock.now().toISOString());
+        notify(projectId);
+        return c.json(result, 202);
+    });
+    function refused(c, result, projectId) {
+        const status = result.reason === "no-project"
+            ? 404
+            : result.reason === "invalid-selection" || result.reason === "invalid-edit"
+                ? 400
+                : 409;
+        const lead = result.reason === "running"
+            ? "This item, or work that depends on it, is still running. Wait for it to finish, or Pause the project, then use Redo again."
+            : result.reason === "readiness"
+                ? "Slopify can't make this item again yet. Fix what is listed in Settings → Providers or Edit project, then use Redo again."
+                : result.reason === "conflict" || result.reason === "control-changed"
+                    ? "This project changed since the page loaded. Reload the project page, then use Redo again."
+                    : result.reason === "invalid-selection"
+                        ? "This item can't be made again."
+                        : "Slopify couldn't make this item again.";
+        return problem(c, {
+            status,
+            title: titleOf(status),
+            detail: [lead, ...(result.fields ?? []).map((row) => row.message)].join(" "),
+            extensions: {
+                reason: result.reason,
+                fields: result.fields ?? [],
+                currentRevisionId: currentRevisionId(deps.db, projectId) ?? null,
+            },
+        });
+    }
+}

package/dist/edge/http/revision-files.js

@@ -1,9 +1,8 @@
-import { createReadStream } from "node:fs";
-import { Readable } from "node:stream";
 import { zValidator } from "@hono/zod-validator";
 import { Hono } from "hono";
 import { z } from "zod";
 import { findRevisionDownload, revisionImagesZip } from "../../slices/revisions/downloads.js";
+import { fileResponse } from "./byte-range.js";
 import { replyForFolder } from "./folder-location.js";
 import { onInvalid, problem, titleOf } from "./problem.js";
 const id = z
@@ -36,9 +35,8 @@ export function revisionFileRoutes(deps) {
         // `?inline=1` lets the project page open a PDF in a browser tab instead of saving
         // it. Only PDFs: anything else the browser might render stays a download.
         const inline = c.req.query("inline") === "1" && value.contentType === "application/pdf";
-        return c.body(Readable.toWeb(createReadStream(value.path)), 200, {
+        return fileResponse(c, value.path, value.bytes, {
             "content-type": value.contentType,
-            "content-length": String(value.bytes),
             "content-disposition": `${inline ? "inline" : "attachment"}; filename="${value.filename}"`,
             "x-content-type-options": "nosniff",
         });
@@ -65,7 +63,7 @@ function unavailable(c, reason) {
         status: 404,
         title: titleOf(404),
         detail: reason === "missing-file"
-            ? "This file was deleted or moved from the project folder. In the Edit tab, use Rebuild affected outputs to make it again."
+            ? "This file was deleted or moved from the project folder. In the Edit tab, use Choose what to remake (in the project's More menu) to make it again."
             : "This file is no longer part of the project. Reload the page to see its current files.",
         extensions: { reason },
     });

package/dist/edge/http/revisions.js

@@ -37,7 +37,7 @@ const details = {
     conflict: "This project changed while you were editing. Reload the page to see the latest, then make your change again.",
     "idempotency-conflict": "This change was already sent with different details. Reload the page, then try again.",
     "invalid-edit": "Some of your changes are not valid. Fix the highlighted fields and save again.",
-    "stale-preview": "What needs rebuilding changed since you opened this review. Cancel it and open Rebuild affected outputs again to see the latest.",
+    "stale-preview": "What needs rebuilding changed since you opened this review. Cancel it and open Choose what to remake (in the project's More menu) again to see the latest.",
     "invalid-selection": "Some of the outputs you picked can no longer be rebuilt. Reload the page and choose again.",
     "review-required": 'This rebuild touches content you supplied yourself. Tick "Keep the provided content" for each item in the review, then choose Start rebuild.',
     "cost-ack-required": "Some costs for this rebuild are unknown. Tick the box confirming you understand, then choose Start rebuild.",

package/dist/edge/http/run-cost.js

@@ -0,0 +1,25 @@
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { z } from "zod";
+import { projectExists } from "../../slices/admission/repo.js";
+import { runCostOf } from "../../slices/run-cost/panel.js";
+import { onInvalid, problem, titleOf } from "./problem.js";
+const idParam = z.object({ id: z.string().min(1).max(64) });
+// The project's Run cost tab and its "Waiting for … limits" line: what the run's provider
+// calls used and cost, and any CLI plan limit a stage is waiting on. Read from the stored
+// calls alone; nothing here reaches a provider.
+//
+// The return type is inferred so Hono keeps the route types the SPA's client is generated
+// from; see stagingRoutes.
+export function runCostRoutes(deps) {
+    return new Hono().get("/:id/run-cost", zValidator("param", idParam, onInvalid), (c) => {
+        const id = c.req.valid("param").id;
+        if (!projectExists(deps.db, id))
+            return problem(c, {
+                status: 404,
+                title: titleOf(404),
+                detail: "This project no longer exists. Go back to Projects to pick another.",
+            });
+        return c.json(runCostOf(deps.db, id));
+    });
+}