@looop-games/cli 0.1.31 → 0.1.33

package/CHANGELOG.md

@@ -14,6 +14,32 @@ Versions: [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [0.1.33] - 2026-08-27
+
+### Added
+- **The dev server now carries an agent inbox** — `POST /__looop/agent-inbox`.
+  Dev tools in the running game (starting with the Performance tool's "Send to
+  agent" button) can ship a JSON report out of the browser; it lands as one
+  file under your game's `.looop/agent-inbox/` and prints one line in the
+  `looop dev` terminal. That folder is where your agent looks when you send it
+  something from inside the game — it ignores itself in git, so reports never
+  clutter `git status`. Only pages served by your own dev server can write to
+  it (cross-origin posts from other websites are refused), and single reports
+  are capped at 2 MB. There's no cleanup/rotation yet — reports are small and
+  yours to delete.
+
+## [0.1.32] - 2026-08-23
+
+### Fixed
+- `looop dev` no longer hands your game a **browser-blocked port**. It derives the
+  multiplayer and services ports from the game port, and a few combinations land
+  on ports browsers refuse to connect to (`ERR_UNSAFE_PORT` — e.g. game port 8050
+  derives multiplayer port 2049/NFS). The game booted but its room socket died
+  instantly, so it rendered blank with no owned player — and because `curl` and
+  headless tests ignore the blocklist, every check looked healthy. Dev now skips
+  any port block a browser can't reach, and warns if you pin an unreachable one
+  with `--port`.
+
 ## [0.1.31] - 2026-08-21
 
 ### Changed

package/lib/dev.mjs

@@ -16,7 +16,7 @@ import { ensureEngine } from './engine.mjs';
 import { createStaticServer } from './static-server.mjs';
 import { createLlmShim, DEFAULT_API_BASE } from './llm-shim.mjs';
 import { getToken, getApiBase } from './config.mjs';
-import { resolvePorts, portInUse, killPort, lanIp } from './ports.mjs';
+import { resolvePorts, portInUse, killPort, lanIp, isRestricted, nextBrowserSafe } from './ports.mjs';
 import { assertNoInertOverride, isFrameworkV2, isSinglePlayerV2, scanPrimitives } from './primitives.mjs';
 import { buildDevRoomServer, DEV_OVERRIDES_DIR } from './room-server.mjs';
 import { createFileWatcher, createRoomReloader } from './room-reload.mjs';
@@ -73,8 +73,18 @@ export async function dev({ cwd = process.cwd(), port, noMp = process.env.NO_MP
     requested: explicit,
   });
   for (const s of steppedAside) {
-    const who = s.projectDir ? `another Looop game (${basename(s.projectDir)})` : 'another app';
-    log(`→ :${s.port}  (held by ${who} — leaving it alone)`);
+    const who = s.reason === 'browser-restricted'
+      ? 'browser-restricted (mp/shim would be blocked) — stepping past'
+      : `held by ${s.projectDir ? `another Looop game (${basename(s.projectDir)})` : 'another app'} — leaving it alone`;
+    log(`→ :${s.port}  (${who})`);
+  }
+  // An EXPLICIT --port is obeyed as given, but if it derives a browser-blocked
+  // port (e.g. --port 8050 → mp 2049/NFS) the game would look broken with no
+  // clue, so say so loudly rather than silently binding it.
+  for (const [name, p] of [['multiplayer', ports.mp], ['services', ports.shim], ['static', ports.static]]) {
+    if (isRestricted(p)) {
+      log(`⚠ ${name} port :${p} is browser-restricted (ERR_UNSAFE_PORT) — browsers will refuse it. Re-run with a --port whose ${name} port is reachable (e.g. --port ${nextBrowserSafe(ports.static)}).`);
+    }
   }
   const children = [];
   const servers = [];
@@ -135,6 +145,7 @@ export async function dev({ cwd = process.cwd(), port, noMp = process.env.NO_MP
   const staticServer = createStaticServer({
     slug: project.slug,
     projectDir: project.dir, // answers /__looop/whoami — see ports.mjs
+    log, // agent-inbox report lines ride the dev logger
     mounts: [
       { url: `/games/${project.slug}/`, dir: project.dir },
       { url: '/shared/', dir: generatedOverridesDir },

package/lib/ports.mjs

@@ -35,6 +35,40 @@ export const STATIC_PORT_BASE = 8000;
 export const MP_PORT_BASE = 1999;
 export const SHIM_PORT_BASE = 8788;
 
+// Ports a BROWSER refuses to connect to (ERR_UNSAFE_PORT), from Chromium's
+// net/base/port_util.cc `kRestrictedPorts` (Firefox bans the same set). We
+// derive mp/shim from the static port, so a block landing ANY of the three on
+// one of these silently breaks the browser connection — while curl and a
+// headless probe connect fine, so every server-side check looks healthy. The
+// one that bites in the normal range is 2049 (NFS): static 8050 → mp 2049. The
+// full set keeps it robust if the derivation range ever shifts. Reported by a
+// creator (feedback fb_c690e35cff30511e).
+export const RESTRICTED_PORTS = new Set([
+  1, 7, 9, 11, 13, 15, 17, 19, 20, 21, 22, 23, 25, 37, 42, 43, 53, 69, 77, 79,
+  87, 95, 101, 102, 103, 104, 109, 110, 111, 113, 115, 117, 119, 123, 135, 137,
+  139, 143, 161, 179, 389, 427, 465, 512, 513, 514, 515, 526, 530, 531, 532,
+  540, 548, 554, 556, 563, 587, 601, 636, 989, 990, 993, 995, 1719, 1720, 1723,
+  2049, 3659, 4045, 5060, 5061, 6000, 6566, 6665, 6666, 6667, 6668, 6669, 6697,
+  10080,
+]);
+
+export function isRestricted(port) {
+  return RESTRICTED_PORTS.has(port);
+}
+
+/** True if a static base derives a block where static, mp, OR shim is browser-restricted. */
+export function blockIsRestricted(staticPort) {
+  const p = portsFor(staticPort);
+  return isRestricted(p.static) || isRestricted(p.mp) || isRestricted(p.shim);
+}
+
+/** The first static port ≥ `staticPort` whose whole derived block is browser-reachable. */
+export function nextBrowserSafe(staticPort) {
+  let p = staticPort;
+  while (blockIsRestricted(p)) p += 1;
+  return p;
+}
+
 // Ports move in BLOCKS: the browser derives mp/shim from location.port, so the
 // whole stack shifts together. 8000/1999/8788 → 8010/2009/8798 → …
 export const BLOCK_STRIDE = 10;
@@ -97,6 +131,15 @@ export async function resolvePorts({
   const steppedAside = [];
   for (let i = 0; i < blocks; i++) {
     const ports = portsFor(base + i * BLOCK_STRIDE);
+    // A block whose static/mp/shim lands on a browser-restricted port is
+    // unusable no matter how free it is — the browser refuses the connection
+    // (ERR_UNSAFE_PORT) even though curl and server checks pass. Skip it before
+    // probing, so auto-allocation only ever hands the creator a browser-
+    // reachable stack. (feedback fb_c690e35cff30511e — mp 2049/NFS on base 8050.)
+    if (blockIsRestricted(base + i * BLOCK_STRIDE)) {
+      steppedAside.push({ port: ports.static, projectDir: null, reason: 'browser-restricted' });
+      continue;
+    }
     const owner = (await portInUse(ports.static)) ? await whoIsOn(ports.static) : undefined;
 
     if (owner === undefined) {

package/lib/static-server.mjs

@@ -10,7 +10,7 @@
 // overrides dir mounts at /shared/ ahead of the bundle.
 import http from 'node:http';
 import { EventEmitter } from 'node:events';
-import { readdirSync, readFileSync, statSync, existsSync } from 'node:fs';
+import { readdirSync, readFileSync, statSync, existsSync, mkdirSync, writeFileSync } from 'node:fs';
 import { extname, join, normalize, sep } from 'node:path';
 import { injectHeadTags, rewriteHtmlScripts, rewriteJsImports, PLATFORM_URL, TOOLBOX_URL } from './inject.mjs';
 import { WHOAMI_PATH } from './ports.mjs';
@@ -34,6 +34,12 @@ const RELOAD_CLIENT = `<script>
 
 const WATCH_EXTS = new Set(['.html', '.css', '.js', '.mjs', '.json', '.svg', '.png', '.jpg', '.jpeg', '.gif', '.webp']);
 
+// The toolbox → agent report channel (see handleAgentInbox below). The path is
+// a contract with the toolbox shell's ctx.toAgent(); the cap keeps a runaway
+// payload from filling the disk — reports are small JSON summaries.
+export const AGENT_INBOX_PATH = '/__looop/agent-inbox';
+const AGENT_INBOX_MAX_BYTES = 2 * 1024 * 1024;
+
 const MIME = {
   '.html': 'text/html; charset=utf-8',
   '.js': 'text/javascript; charset=utf-8',
@@ -102,6 +108,7 @@ export function createStaticServer({
   injectReload = true,
   watchIntervalMs = 400,
   identity,
+  log = console.log,
   // A framework-v2 game's lowered skeleton — injected into the entry HTML as an
   // import map + globalThis.__LOOOP_SKELETON__ so startGame() can boot. Null for
   // a v1 game (no bare `looop` import, no skeleton).
@@ -234,10 +241,91 @@ export function createStaticServer({
     });
   }
 
+  // The agent inbox — the write half of the toolbox → agent channel (project
+  // note nf7zwa). A dev tool in the running game POSTs an envelope
+  // ({ tool, at, payload }, stamped by the toolbox shell); it lands as ONE file
+  // in <projectDir>/.looop/agent-inbox/ and prints one summary line. The file
+  // is the load-bearing sink: the agent working on this game usually does NOT
+  // hold the dev-server terminal, so stdout alone would be invisible to it.
+  // The mailbox dir ignores itself (a `.gitignore` of `*` inside it), so
+  // reports never show up in the creator's `git status` whatever repo shape
+  // the game has.
+  function handleAgentInbox(req, res) {
+    if (req.method !== 'POST') {
+      res.writeHead(405, { 'Content-Type': 'text/plain', Allow: 'POST' });
+      return res.end('POST only');
+    }
+    // Only the page this server itself served may write. A hostile website in
+    // the creator's browser can fire a no-preflight POST at localhost (a CORS
+    // "simple" content-type skips the preflight, and CORS only gates reading
+    // the response, never the server-side write) — and these files are later
+    // read by an AI agent as trusted tool reports, so a foreign page must not
+    // be able to author them. Browsers send Origin on every POST; the real
+    // client is served from this server, so its Origin equals our host.
+    // Non-browser callers (curl, node) send no Origin and pass — same trust
+    // level as anything else already running on the creator's machine/LAN.
+    const origin = req.headers.origin;
+    if (origin && origin !== `http://${req.headers.host}`) {
+      res.writeHead(403, { 'Content-Type': 'text/plain' });
+      return res.end('cross-origin post rejected');
+    }
+    const chunks = [];
+    let size = 0;
+    let overflowed = false;
+    req.on('data', (chunk) => {
+      if (overflowed) return; // draining the rest so the client can read the 413
+      size += chunk.length;
+      if (size > AGENT_INBOX_MAX_BYTES) {
+        overflowed = true;
+        chunks.length = 0;
+        res.writeHead(413, { 'Content-Type': 'text/plain', Connection: 'close' });
+        res.end(`report too large (max ${AGENT_INBOX_MAX_BYTES} bytes)`);
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on('end', () => {
+      if (overflowed) return;
+      let envelope;
+      try {
+        envelope = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+      } catch {
+        res.writeHead(400, { 'Content-Type': 'text/plain' });
+        return res.end('body must be JSON');
+      }
+      // The tool id names the file — it must be a plain slug, never a path.
+      const tool = envelope?.tool;
+      if (typeof tool !== 'string' || !/^[a-z0-9][a-z0-9-]{0,39}$/i.test(tool)) {
+        res.writeHead(400, { 'Content-Type': 'text/plain' });
+        return res.end('envelope needs a tool id ([a-z0-9-])');
+      }
+      try {
+        const inboxDir = join(projectDir, '.looop', 'agent-inbox');
+        mkdirSync(inboxDir, { recursive: true });
+        const selfIgnore = join(inboxDir, '.gitignore');
+        if (!existsSync(selfIgnore)) writeFileSync(selfIgnore, '*\n');
+        const d = new Date();
+        const p = (n, w = 2) => String(n).padStart(w, '0');
+        const stamp = `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}-${p(d.getHours())}-${p(d.getMinutes())}-${p(d.getSeconds())}-${p(d.getMilliseconds(), 3)}`;
+        let file = join(inboxDir, `${stamp}-${tool}.json`);
+        for (let n = 2; existsSync(file); n += 1) file = join(inboxDir, `${stamp}-${tool}-${n}.json`);
+        writeFileSync(file, JSON.stringify(envelope, null, 2) + '\n');
+        log(`agent-inbox: ${tool} (${(size / 1024).toFixed(1)} KB) → ${file}`);
+        sendBody(res, 200, JSON.stringify({ ok: true, file }), 'application/json');
+      } catch (err) {
+        res.writeHead(500, { 'Content-Type': 'text/plain' });
+        res.end(`agent-inbox write failed: ${err?.message ?? err}`);
+      }
+    });
+  }
+
   const server = http.createServer((req, res) => {
     const reqUrl = new URL(req.url, 'http://x');
     const urlPath = reqUrl.pathname;
     if (urlPath === '/__reload') return handleSse(res);
+    // Without a projectDir there is nowhere to land a report — the route
+    // simply doesn't exist (falls through to 404), same as any unknown path.
+    if (urlPath === AGENT_INBOX_PATH && projectDir) return handleAgentInbox(req, res);
     // Ownership probe (ports.mjs): "whose dev server is this?". It is what lets
     // another `looop dev` — a lane, another game — tell OUR stale server (kill
     // and reclaim) from a live one that belongs to somebody else (step around,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@looop-games/cli",
-  "version": "0.1.31",
+  "version": "0.1.33",
   "description": "Looop game development CLI — dev server, login, and publishing for standalone Looop games.",
   "type": "module",
   "license": "Apache-2.0",