@gentbajko/slopify 3.25.9 → 4.1.0

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 → Keys & services)",
+    },
+    {
+        method: "PUT",
+        path: new RegExp(`^/api/providers/${id}/path/?$`),
+        what: "A CLI's path is set (Settings → Keys & services)",
+    },
+    {
+        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,26 +131,20 @@ 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"
-                ? "Slopify can't make this item again yet. Fix what is listed in Settings → Providers or Edit project, then use Redo again."
+                ? "Slopify can't make this item again yet. Fix what is listed in Settings → Keys & services or Edit settings, 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),
+        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,9 +79,8 @@ 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."
+            ? "This file was deleted or moved from the project folder. Use Choose what to make again (in the project's More menu) to make it again."
             : reason === "no-images"
                 ? "There are no saved files of this kind to put in the zip yet. Wait for the step that makes them to finish, then download again."
                 : "This file is no longer part of the project. Reload the page to see its current files.",

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,
@@ -38,20 +36,18 @@ 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 Choose what to remake (in the project's More menu) again to see the latest.",
+    "stale-preview": "What needs rebuilding changed since you opened this review. Cancel it and open Choose what to make again (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.",
-    readiness: "Slopify cannot run this rebuild yet. Fix the problems listed, then try again.",
+    "review-required": "This touches content you supplied yourself. Tick “Keep the provided content” for each item in the review, then press the button that makes them again.",
+    "cost-ack-required": "Some prices aren't known in advance. Tick “Start even though …” in the review, then press the button that makes them again.",
+    readiness: "This can't start yet. Fix the items 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));

package/dist/edge/http/same-page.js

@@ -0,0 +1,80 @@
+// The address of what connected to this server: the browser, or a proxy in front of it.
+// Undefined for an in-process request, which has no socket.
+export function peerAddress(c) {
+    const env = c.env;
+    if (typeof env !== "object" || env === null || !("incoming" in env))
+        return undefined;
+    const incoming = env.incoming;
+    if (typeof incoming !== "object" || incoming === null || !("socket" in incoming))
+        return undefined;
+    const socket = incoming.socket;
+    if (typeof socket !== "object" || socket === null || !("remoteAddress" in socket))
+        return undefined;
+    return typeof socket.remoteAddress === "string" ? socket.remoteAddress : undefined;
+}
+const loopbackPeer = (address) => address !== undefined &&
+    (address === "::1" || /^(?:::ffff:)?127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/u.test(address));
+// The name the browser used, as a proxy on this computer passes it on in X-Forwarded-Host
+// (its first value). Only trusted from a loopback peer: anyone else could write the header.
+export function forwardedHost(c) {
+    if (!loopbackPeer(peerAddress(c)))
+        return undefined;
+    const first = c.req.header("x-forwarded-host")?.split(",")[0]?.trim();
+    return first === undefined || first === "" ? undefined : first;
+}
+// host[:port] with the scheme's default port left out, as an Origin's own host has it.
+function hostOf(host, scheme) {
+    const lower = host.trim().toLowerCase();
+    const fallback = scheme === "https:" ? ":443" : scheme === "http:" ? ":80" : undefined;
+    return fallback !== undefined && lower.endsWith(fallback)
+        ? lower.slice(0, -fallback.length)
+        : lower;
+}
+// Standard same-origin protection: a browser's Origin names the page that sent the request,
+// and a page at the very host:port the browser addressed is Slopify's own, whatever proxy
+// (Slopify's remote access, a `tailscale serve` set up by hand, Caddy, nginx) stands in front.
+// A cross-site page names its own host, so it never matches; which names may reach Slopify at
+// all is `request-guard.ts`'s Host check.
+function sameHost(c, origin) {
+    let url;
+    try {
+        url = new URL(origin);
+    }
+    catch {
+        return false;
+    }
+    if (url.host === "")
+        return false;
+    const own = url.host.toLowerCase();
+    return [c.req.header("host"), forwardedHost(c)].some((host) => host !== undefined && hostOf(host, url.protocol) === own);
+}
+// Whether a request with an Origin comes from the Slopify page itself: the page this server
+// serves, the page at the address the browser used for this request (through any proxy), or
+// the same page at the exact https address Slopify set up in Tailscale.
+export function fromSlopifyPage(c, remoteHost) {
+    const origin = c.req.header("origin");
+    if (origin === undefined || origin === new URL(c.req.url).origin)
+        return true;
+    if (sameHost(c, origin))
+        return true;
+    const remote = remoteHost?.();
+    return (remote !== undefined &&
+        origin === `https://${remote}` &&
+        (c.req.header("x-forwarded-host") ?? c.req.header("host")) === remote);
+}
+// A request that reached Slopify through a forwarding proxy, Tailscale serve included: it sets
+// X-Forwarded-For on every request and keeps the ts.net Host. Agents' endpoints answer only
+// requests made on this computer.
+export function viaProxy(headers) {
+    if (headers.has("x-forwarded-for") || headers.has("x-forwarded-host"))
+        return true;
+    if (headers.has("tailscale-user-login") || headers.has("tailscale-funnel-request"))
+        return true;
+    const host = headers.get("host") ?? "";
+    const name = host.replace(/:\d+$/u, "").toLowerCase();
+    return name.endsWith(".ts.net");
+}
+// Tailscale marks every request that came through Funnel, from the public internet.
+export function viaFunnel(headers) {
+    return headers.has("tailscale-funnel-request");
+}