makersclaw 0.5.1 → 0.6.0

package/templates/next/files/check/run.mjs

@@ -10,29 +10,44 @@
 // example INSERTed into a shared table, a manifest entry whose file was
 // never written, an icon name that rendered nothing, a tweet card painted
 // in the workspace's tokens (unrecognisable as a tweet — the one thing
-// the app was for), a kit file "improved" per app.
+// the app was for), a kit file "improved" per app, a button whose server
+// action the app's own agent had no way to know about.
 //
 //   npm run check               static rules, then smoke
 //   npm run check -- --static   static rules only
 //
 // The smoke test builds for itself, and only when a source file is newer
-// than its last build. Where: in the sandbox the app folder is
-// `ubuntu:claw 2755` — the terminal user can read it, not write in it —
-// so the sources are copied to a folder of its own (`~/.claw-check/<app>`,
-// node_modules symlinked back) and built there. On a writable checkout
-// (local dev) it builds in place, into `.next-check` (CLAW_DIST_DIR,
-// next.config.mjs). Never into `.next`: that is the dev server's, and a
-// second build there dies with EACCES on .next/trace. The founder's live
-// preview keeps running, untouched, while the check runs beside it.
+// than its last build. Where: in place when the app folder is writable,
+// into `.next-check` (CLAW_DIST_DIR, next.config.mjs). Where it is not (a
+// sandbox tree made `2755` before claw opened app trees to its `claw`
+// group, tree-access.ts), the sources are copied to a folder of its own
+// (`~/.claw-check/<app>`, node_modules symlinked back) and built there.
+//
+// Never into `.next`: it is not the check's. In a working copy it is the
+// preview dev server's; in a live app it holds the production build the
+// platform made and serves, and whose .next/BUILD_ID it reads as proof of
+// a build. The founder's live preview keeps running, untouched, while the
+// check runs beside it. What Next 16 changed (16.3.7, 2026-09-29): `next
+// dev` keeps its own files in `.next/dev`, and a build by the same user
+// beside a running dev server works and leaves `dev/` alone. Under claw's
+// umask 002 a `.next` the dev server makes is 775, so the EACCES on
+// .next/trace that Next 15 hit across users should not happen in today's
+// sandbox (not tried with two Linux users). It comes back wherever the
+// builder cannot write `.next` (`chmod 555` on it: EACCES on .next/trace),
+// which is where one Linux user per app, claw's planned walls, leads.
+//
+// A copy's node_modules is a symlink back to the app's, and Turbopack
+// reads nothing outside its root, so the copy's build is told a root
+// that holds both (CLAW_TURBOPACK_ROOT, commonRoot below).
 //
 // Output is meant to be read by the platform agent in one glance: keep
 // it under twenty lines, name file:line, say what to do instead.
 
-import { accessSync, constants, cpSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, symlinkSync } from "node:fs";
+import { accessSync, constants, cpSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, rmSync, statSync, symlinkSync } from "node:fs";
 import { createHash } from "node:crypto";
 import { spawn, spawnSync } from "node:child_process";
 import { createServer } from "node:net";
-import { basename, dirname, join, relative } from "node:path";
+import { basename, dirname, join, relative, sep } from "node:path";
 import { homedir, tmpdir } from "node:os";
 import { fileURLToPath } from "node:url";
 
@@ -46,8 +61,11 @@ const STATIC_ONLY = process.argv.includes("--static");
 // `kit` rule refuses it (a shared piece goes in components/, a picture in
 // components/depictions/). The list is the template's; `makersclaw
 // update` lays both folders again.
-// Exact names AND extensions: Next resolves .js before .jsx, so a
-// components/ui/depiction.js beside depiction.jsx would win unseen.
+// Exact names AND extensions: a file of the same name with an extension
+// the bundler tries first wins unseen. Next 15's webpack tried .js before
+// .jsx (a components/ui/depiction.js beside depiction.jsx won); Next 16's
+// Turbopack tries .jsx before .js (seen on 16.3.7), so the kit's own file
+// wins there, but the rule holds for every bundler.
 const KIT = /^components\/(?:ui\/(?:cx|index)\.js|ui\/(?:radio|toggle|button-group|avatar|breadcrumb|pagination|button|collapsible|item|table|depiction|feedback|stat|distribution|swatch|steps|separator|scroll-area|field|icon|menu|context-menu|popover|calendar|date-picker|tooltip|notice|sheet|tabs|slider|input-group|image|file-input|input-otp|command|combobox|rating|toast|carousel|resizable)\.jsx|parts\/(?:index|sample)\.js|parts\/(?:fixture|record-switcher|live-work)\.jsx)$/;
 
 // The pins: sha256 of every fixed file, written by `makersclaw init` and
@@ -103,7 +121,7 @@ const SKIP = [
   /^app\/frame\.js$/,
   /^app\/claw-alive\/route\.js$/,
   /^app\/s\/\[key\]\/page\.jsx$/,
-  /^middleware\.js$/,
+  /^proxy\.js$/,
   /^next\.config\.mjs$/,
   /^postcss\.config\.mjs$/,
   /^public\//,
@@ -343,6 +361,13 @@ const surfaceKeys = [];
       if (e.isFile() && /^(?:ui|parts|depictions|blocks)\.[^.]+$/.test(e.name)) L.hit(`components/${e.name}`, "shadow", `a file beside the components/${e.name.replace(/\..*$/, "")}/ folder wins module resolution over it; delete it`);
     }
   }
+  // Next 16 runs proxy.js (fixed) before every request. A middleware file
+  // beside it, the name Next 15 used, fails the build; alone it would run
+  // in the token check's place. `makersclaw update` removes the template's
+  // own from 0.5.x.
+  for (const e of existsSync(ROOT) ? readdirSync(ROOT) : []) {
+    if (/^(?:middleware|proxy)\.(?:js|jsx|mjs|cjs|ts|tsx|mts|cts)$/.test(e) && e !== "proxy.js") L.hit(e, "proxy", `Next 16 runs proxy.js, the template's fixed token check; delete ${e}`);
+  }
   // check/ is this script and its pins; a module hidden there is bundled
   // by Next and read by no rule.
   if (existsSync(join(ROOT, "check"))) {
@@ -556,6 +581,74 @@ const surfaceKeys = [];
   else ok7(`${pictures} picture${pictures === 1 ? "" : "s"} of elsewhere, framed in ${hosts} file${hosts === 1 ? "" : "s"}: ${[...rendered.keys()].join(", ")}`);
 }
 
+// 8. The agent runs the app. Every server action that writes is named, by
+//    its function name in backticks, in the agent's brief beside the app
+//    (../AGENTS.md) or its references (../references/*.md), with the sql
+//    that does the same: anything a person can do on the screens, the
+//    app's agent can do. Born of Whiteboard 0.3.0 (2026-09-28): asked in
+//    chat for a board, its agent asked the member to make one, since
+//    nothing told it how. An app with no brief beside it (a copy on its
+//    own) is not checked here.
+{
+  const home = dirname(ROOT);
+  if (!existsSync(join(home, "AGENTS.md"))) ok("agent", "no AGENTS.md beside the app: its actions are not checked here");
+  else {
+    const refs = join(home, "references");
+    const brief = [join(home, "AGENTS.md"), ...(existsSync(refs) ? readdirSync(refs).filter((n) => n.endsWith(".md")).map((n) => join(refs, n)) : [])]
+      .map((p) => readFileSync(p, "utf8"))
+      .join("\n");
+    const WRITES =
+      /\b(insertRow|updateRow|deleteRow|moveRow|saveSetting)\s*\(|\binsert\s+into\b|\bupdate\s+(?:only\s+)?(?:public\.)?[a-z_][a-z0-9_]*(?:\s+(?:as\s+)?[a-z_][a-z0-9_]*)?\s+set\b|\bdelete\s+from\b/i;
+    // Every top-level function of a server file, bare or wrapped in a call
+    // (`export const save = safe(async (…) => …)`), exported by name or in
+    // an `export { … }` list. One writes when its body writes, or when it
+    // calls or hands on a function of its own file, or another action, that
+    // writes: a scan of direct SQL alone missed 67 of 669 in the store's
+    // apps (2026-09-28).
+    const HEAD =
+      /^(export\s+)?(?:async\s+)?function\s*\*?\s*([A-Za-z_$][\w$]*)\s*\(|^(export\s+)?const\s+([A-Za-z_$][\w$]*)\s*=\s*(?:[A-Za-z_$][\w$.]*\s*\(\s*)?(?:async\s*)?(?:function\b|\((?:[^()]|\([^()]*\))*\)\s*=>|[A-Za-z_$][\w$]*\s*=>)/gm;
+    const mentions = (body, name) => new RegExp(`(^|[^\\w$.])${name.replace(/\$/g, "\\$")}(?![\\w$])`).test(body);
+    const fns = [];
+    for (const f of appFiles) {
+      if (!/^\s*(["'])use server\1/m.test(f.text.split("\n").slice(0, 8).join("\n"))) continue;
+      const listed = new Map();
+      for (const m of f.code.matchAll(/^export\s*\{([^}]*)\}/gm))
+        for (const part of m[1].split(",")) {
+          const [local, as] = part.trim().split(/\s+as\s+/);
+          if (local) listed.set(local.trim(), (as ?? local).trim());
+        }
+      const heads = [...f.code.matchAll(HEAD)];
+      heads.forEach((m, i) => {
+        const name = m[2] ?? m[4];
+        const body = f.code.slice(m.index, heads[i + 1]?.index ?? f.code.length);
+        fns.push({ file: f.path, name, exported: m[1] || m[3] ? name : (listed.get(name) ?? null), body, writes: WRITES.test(body), where: `${f.path}:${lineOf(f.code, m.index)}` });
+      });
+    }
+    for (let changed = true; changed; ) {
+      changed = false;
+      const actions = fns.filter((g) => g.writes && g.exported).map((g) => g.exported);
+      for (const f of fns) {
+        if (f.writes) continue;
+        const local = fns.filter((g) => g.writes && g.file === f.file && g !== f).map((g) => g.name);
+        const others = actions.filter((n) => n !== f.exported && n !== f.name);
+        if ([...local, ...others].some((n) => mentions(f.body.slice(f.body.indexOf("(")), n))) f.writes = changed = true;
+      }
+    }
+    const writes = fns.filter((f) => f.writes && f.exported).map((f) => ({ where: f.where, name: f.exported }));
+    const missing = writes.filter((w) => !brief.includes(`\`${w.name}\``));
+    if (!writes.length) ok("agent", "no server action writes");
+    else if (missing.length)
+      fail(
+        "agent",
+        missing[0].where,
+        `${missing.length} of ${writes.length} server actions that write are not in the agent's brief: ` +
+          `${missing.slice(0, 6).map((w) => w.name).join(", ")}${missing.length > 6 ? ", …" : ""}. Name each in ` +
+          `../references/actions.md, in backticks, with the sql that does the same, so the app's agent can do what the screen does`,
+      );
+    else ok("agent", `all ${writes.length} server actions that write are in the agent's brief`);
+  }
+}
+
 // 6. Smoke: the app, built and started, answers every surface.
 
 /** Newest mtime among the app's own sources (what a build reads): walk
@@ -587,6 +680,18 @@ function buildSite() {
   return { dir: join(home, ".claw-check", name), dist: ".next", copied: true };
 }
 
+/** The nearest folder holding both paths, by their real paths ("/" at
+ *  worst). A copy's build reads node_modules through a symlink back to the
+ *  app, and Turbopack reads nothing outside its root: the check hands it
+ *  this folder as the root (CLAW_TURBOPACK_ROOT, next.config.mjs). */
+function commonRoot(a, b) {
+  const x = realpathSync(a).split(sep);
+  const y = realpathSync(b).split(sep);
+  let i = 0;
+  while (i < x.length && i < y.length && x[i] === y[i]) i++;
+  return x.slice(0, i).join(sep) || sep;
+}
+
 /** Copy the app's sources (never node_modules or a build) to `dir`, and
  *  point its node_modules back at the app's. */
 function copySources(dir) {
@@ -624,7 +729,12 @@ function buildForCheck(site, env) {
 async function smoke() {
   const site = buildSite();
   const base = { ...process.env, ...dotenv(join(ROOT, ".env")), NODE_ENV: "production", HOSTNAME: "127.0.0.1", CLAW_DIST_DIR: site.dist };
-  delete base.CLAW_PRODUCT_TOKEN; // the check is not the proxy; the middleware would 401 it
+  delete base.CLAW_TURBOPACK_ROOT;
+  if (site.copied) {
+    mkdirSync(site.dir, { recursive: true });
+    base.CLAW_TURBOPACK_ROOT = commonRoot(site.dir, ROOT);
+  }
+  delete base.CLAW_PRODUCT_TOKEN; // the check is not the product proxy; proxy.js would 401 it
   const built = buildForCheck(site, base);
   if (!built.ok) {
     fail("smoke", "build", `next build failed:\n${built.tail}`);

package/templates/next/files/lib/actions.js

@@ -10,7 +10,7 @@ import { ident, logActivity, query } from "./db";
 // are quoted through ident(), which refuses anything that is not a plain
 // identifier. Returns { ok } or { ok: false, error }; never throws.
 //
-// `surface` is optional: middleware.js stamps the current surface key on
+// `surface` is optional: proxy.js stamps the current surface key on
 // the request, so a surface rarely needs to pass it.
 //
 // `detail` is the founder's sentence for the row. The OS Activity tab

package/templates/next/files/lib/data.js

@@ -160,7 +160,7 @@ export async function loadActivity({ limit = 100, surface, since } = {}) {
  *  code keeps one import. */
 export { markSample };
 
-/** The surface key of the current request (middleware.js sets it from
+/** The surface key of the current request (proxy.js sets it from
  *  /s/<key>), unless the caller names one — a string, or the page's
  *  `surface` object. */
 export async function currentSurface(explicit) {

package/templates/next/files/next.config.mjs

@@ -7,8 +7,8 @@
 // attribute app/layout.jsx renders is the runtime copy and is read first, so
 // a start under a different prefix than the build still resolves.
 //
-// allowedOrigins is NOT optional here, and it is not yours to edit. Next 15
-// refuses a Server Action whose `Origin` header disagrees with
+// allowedOrigins is NOT optional here, and it is not yours to edit. Next
+// (15 and 16) refuses a Server Action whose `Origin` header disagrees with
 // `x-forwarded-host` — and in this stack they always disagree, because the
 // sandbox ingress rewrites `x-forwarded-host` to its own vercel.run name
 // while the browser is on the product host. Without this the app loads
@@ -23,19 +23,61 @@ const allowedOrigins = (process.env.CLAW_ALLOWED_ORIGINS || "")
   .map((o) => o.trim())
   .filter(Boolean);
 
+// The same hosts, for `next dev` alone. Next 16 refuses a request for a
+// dev resource (/_next/*, /__nextjs*: the HMR socket, the error overlay's
+// lookups) whose Origin host is not localhost or listed here; Next 15 only
+// warned. The preview's browser is on the product host, so without this
+// every such request answers 403. Hostnames only: Next compares no port.
+const allowedDevOrigins = [
+  ...new Set(
+    allowedOrigins
+      .map((o) => o.replace(/^[a-z][a-z0-9+.-]*:\/\//i, "").replace(/\/.*$/, "").replace(/:\d+$/, "").toLowerCase())
+      .filter(Boolean),
+  ),
+];
+
 // `npm run check` builds into its own folder (CLAW_DIST_DIR=.next-check,
-// check/run.mjs) so it never touches `.next`: in the sandbox the running
-// dev server owns that folder as another user, and a second `next build`
-// there dies with EACCES on .next/trace before it starts.
+// check/run.mjs) so it never touches `.next`, which is not the check's:
+// in a working copy it is the dev server's, and in a live app it holds
+// the production build the platform made, serves and reads as its proof
+// (.next/BUILD_ID). check/run.mjs says more.
+//
+// CLAW_TURBOPACK_ROOT is set by `npm run check` alone, when it builds a
+// copy of an app folder it cannot write (check/run.mjs buildSite). The
+// copy's node_modules is a symlink back to the app's, and Turbopack (Next
+// 16's bundler for build as well as dev) refuses a symlink that leaves its
+// root: "Symlink [project]/node_modules is invalid, it points out of the
+// filesystem root". The check names the nearest folder holding both.
+// Unset, Turbopack finds the root itself.
+const turbopackRoot = process.env.CLAW_TURBOPACK_ROOT || "";
+
+// agentRules: false. Next 16's `next dev` writes AGENTS.md and CLAUDE.md
+// into the app folder when it sees an AI agent in its environment
+// (AI_AGENT, CLAUDECODE…), telling the agent to read Next's own docs.
+// This app's agent brief is the platform's, beside the app, and the app
+// folder holds only what the template and the app's own screens put there.
+//
+// mcpServer: false. Next 16's `next dev` also serves an MCP endpoint at
+// /_next/mcp (the app's routes, logs and errors, the errors of every
+// browser on the page, a route compile) and answers it before proxy.js
+// runs, so no product token guards it. Off: the token check is meant to
+// be the preview's only door. One more answers there that no setting
+// turns off, the dev overlay's /__nextjs_attach-nodejs-inspector (it
+// opens a Node debugger on loopback); only the platform can wall that
+// (CHANGELOG, 0.6.0).
 const nextConfig = {
   basePath: process.env.CLAW_BASE_PATH || "",
   distDir: process.env.CLAW_DIST_DIR || ".next",
   env: {
     CLAW_BASE_PATH: process.env.CLAW_BASE_PATH || "",
   },
-  ...(allowedOrigins.length > 0
-    ? { experimental: { serverActions: { allowedOrigins } } }
-    : {}),
+  agentRules: false,
+  ...(allowedDevOrigins.length > 0 ? { allowedDevOrigins } : {}),
+  ...(turbopackRoot ? { turbopack: { root: turbopackRoot }, outputFileTracingRoot: turbopackRoot } : {}),
+  experimental: {
+    mcpServer: false,
+    ...(allowedOrigins.length > 0 ? { serverActions: { allowedOrigins } } : {}),
+  },
 };
 
 export default nextConfig;

package/templates/next/files/package.json

@@ -10,10 +10,10 @@
   },
   "dependencies": {
     "@tailwindcss/postcss": "^4",
-    "next": "^15.4.0",
+    "next": "^16.3.7",
     "pg": "^8.16.0",
-    "react": "^19.1.0",
-    "react-dom": "^19.1.0",
+    "react": "^19.3.0",
+    "react-dom": "^19.3.0",
     "tailwindcss": "^4"
   }
 }

package/templates/next/files/{middleware.js → proxy.js}

@@ -1,8 +1,15 @@
 import { NextResponse } from "next/server";
 
-// The only door is the Makersclaw dashboard proxy, which stamps this token
-// on every request. The sandbox port itself is public, so without this
-// check anyone with the URL could read the founder's data.
+// Next runs this before every request. Until 0.6.0 it was middleware.js
+// (Next 15's name for it); Next 16 renamed the file and its export to
+// `proxy`, and runs it on Node, never the edge runtime. A middleware.js
+// beside this file fails the build, so `makersclaw update` removes the old
+// one. Not to be confused with the product proxy, the Makersclaw dashboard
+// door that sits in front of the whole app.
+//
+// The only door is that product proxy, which stamps this token on every
+// request. The sandbox port itself is public, so without this check
+// anyone with the URL could read the founder's data.
 //
 // It also tells the server which surface a request is for: /s/<key> becomes
 // the x-claw-surface request header, so lib/data.js and lib/actions.js can
@@ -13,12 +20,12 @@ import { NextResponse } from "next/server";
 // the desk, and the product proxy carries it as the x-claw-theme header
 // on every later request (the browser's cookies never reach the app).
 // ?theme= on any URL wins for that request and sets the claw_theme cookie
-// too, so the app keeps its theme when run without the proxy (local
-// `next dev`). app/layout.jsx reads header, then cookie, onto
+// too, so the app keeps its theme when run without the product proxy
+// (local `next dev`). app/layout.jsx reads header, then cookie, onto
 // <html data-theme>.
 const THEMES = new Set(["light", "dark"]);
 
-export function middleware(request) {
+export function proxy(request) {
   const expected = process.env.CLAW_PRODUCT_TOKEN;
   if (expected && request.headers.get("x-claw-product-token") !== expected) {
     return new NextResponse("Open this app from your Makersclaw dashboard.", {