mockpit 3.0.0 → 3.1.0

package/bin/poster.js

@@ -8,7 +8,8 @@
 // capture means the page runs live in the overviews, which is what it did before posters.
 //
 // The worker renders the served document and doesn't take a poster's place: one sent by the
-// agent wins, and the server refuses a still of a version that has since changed.
+// agent wins, and the server refuses a still of a version that has since changed. A system
+// write retakes the project's stills: one taken under an older revision no longer shows.
 
 import { spawn } from "node:child_process";
 import {
@@ -34,6 +35,8 @@ const CAPTURE_MS = 15_000;
 const LOAD_MS = 8_000;
 // A job this old describes a burst long past, and its version has likely moved on.
 const JOB_MAX_AGE_MS = 2 * 60_000;
+// Stills one system change retakes, latest variants first: the rest run live until then.
+const RETAKE_MAX = 40;
 // Stays up briefly for the next publish of a burst, which saves starting a browser again.
 const WORKER_IDLE_MS = 3_000;
 const WORKER_MAX_MS = 10 * 60_000;
@@ -111,6 +114,12 @@ export function queuePoster(job) {
   }
 }
 
+// { base, token, client, session, project }: after a system write that changed something.
+// The worker reads which variants need a new still, so this never waits either.
+export function queueRetakes(job) {
+  queuePoster({ ...job, retake: true });
+}
+
 // --- the browser, over the DevTools protocol on a local port ---
 
 async function launchBrowser(path) {
@@ -251,12 +260,48 @@ async function shoot(port, job, url, width) {
 
 // --- one job, end to end ---
 
+const headersOf = (job) => ({
+  "content-type": "application/json",
+  "x-mockpit-client": job.client,
+  ...(job.token ? { authorization: `Bearer ${job.token}` } : {}),
+});
+
+// A retake becomes one job per live variant whose page shows no still now: the views
+// already leave out one taken under another revision, and keep the agent's own.
+async function expandRetake(dir, job) {
+  const res = await fetch(`${job.base}/api/projects/${encodeURIComponent(job.project)}/tree`, {
+    headers: headersOf(job),
+  });
+  if (!res.ok) return;
+  const { tree } = await res.json();
+  const wanted = (tree ?? [])
+    .filter((d) => !d.archivedAt)
+    .flatMap((d) =>
+      (d.variants ?? [])
+        .filter((v) => v.status !== "archived" && v.surface >= 0 && !v.poster)
+        .map((v) => ({ design: d.id, postId: v.postId, version: v.version, at: v.updatedAt })),
+    )
+    .sort((a, b) => String(b.at).localeCompare(String(a.at)))
+    .slice(0, RETAKE_MAX);
+  const { retake: _r, project: _p, ...base } = job;
+  for (const [i, v] of wanted.entries()) {
+    const name = `${Date.now()}-${String(i).padStart(3, "0")}-retake.job`;
+    writeFileSync(
+      join(dir, name),
+      JSON.stringify({
+        ...base,
+        design: v.design,
+        postId: v.postId,
+        version: v.version,
+        queuedAt: Date.now(),
+      }),
+      { mode: 0o600 },
+    );
+  }
+}
+
 async function capture(port, job) {
-  const headers = {
-    "content-type": "application/json",
-    "x-mockpit-client": job.client,
-    ...(job.token ? { authorization: `Bearer ${job.token}` } : {}),
-  };
+  const headers = headersOf(job);
   const get = async (path) => {
     const res = await fetch(`${job.base}${path}`, { headers });
     if (!res.ok) throw new Error(`${path}: ${res.status}`);
@@ -283,6 +328,7 @@ async function capture(port, job) {
     ver: String(job.version),
     ...(mode ? { mode } : {}),
     ...(rewrites ? { w: String(rewrites) } : {}),
+    ...(design.systemRev ? { y: String(design.systemRev) } : {}),
   });
   const width = design.widths?.[0] ?? DEFAULT_WIDTH;
   const data = await shoot(
@@ -299,7 +345,14 @@ async function capture(port, job) {
   });
   await post(
     `/api/designs/${encodeURIComponent(job.design)}/variants/${encodeURIComponent(job.postId)}/poster`,
-    { version: job.version, rewrites, poster: asset.id, mode, session: job.session },
+    {
+      version: job.version,
+      rewrites,
+      poster: asset.id,
+      mode,
+      system: design.systemRev ?? 0,
+      session: job.session,
+    },
   );
 }
 
@@ -350,6 +403,10 @@ async function work() {
     }
     rmSync(file, { force: true });
     if (!job || !path || Date.now() - job.queuedAt > JOB_MAX_AGE_MS) continue;
+    if (job.retake) {
+      await expandRetake(dir, job).catch(() => {});
+      continue;
+    }
     try {
       if (!browser?.alive()) browser = await launchBrowser(path);
       if (browser) {

package/dist/mcp/server.js

@@ -68,6 +68,22 @@ async function api(path, init = {}) {
 }
 // Stdio runs on the agent's machine, so a value may name a file: markup and
 // asset bytes never have to travel through the model's context.
+// A sheet is CSS text when it has a block, else a path: a mistyped path must fail
+// rather than be sent as the project's stylesheet.
+function readSheet(value) {
+    if (value === "" || value.includes("{"))
+        return value;
+    let stat;
+    try {
+        stat = statSync(value);
+    }
+    catch {
+        throw new Error(`sheet: no file at ${value} (pass CSS text, or a path to a .css file)`);
+    }
+    if (!stat.isFile())
+        throw new Error(`sheet: ${value} is not a file`);
+    return readFileSync(value, "utf8");
+}
 function readMaybeFile(value) {
     if (value.includes("\n") || value.length > 512)
         return value;
@@ -284,11 +300,35 @@ const handlers = {
         }
         return post(`/api/designs/${enc(args.design)}`, { ...args, project, session }, "PATCH");
     },
-    export: (args) => json(`/api/designs/${enc(args.design)}/export${query({
-        project: resolveProject(args.project),
-        state: args.state,
-        variant: args.variant,
-    })}`),
+    async system(args) {
+        const session = await ensureSession();
+        const { project: named, ...rest } = args;
+        const project = resolveProject(named);
+        const writes = Object.keys(rest).filter((k) => rest[k] !== undefined);
+        if (writes.length === 0)
+            return json(`/api/projects/${enc(project)}/system`);
+        const body = typeof rest.sheet === "string" ? { ...rest, sheet: readSheet(rest.sheet) } : rest;
+        const result = await post(`/api/projects/${enc(project)}/system`, { ...body, session }, "PUT");
+        // Every page looks different now: its stills are taken again in the background.
+        const taking = result?.changed?.length ? await posters : null;
+        if (taking) {
+            taking.queueRetakes({
+                base: API.replace(/\/$/, ""),
+                token: TOKEN,
+                client: CLIENT,
+                session,
+                project,
+            });
+        }
+        return result;
+    },
+    export: (args) => args.design === undefined
+        ? json(`/api/projects/${enc(resolveProject(args.project))}/system/export`)
+        : json(`/api/designs/${enc(args.design)}/export${query({
+            project: resolveProject(args.project),
+            state: args.state,
+            variant: args.variant,
+        })}`),
     async upload({ path, data, contentType, filename, kind }) {
         const session = await ensureSession();
         // Stdio shares the agent's filesystem, so a path beats base64 in context.
@@ -304,7 +344,9 @@ const handlers = {
     // agent never restates them; a topic is the same text on every tier.
     guide: (args) => api(`/agent-howto${query(args.topic === undefined
         ? { project: resolveProject(args.project) }
-        : { topic: args.topic })}`),
+        : args.topic === "system"
+            ? { topic: args.topic, project: resolveProject(args.project) }
+            : { topic: args.topic })}`),
 };
 // The script travels as a file path when it can, so it is never JSON-escaped
 // into the model's tool call.