agents-city 0.1.0

package/bin/navegador.mjs

@@ -0,0 +1,243 @@
+#!/usr/bin/env node
+/* Drive a real Chrome against a running Hall, over the DevTools protocol.
+ *
+ * Why this exists: every other suite in this repo can pass while the page is
+ * dead. Instruction editors and a zip upload once shipped rendered, typechecked
+ * and fully tested on the server side — and wired to nothing. `tsc` cannot see
+ * an event handler that was never attached, and neither can a DOM-free test.
+ * Only a browser that clicks can.
+ *
+ * No dependency: Node 22 has a global WebSocket, and CDP is JSON over one. A
+ * headless browser is heavy enough without a driver library on top.
+ *
+ *   node bin/navegador.mjs <url>
+ *
+ * Prints one line per check and exits non-zero if any failed.
+ */
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { mkdtemp } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+const CANDIDATOS = [
+  process.env.CHROME_PATH,
+  '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+  '/Applications/Chromium.app/Contents/MacOS/Chromium',
+  '/usr/bin/google-chrome',
+  '/usr/bin/google-chrome-stable',
+  '/usr/bin/chromium',
+  '/usr/bin/chromium-browser',
+  '/snap/bin/chromium',
+].filter(Boolean);
+
+function dondeEstaChrome() {
+  return CANDIDATOS.find((p) => existsSync(p)) || '';
+}
+
+/** Chrome prints its DevTools endpoint on stderr; that is the handshake. */
+function esperaEndpoint(proceso, limite = 20000) {
+  return new Promise((listo, falla) => {
+    let visto = '';
+    const reloj = setTimeout(() => falla(new Error('chrome never announced its port')), limite);
+    proceso.stderr.on('data', (trozo) => {
+      visto += trozo.toString();
+      const m = visto.match(/ws:\/\/[^\s]+/);
+      if (m) {
+        clearTimeout(reloj);
+        listo(m[0]);
+      }
+    });
+    proceso.on('exit', (codigo) => {
+      clearTimeout(reloj);
+      falla(new Error(`chrome exited with ${codigo}: ${visto.slice(-400)}`));
+    });
+  });
+}
+
+class Cdp {
+  constructor(socket) {
+    this.socket = socket;
+    this.n = 0;
+    this.pendientes = new Map();
+    socket.addEventListener('message', (evento) => {
+      const mensaje = JSON.parse(evento.data);
+      const espera = this.pendientes.get(mensaje.id);
+      if (!espera) return;
+      this.pendientes.delete(mensaje.id);
+      mensaje.error ? espera.falla(new Error(JSON.stringify(mensaje.error))) : espera.listo(mensaje.result);
+    });
+  }
+
+  static async abre(url) {
+    const socket = new WebSocket(url);
+    await new Promise((listo, falla) => {
+      socket.addEventListener('open', listo, { once: true });
+      socket.addEventListener('error', () => falla(new Error('cannot reach chrome')), { once: true });
+    });
+    return new Cdp(socket);
+  }
+
+  manda(metodo, params = {}) {
+    const id = ++this.n;
+    this.socket.send(JSON.stringify({ id, method: metodo, params }));
+    return new Promise((listo, falla) => this.pendientes.set(id, { listo, falla }));
+  }
+
+  /** Evaluate in the page and return the value, awaiting promises. */
+  async evalua(expresion) {
+    const r = await this.manda('Runtime.evaluate', {
+      expression: expresion,
+      awaitPromise: true,
+      returnByValue: true,
+    });
+    if (r.exceptionDetails) {
+      throw new Error(r.exceptionDetails.exception?.description ?? 'page threw');
+    }
+    return r.result.value;
+  }
+}
+
+const dormir = (ms) => new Promise((r) => setTimeout(r, ms));
+
+let fallos = 0;
+function comprueba(texto, bien, detalle = '') {
+  console.log(`${bien ? '  ok  ·' : '  FAIL·'} ${texto}${bien || !detalle ? '' : `\n        ${detalle}`}`);
+  if (!bien) fallos += 1;
+}
+
+async function main() {
+  const url = process.argv[2];
+  if (!url) {
+    console.error('usage: navegador.mjs <hall url>');
+    process.exit(2);
+  }
+  const chrome = dondeEstaChrome();
+  if (!chrome) {
+    if (process.env.CITY_BROWSER_REQUIRED === '1') {
+      console.error('  no Chrome on this machine, and CITY_BROWSER_REQUIRED=1');
+      process.exit(1);
+    }
+    console.log('  no Chrome here — browser checks skipped');
+    process.exit(0);
+  }
+  const perfil = await mkdtemp(join(tmpdir(), 'agents-city-chrome-'));
+  const proceso = spawn(chrome, [
+    '--headless=new',
+    '--remote-debugging-port=0',
+    '--no-first-run',
+    '--no-default-browser-check',
+    '--disable-gpu',
+    '--disable-dev-shm-usage',
+    `--user-data-dir=${perfil}`,
+    'about:blank',
+  ]);
+  try {
+    // Talk to the PAGE's own socket rather than the browser's: no sessions to
+    // thread through every message, which is where a hand-rolled driver goes
+    // wrong first.
+    const endpoint = await esperaEndpoint(proceso);
+    const base = new URL(endpoint.replace(/^ws/, 'http'));
+    const pestanas = await (await fetch(`http://${base.host}/json/list`)).json();
+    const pagina = pestanas.find((t) => t.type === 'page' && t.webSocketDebuggerUrl);
+    if (!pagina) throw new Error('chrome opened no page to drive');
+    const cdp = await Cdp.abre(pagina.webSocketDebuggerUrl);
+
+    await cdp.manda('Page.enable');
+    await cdp.manda('Runtime.enable');
+    await cdp.manda('Page.navigate', { url });
+    for (let i = 0; i < 60; i += 1) {
+      const listo = await cdp.evalua('!!document.getElementById("rail") && !!window.PASE');
+      if (listo) break;
+      await dormir(250);
+    }
+
+    comprueba(
+      'the hall loads and reads its city',
+      await cdp.evalua(
+        '(async () => { for (let i = 0; i < 40; i++) { if (document.querySelectorAll("nav li").length) return true; await new Promise(r => setTimeout(r, 250)); } return false; })()',
+      ),
+    );
+
+    // The skin, both ways, and remembered.
+    const tema = await cdp.evalua(`(() => {
+      const b = document.getElementById('temaBoton');
+      if (!b) return { falta: true };
+      const antes = document.documentElement.getAttribute('data-tema');
+      b.click();
+      const despues = document.documentElement.getAttribute('data-tema');
+      return { antes, despues, guardado: localStorage.getItem('hall-tema'), etiqueta: b.textContent.trim() };
+    })()`);
+    comprueba(
+      'the day/night switch flips the page and remembers the choice',
+      !!tema && !tema.falta && tema.despues && tema.guardado === tema.despues,
+      JSON.stringify(tema),
+    );
+
+    // The agents view: this is where dead controls shipped once.
+    const abierto = await cdp.evalua(`(async () => {
+      const ir = [...document.querySelectorAll('nav li')].find(l => /agents/i.test(l.textContent));
+      if (!ir) return { falta: 'no agents entry' };
+      ir.click();
+      for (let i = 0; i < 40; i++) {
+        if (document.querySelector('.fichaRPG')) break;
+        await new Promise(r => setTimeout(r, 250));
+      }
+      const boton = (sel) => { const e = document.querySelector(sel); return e ? !!(e.onclick || e.onchange) : null; };
+      return {
+        fichas: document.querySelectorAll('.fichaRPG').length,
+        alta: boton('#altaAgente'),
+        instrucciones: boton('.rpgIns'),
+        subir: boton('.rpgSubir input'),
+        monta: boton('.rpgMonta'),
+        dado: boton('.rpgDado'),
+        test: boton('.rpgTest'),
+      };
+    })()`);
+    comprueba('the agents view renders its sheets', (abierto?.fichas ?? 0) > 0, JSON.stringify(abierto));
+    for (const [control, etiqueta] of [
+      ['alta', '+ Add an agent'],
+      ['instrucciones', 'the CLAUDE.md / AGENTS.md editors'],
+      ['subir', 'the skill zip upload'],
+      ['monta', 'the + folder mount button'],
+      ['dado', 'the avatar reroll'],
+      ['test', 'the engine test button'],
+    ]) {
+      comprueba(
+        `${etiqueta} is wired to a handler, not just drawn`,
+        abierto?.[control] === true,
+        `${control}=${JSON.stringify(abierto?.[control])}`,
+      );
+    }
+
+    // And one of them actually does something when clicked.
+    const modal = await cdp.evalua(`(async () => {
+      const b = document.querySelector('.rpgIns');
+      if (!b) return { falta: true };
+      b.click();
+      for (let i = 0; i < 40; i++) {
+        const m = document.getElementById('editorIns');
+        if (m && !m.hidden) return { abierto: true, titulo: document.getElementById('edTitulo')?.textContent ?? '' };
+        await new Promise(r => setTimeout(r, 250));
+      }
+      return { abierto: false };
+    })()`);
+    comprueba(
+      'clicking CLAUDE.md opens the editor on that agent',
+      modal?.abierto === true && /CLAUDE\.md/.test(modal.titulo ?? ''),
+      JSON.stringify(modal),
+    );
+
+    const errores = await cdp.evalua('window.__erroresDePagina ? window.__erroresDePagina.length : 0');
+    comprueba('the page raised no uncaught errors while we drove it', errores === 0, String(errores));
+  } finally {
+    proceso.kill('SIGKILL');
+  }
+  console.log(`\n  ${fallos ? `${fallos} failed` : 'browser ok'} — 11 checks\n`);
+  process.exit(fallos ? 1 : 0);
+}
+
+main().catch((e) => {
+  console.error(`  browser checks could not run: ${e.message}`);
+  process.exit(1);
+});

package/bin/report.py

@@ -0,0 +1,14 @@
+#!/usr/bin/env python3
+"""Report growth from where the work actually happens.
+
+A one-line wrapper. The reporter itself ships inside the plugin, because that is
+what gets installed on everybody's machine — and growth for a marketing, legal or
+finance city has to be counted where the folders are.
+
+    ./bin/report.py --push
+"""
+import os
+import sys
+os.execv(sys.executable, [sys.executable,
+         os.path.join(os.path.dirname(os.path.abspath(__file__)),
+                      '..', 'plugin', 'scripts', 'report.py'), *sys.argv[1:]])

package/bin/reset

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+# Reset exactly one managed city, with a recovery copy.
+exec python3 "$(cd "$(dirname "$0")/../plugin/scripts" && pwd)/reset.py" "$@"

package/bin/road

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+# Open, inspect or close explicit roads between cities.
+exec python3 "$(cd "$(dirname "$0")/../plugin/scripts" && pwd)/roads.py" "$@"

package/bin/seat

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+# Sit down to work: one command, no account, no setup.
+#
+#   ./bin/seat --help    what it asks and what it writes
+#
+# The logic is in plugin/scripts/seat.py and not here, because that folder is what
+# gets installed on everybody's machine — so `/city:join`, which runs inside Claude
+# from an installed plugin with no clone around it, reaches exactly the same code.
+# One job, one implementation, two doors.
+exec python3 "$(cd "$(dirname "$0")/../plugin/scripts" && pwd)/seat.py" "$@"