@gentbajko/slopify 3.25.8 → 4.0.0

package/dist/edge/http/providers.js

@@ -17,7 +17,7 @@ import { keyStatus, removeProviderKey, saveProviderKey } from "../../slices/sett
 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";
+import { onInvalid, problem } 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
@@ -26,7 +26,7 @@ const healthQuery = z.object({ provider: z.enum(providerIds).optional() });
 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
+export const switchBody = z
     .object({
     kind: z.enum(usageKinds),
     id: z.string().min(1).max(64),
@@ -53,6 +53,15 @@ export function providerRoutes(deps) {
         report: (provider) => deps.log.write("warn", "model-catalog", { detail: `Could not load models for ${provider}` }),
     });
     const upkeep = () => ({ ...deps, uuid: deps.drafts?.uuid ?? randomUUID });
+    // A picker opening reads the key's own model list again when it is due; never waited for.
+    const relist = (id) => {
+        if (deps.autoModelChecks !== true)
+            return;
+        void deps.modelListing?.refresh(id).catch((error) => {
+            deps.log.write("warn", "model-checks.listing", { detail: `${id}: ${String(error)}` });
+        });
+    };
+    const standingsOf = (id, models) => deps.modelChecks?.standings(id, models);
     return (new Hono()
         // The step lists Settings → Providers shows beside each key field.
         .get("/key-guides", (c) => c.json({ guides: keyGuides }))
@@ -70,7 +79,7 @@ export function providerRoutes(deps) {
         // 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 });
+            return problem(c, { status: 503, detail: noFetch });
         const catalogue = deps.catalogue;
         return c.json(await checkProviderHealth({
             ...readiness,
@@ -87,7 +96,6 @@ export function providerRoutes(deps) {
         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();
@@ -97,21 +105,23 @@ export function providerRoutes(deps) {
         .get("/catalogue/retired", (c) => {
         c.header("Cache-Control", "no-store");
         return c.json({
-            usages: deps.catalogue === undefined ? [] : retiredModelUsage(deps.db, deps.catalogue.read()),
+            usages: deps.catalogue === undefined
+                ? []
+                : retiredModelUsage(deps.db, deps.catalogue.read(), deps.catalogue.lifecycle?.()),
         });
     })
         .post("/catalogue/retired/switch", zValidator("json", switchBody, onInvalid), async (c) => {
         if (deps.catalogue === undefined)
-            return problem(c, { status: 503, title: titleOf(503), detail: noFetch });
+            return problem(c, { status: 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 problem(c, { status: 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()));
+            return problem(c, { status: 503, detail: noFetch });
+        return c.json(await switchAllRetired(upkeep(), deps.catalogue.read(), deps.catalogue.lifecycle?.()));
     })
         .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.",
@@ -120,7 +130,6 @@ export function providerRoutes(deps) {
         if (!deps.catalogue)
             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.",
             });
         try {
@@ -129,7 +138,6 @@ export function providerRoutes(deps) {
         catch {
             return problem(c, {
                 status: 502,
-                title: titleOf(502),
                 detail: "Slopify could not download the latest model list. Your current list is still in use; check your internet connection and try Refresh again.",
             });
         }
@@ -155,30 +163,36 @@ export function providerRoutes(deps) {
         const { id } = c.req.valid("param");
         // Animate images lists the provider's image-to-video models, which only the catalogue
         // names.
-        if (c.req.query("video") === "1")
+        relist(id);
+        if (c.req.query("video") === "1") {
+            const videos = deps.catalogue === undefined ? [] : videoModelsOf(deps.catalogue.read(), id);
             return c.json({
-                models: deps.catalogue === undefined ? [] : videoModelsOf(deps.catalogue.read(), id),
+                models: videos,
                 allowsCustom: false,
+                standings: standingsOf(id, videos),
             });
-        if (deps.catalogue && !isUncataloguedProvider(id))
+        }
+        if (deps.catalogue && !isUncataloguedProvider(id)) {
+            const models = deps.catalogue
+                .models(id, providerById(id).family)
+                .map((m) => ({ ...m, ...catalogueModelInfo(m) }));
             return c.json({
-                models: deps.catalogue
-                    .models(id, providerById(id).family)
-                    .map((m) => ({ ...m, ...catalogueModelInfo(m) })),
+                models,
                 allowsCustom: false,
                 notice: "Curated active models from models.yaml. Edit it locally or refresh in Settings.",
                 warning: deps.catalogue.status().warning ?? undefined,
+                standings: standingsOf(id, models),
             });
+        }
         const result = await catalog.get(id, providerById(id).family, c.req.query("refresh") === "1");
         c.header("Cache-Control", "no-store");
-        return c.json(result);
+        return c.json({ ...result, standings: standingsOf(id, result.models) });
     })
         .put("/:id/path", zValidator("param", providerParam, onInvalid), zValidator("json", pathBody, onInvalid), async (c) => {
         const result = await saveCliPath(readiness, c.req.valid("param").id, c.req.valid("json").path);
         if (!result.ok)
             return problem(c, {
                 status: 400,
-                title: titleOf(400),
                 detail: result.message,
                 extensions: { fields: [{ field: "path", message: result.message }] },
             });
@@ -192,6 +206,11 @@ export function providerRoutes(deps) {
             return refusal(c, id, result.reason);
         }
         catalog.invalidate(id);
+        // A new key: read its model list and check what is free to check, in the background.
+        if (deps.autoModelChecks === true)
+            void deps.modelChecks?.automatic("key-added", id).catch((error) => {
+                deps.log.write("warn", "model-checks", { detail: `${id}: ${String(error)}` });
+            });
         // The response says a key is stored and shows the mask, never the value.
         return c.json(keyStatus(keys, id));
     })
@@ -203,13 +222,12 @@ export function providerRoutes(deps) {
         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 });
+            return problem(c, { status: 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));
@@ -229,7 +247,6 @@ function refusal(c, id, reason) {
     if (reason === "cli-provider") {
         return problem(c, {
             status: 400,
-            title: titleOf(400),
             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.`,
@@ -238,13 +255,11 @@ function refusal(c, id, reason) {
     if (reason === "absent") {
         return problem(c, {
             status: 404,
-            title: titleOf(404),
             detail: `There is no saved API key for ${name}, so there is nothing to remove.`,
         });
     }
     return problem(c, {
         status: 400,
-        title: titleOf(400),
         detail: "This API key cannot be saved yet. Paste the key and try again.",
         extensions: {
             fields: [{ field: "key", message: "Paste the API key from your provider's account page." }],

package/dist/edge/http/refusal.js

@@ -0,0 +1,29 @@
+import { problem } from "./problem.js";
+export function refusal(c, reason, rules) {
+    return problem(c, {
+        status: rules.statuses[reason] ?? rules.otherwise,
+        detail: rules.detail,
+        extensions: { reason, ...rules.extensions },
+    });
+}
+export function revisionRequired(c) {
+    return problem(c, {
+        status: 409,
+        detail: "This change is now made from the Edit tab. Choose Edit project, save your change, then use Choose what to remake (in the project's More menu).",
+        extensions: { reason: "revision-required" },
+    });
+}
+// A build without its bundled files says so in plain words; anything else is the app's error handler's.
+export function bundleMissing(c, error, Missing) {
+    if (!(error instanceof Missing))
+        throw error;
+    return problem(c, { status: 500, detail: error.message });
+}
+export async function jsonBody(c) {
+    try {
+        return await c.req.json();
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/edge/http/remote-access.js

@@ -0,0 +1,40 @@
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { z } from "zod";
+import { actorOf } from "./actor.js";
+import { onInvalid, problem } from "./problem.js";
+import { viaProxy } from "./same-page.js";
+const body = z.object({
+    enabled: z.boolean(),
+    httpsPort: z.number().int().min(1).max(65535).optional(),
+});
+// Settings → General → Remote access: Slopify's page on the person's other devices through
+// Tailscale serve. Reading it is open to agents (get_remote_access); turning it on or off is
+// the person's alone, from this computer.
+export function remoteAccessRoutes(service) {
+    const unavailable = "Remote access can't be set from this Slopify. Start it with npx @gentbajko/slopify and try Settings → General → Remote access again.";
+    return new Hono()
+        .get("/", async (c) => {
+        if (service === undefined)
+            return problem(c, { status: 404, detail: unavailable });
+        c.header("Cache-Control", "no-store");
+        const view = await service.view();
+        return c.json(viaProxy(c.req.raw.headers) ? { ...view, changeable: false } : view);
+    })
+        .put("/", zValidator("json", body, onInvalid), async (c) => {
+        if (service === undefined)
+            return problem(c, { status: 404, detail: unavailable });
+        if (actorOf(c) !== "person")
+            return problem(c, {
+                status: 403,
+                detail: "Remote access is the person's to turn on or off, in Settings → General → Remote access. Agents and the assistant can only read it (get_remote_access).",
+            });
+        if (viaProxy(c.req.raw.headers))
+            return problem(c, {
+                status: 403,
+                detail: "Remote access is turned on or off only on the computer Slopify runs on. Open Settings → General → Remote access there, at http://127.0.0.1 and Slopify's port.",
+            });
+        const { enabled, httpsPort } = c.req.valid("json");
+        return c.json(await service.set(enabled, httpsPort));
+    });
+}

package/dist/edge/http/remote-guard.js

@@ -0,0 +1,71 @@
+import { problem } from "./problem.js";
+import { viaProxy } from "./same-page.js";
+const id = "[^/]+";
+export const hostOnlyWrites = [
+    {
+        method: "PUT|DELETE",
+        path: new RegExp(`^/api/providers/${id}/key/?$`),
+        what: "Provider keys are saved and removed (Settings → Providers)",
+    },
+    {
+        method: "PUT",
+        path: new RegExp(`^/api/providers/${id}/path/?$`),
+        what: "A CLI's path is set (Settings → Providers)",
+    },
+    {
+        method: "PUT",
+        path: /^\/api\/storage\/import\/?$/,
+        what: "A backup is imported (Settings → Backup & storage)",
+    },
+    {
+        method: "POST",
+        path: new RegExp(`^/api/storage/(?:cleanup|old-versions/delete|projects/${id}/(?:old-versions/delete|keep-outputs))/?$`),
+        what: "Clean-ups that delete files are run (Settings → Backup & storage)",
+    },
+    {
+        method: "POST",
+        path: /^\/api\/storage\/files\/move\/?$/,
+        what: "The Files folder is moved (Settings → Backup & storage)",
+    },
+    {
+        method: "PUT",
+        path: /^\/api\/backups\/?$/,
+        what: "The backup folder is set (Settings → Backup & storage)",
+    },
+    {
+        method: "POST|DELETE",
+        path: /^\/api\/update(?:\/activate)?\/?$/,
+        what: "Updates are installed (Settings → About)",
+    },
+    {
+        method: "PUT",
+        path: /^\/api\/settings\/autostart\/?$/,
+        what: "Start with this computer is turned on or off (Settings → General)",
+    },
+];
+export const otherAccount = "Slopify refused this request: over remote access it answers only the Tailscale account that turned remote access on. Sign in to Tailscale on this device with that account, or open Slopify on the computer it runs on.";
+export const hostOnlySentence = (what) => `${what} only on the computer Slopify runs on, not over remote access: open Slopify there, at http://127.0.0.1 and Slopify's port, and do it there.`;
+export function remoteGuard(remoteAccess) {
+    return async (c, next) => {
+        const headers = c.req.raw.headers;
+        // The agents' endpoints refuse every proxied request themselves, with their own sentence.
+        if (!viaProxy(headers) || /^\/mcp(?:\/|$)/.test(c.req.path))
+            return next();
+        const owner = remoteAccess?.owner();
+        const remote = remoteAccess?.remoteHost();
+        const throughServe = headers.has("tailscale-user-login") ||
+            (remote !== undefined &&
+                (headers.get("x-forwarded-host") === remote || headers.get("host") === remote));
+        if (owner !== undefined && throughServe && headers.get("tailscale-user-login") !== owner)
+            return problem(c, { status: 403, detail: otherAccount });
+        const path = c.req.path;
+        const write = hostOnlyWrites.find((rule) => rule.method.split("|").includes(c.req.method) && rule.path.test(path));
+        if (write !== undefined)
+            return problem(c, {
+                status: 403,
+                detail: hostOnlySentence(write.what),
+                extensions: { reason: "host-only" },
+            });
+        return next();
+    };
+}

package/dist/edge/http/request-guard.js

@@ -0,0 +1,91 @@
+import { isIP } from "node:net";
+import { hostname } from "node:os";
+import { actorOf } from "./actor.js";
+import { problem } from "./problem.js";
+import { forwardedHost, fromSlopifyPage } from "./same-page.js";
+const nameOf = (host) => {
+    const trimmed = host.trim().toLowerCase();
+    if (trimmed.startsWith("["))
+        return trimmed.slice(1, trimmed.indexOf("]"));
+    const colon = trimmed.indexOf(":");
+    return colon === trimmed.lastIndexOf(":") && colon >= 0 ? trimmed.slice(0, colon) : trimmed;
+};
+const ownNames = () => {
+    const own = hostname().toLowerCase();
+    return own === "" ? [] : [own, `${own}.local`];
+};
+export function hostAllowed(host, rules) {
+    // An in-process request, or an HTTP/1.0 client, names no host.
+    if (host === undefined)
+        return true;
+    const name = nameOf(host);
+    if (name === "")
+        return false;
+    if (isIP(name) !== 0)
+        return true;
+    if (name === "localhost" || name.endsWith(".localhost"))
+        return true;
+    // This computer's tailnet name, also when the person serves Slopify through Tailscale
+    // themselves: a ts.net name only resolves inside a tailnet, never to someone's loopback.
+    if (name.endsWith(".ts.net"))
+        return true;
+    const named = [
+        rules.listenHost,
+        rules.remoteHost === undefined ? undefined : nameOf(rules.remoteHost),
+        ...rules.extraHosts,
+        ...ownNames(),
+    ].flatMap((one) => (one === undefined || one.trim() === "" ? [] : [one.trim().toLowerCase()]));
+    return named.includes(name);
+}
+const formTypes = ["text/plain", "application/x-www-form-urlencoded", "multipart/form-data"];
+const safeMethods = ["GET", "HEAD", "OPTIONS"];
+// The paired extension's own routes: token-checked, with CORS for its origin alone.
+const extensionRoutes = /^\/api\/(?:studio|social)\/ext(?:\/|$)/;
+export function requestGuard(deps) {
+    return async (c, next) => {
+        if (actorOf(c) !== "person")
+            return next();
+        const rules = {
+            listenHost: deps.listenHost,
+            remoteHost: deps.remoteHost?.(),
+            extraHosts: deps.extraHosts,
+        };
+        const host = c.req.header("host");
+        const forwarded = forwardedHost(c);
+        const refused = !hostAllowed(host, rules)
+            ? (host ?? "")
+            : forwarded !== undefined && !hostAllowed(forwarded, rules)
+                ? forwarded
+                : undefined;
+        if (refused !== undefined) {
+            const shown = refused.replace(/[^\w.:[\]-]/g, "").slice(0, 100);
+            return problem(c, {
+                status: 403,
+                detail: `Slopify refused this request: it was addressed to ${shown}, a name this Slopify doesn't answer to, which is how a web page could reach it through your browser. Open Slopify at http://127.0.0.1 and its port. If you reach it by this name on purpose, start Slopify with SLOPIFY_ALLOWED_HOSTS=${nameOf(shown)}.`,
+                extensions: { reason: "foreign-host" },
+            });
+        }
+        if (safeMethods.includes(c.req.method) ||
+            !c.req.path.startsWith("/api/") ||
+            extensionRoutes.test(c.req.path))
+            return next();
+        const origin = c.req.header("origin");
+        if (origin !== undefined) {
+            if (fromSlopifyPage(c, deps.remoteHost))
+                return next();
+            return problem(c, {
+                status: 403,
+                detail: `Slopify refused this request: it came from a web page at another address (${origin.slice(0, 100)}). Changes are made only from Slopify's own page; open Slopify and try again there.`,
+                extensions: { reason: "foreign-origin" },
+            });
+        }
+        const type = (c.req.header("content-type") ?? "").split(";")[0]?.trim().toLowerCase() ?? "";
+        if (formTypes.includes(type) && c.req.header("x-slopify-client") === undefined)
+            return problem(c, {
+                status: 403,
+                detail: "Slopify refused this request: it looks like a form another web page sent. Slopify's page sends its changes itself; open Slopify and try again there. A script on this computer can send the header X-Slopify-Client: script.",
+                extensions: { reason: "form-request" },
+            });
+        return next();
+    };
+}

package/dist/edge/http/reviews.js

@@ -1,6 +1,6 @@
 import { zValidator } from "@hono/zod-validator";
 import { Hono } from "hono";
-import { z } from "zod";
+import { errorText } from "../../kernel/errors.js";
 import { revisionControlSchema } from "../../slices/control/revision-control-schema.js";
 import { recoverProject } from "../../slices/rebuild/recovery.js";
 import { readRecovery } from "../../slices/rebuild/recovery-repo.js";
@@ -10,13 +10,11 @@ import { latestReviews } from "../../slices/reviews/view.js";
 import { currentRevisionId } from "../../slices/revisions/repo.js";
 import { getRevisionView } from "../../slices/revisions/view.js";
 import { actorOf } from "./actor.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 });
+import { idParam, idString } from "./ids.js";
+import { onInvalid, problem } from "./problem.js";
+import { refusal } from "./refusal.js";
+const id = idString;
+const projectParam = idParam;
 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
@@ -24,13 +22,11 @@ const verdictParam = projectParam.extend({ verdictId: id });
 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 decided = (c, verdict) => problem(c, {
         status: 409,
-        title: titleOf(409),
-        detail: `This verdict was already decided: the item was ${verdict.action === "overruled" ? "kept as it is" : "sent to be made again"}${verdict.actionBy === "agent" ? " by an agent" : ""}, so nothing changed. Reload the project page (or call needs_attention) to see what waits now.`,
+        detail: `This verdict was already decided: the item was ${verdict.action === "overruled" ? "kept as it is" : "sent to be made again"}${verdict.actionBy === "agent" ? " by an agent" : verdict.actionBy === "assistant" ? " by the assistant" : ""}, so nothing changed. Reload the project page (or call needs_attention) to see what waits now.`,
         extensions: { reason: "decided" },
     });
     const notify = (projectId) => {
@@ -40,7 +36,7 @@ export function reviewRoutes(deps) {
         catch (error) {
             deps.log.write("error", "review.notify", {
                 projectId,
-                detail: error instanceof Error ? error.message : String(error),
+                detail: errorText(error),
             });
         }
     };
@@ -62,7 +58,6 @@ export function reviewRoutes(deps) {
         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" },
         });
@@ -105,12 +100,10 @@ export function reviewRoutes(deps) {
         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.",
             });
         const already = () => 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" },
         });
@@ -138,11 +131,6 @@ export function reviewRoutes(deps) {
         }
     });
     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"
@@ -152,12 +140,11 @@ export function reviewRoutes(deps) {
                     : 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),
+        return refusal(c, result.reason, {
+            statuses: { "no-project": 404, "invalid-selection": 400, "invalid-edit": 400 },
+            otherwise: 409,
             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

@@ -4,13 +4,11 @@ import { z } from "zod";
 import { findRevisionDownload, revisionSetZip, } from "../../slices/revisions/downloads.js";
 import { fileResponse } from "./byte-range.js";
 import { replyForFolder } from "./folder-location.js";
-import { onInvalid, problem, titleOf } from "./problem.js";
+import { idString } from "./ids.js";
+import { onInvalid, problem } from "./problem.js";
+import { fromSlopifyPage } from "./same-page.js";
 import { waveformAnswer } from "./waveform.js";
-const id = z
-    .string()
-    .min(1)
-    .max(64)
-    .regex(/^[0-9A-Za-z_-]+$/);
+const id = idString;
 const revisionParam = z.object({ projectId: id, revisionId: id });
 const recordParam = revisionParam.extend({ recordId: id });
 const folderParam = z.object({ id, revisionId: id, recordId: id });
@@ -66,11 +64,9 @@ export function revisionFileRoutes(deps) {
 }
 export function revisionFolderRoutes(deps) {
     return new Hono().post("/:id/revisions/:revisionId/:recordId/open-folder", zValidator("param", folderParam, onInvalid), async (c) => {
-        const origin = c.req.header("origin");
-        if (origin !== undefined && origin !== new URL(c.req.url).origin)
+        if (!fromSlopifyPage(c, deps.remoteAccess?.remoteHost))
             return problem(c, {
                 status: 403,
-                title: titleOf(403),
                 detail: "For your safety, folders can only be opened from the Slopify page itself. Open Slopify and try again there.",
             });
         const { id: projectId, revisionId, recordId } = c.req.valid("param");
@@ -83,7 +79,6 @@ export function revisionFolderRoutes(deps) {
 function unavailable(c, reason) {
     return problem(c, {
         status: 404,
-        title: titleOf(404),
         detail: reason === "missing-file"
             ? "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."
             : reason === "no-images"

package/dist/edge/http/revisions.js

@@ -10,16 +10,14 @@ import { ensureBaseline, restoreRevision, saveRevision } from "../../slices/revi
 import { currentRevisionId, listRevisionHistory } from "../../slices/revisions/repo.js";
 import { restoreRevisionSchema, saveRevisionSchema } from "../../slices/revisions/schema.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 });
+import { idParam, idString } from "./ids.js";
+import { onInvalid, problem } from "./problem.js";
+import { refusal } from "./refusal.js";
+const id = idString;
+const projectParam = idParam;
 const revisionParam = projectParam.extend({ revisionId: id });
-const saveBody = saveRevisionSchema.extend({ idempotencyKey: z.uuid() });
-const restoreBody = restoreRevisionSchema.extend({ idempotencyKey: z.uuid() });
+export const saveBody = saveRevisionSchema.extend({ idempotencyKey: z.uuid() });
+export const restoreBody = restoreRevisionSchema.extend({ idempotencyKey: z.uuid() });
 const statuses = {
     "no-project": 404,
     "no-revision": 404,
@@ -45,13 +43,11 @@ const details = {
     readiness: "Slopify cannot run this rebuild yet. Fix the problems listed, then try again.",
 };
 function refused(c, deps, projectId, value) {
-    const status = statuses[value.reason];
-    return problem(c, {
-        status,
-        title: titleOf(status),
+    return refusal(c, value.reason, {
+        statuses,
+        otherwise: 409,
         detail: details[value.reason],
         extensions: {
-            reason: value.reason,
             currentRevisionId: currentRevisionId(deps.db, projectId) ?? null,
             fields: value.fields ?? [],
         },
@@ -60,7 +56,6 @@ function refused(c, deps, projectId, value) {
 function unavailable(c) {
     return problem(c, {
         status: 503,
-        title: titleOf(503),
         detail: "Rebuilding is not ready yet because Slopify is still starting. Wait a moment, reload the page and try again.",
     });
 }

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

@@ -3,7 +3,7 @@ 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";
+import { onInvalid, problem } 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
@@ -17,7 +17,6 @@ export function runCostRoutes(deps) {
         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));