agents-city 0.3.0-beta.21 → 0.3.0

package/bin/test-navegador.py

@@ -0,0 +1,164 @@
+#!/usr/bin/env python3
+"""The Hall, in a real browser that clicks.
+
+    ./bin/test-navegador.py
+
+Every other suite in this repo can pass while the page is dead. The instruction
+editors and the skill upload once shipped rendered, typechecked, and wired to
+nothing at all: `tsc` cannot see a handler that was never attached, and a
+DOM-free assertion cannot click. This suite is the answer to that class of bug,
+and it exists because that bug shipped.
+
+It serves a real Hall over loopback with a throwaway city behind it, drives
+headless Chrome over the DevTools protocol (`bin/navegador.mjs`, no driver
+library), and asserts that the controls DO something. Without a browser on the
+machine it says so and passes; CI sets CITY_BROWSER_REQUIRED=1 so a runner that
+lost its Chrome fails loudly instead of quietly testing nothing.
+"""
+
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+import threading
+
+AQUI = os.path.dirname(os.path.abspath(__file__))
+RAIZ = os.path.dirname(AQUI)
+sys.path.insert(0, os.path.join(RAIZ, "plugin", "scripts"))
+sys.path.insert(0, AQUI)
+
+import serve  # noqa: E402
+from testlib import afirma, resumen  # noqa: E402
+
+
+def disco_de_prueba():
+    """A small disk with one folder of documents on it.
+
+    The mount picker is only testable against something: with an empty search
+    root the chips are empty either way, and a search box that filters nothing
+    down to nothing would pass a test while being useless.
+    """
+    raiz = tempfile.mkdtemp()
+    boveda = os.path.join(raiz, "manual")
+    os.makedirs(boveda)
+    for n in ("uno.md", "dos.md", "tres.md"):
+        open(os.path.join(boveda, n), "w").close()
+    return raiz
+
+
+def ciudad_de_prueba(datos):
+    """A city with one agent in it, so the sheets have something to draw."""
+    with open(os.path.join(datos, "city.yml"), "w", encoding="utf-8") as f:
+        f.write("id: city_browser_v1\nname: Browser Test\nslug: browser\nowner: navtest\n")
+    taller = os.path.join(datos, "agents", "notas")
+    os.makedirs(taller, exist_ok=True)
+    with open(os.path.join(taller, "apuntes.md"), "w", encoding="utf-8") as f:
+        f.write("# notas\n")
+    with open(os.path.join(datos, "navtest.md"), "w", encoding="utf-8") as f:
+        f.write(
+            "---\n"
+            "user: navtest\nname: Nav Test\nrole: cpto\nagent: navtest/seat\n"
+            "agents: [notas]\nkind.notas: knowledge\nrole.notas: apuntes\n"
+            "goals_defined: false\n---\n\n# navtest\n"
+        )
+
+
+def bundle_al_dia():
+    """Rebuild the Hall bundle when this machine can, so the browser drives the
+    CURRENT source.
+
+    The bundles are committed so an install needs no build step, which means a
+    stale one is exactly what a browser test would happily pass against — the
+    bug it exists to catch, one level down. Where esbuild is not installed the
+    committed bundle is what ships, and testing that is honest too.
+    """
+    web = os.path.join(RAIZ, "city", "web")
+    if not os.path.isdir(os.path.join(web, "node_modules", "esbuild")):
+        return "committed bundle (no esbuild here)"
+    hecho = subprocess.run(
+        [
+            os.path.join(web, "node_modules", ".bin", "esbuild"),
+            os.path.join(web, "src", "hall.ts"),
+            "--bundle",
+            "--format=esm",
+            "--outfile=" + os.path.join(web, "dist-hall", "hall.js"),
+        ],
+        capture_output=True,
+        text=True,
+        timeout=180,
+    )
+    if hecho.returncode != 0:
+        return "committed bundle (build failed)"
+    return "rebuilt from src/hall.ts"
+
+
+def main():
+    print()
+    print("  the hall, in a browser that clicks")
+    print(f"  · {bundle_al_dia()}")
+    datos = tempfile.mkdtemp()
+    casa = tempfile.mkdtemp()
+    serve.cities.REGISTRO = os.path.join(tempfile.mkdtemp(), "cities")
+    previo = {k: os.environ.get(k) for k in ("AGENTS_CITY_DATA", "AGENTS_CITY_HOME",
+                                             "AGENTS_CITY_USER", "CITY_SEARCH_IN",
+                                             "XDG_CACHE_HOME")}
+    os.environ.update(
+        AGENTS_CITY_DATA=datos,
+        AGENTS_CITY_HOME=casa,
+        AGENTS_CITY_USER="navtest",
+        CITY_SEARCH_IN=disco_de_prueba(),
+        XDG_CACHE_HOME=tempfile.mkdtemp(),
+    )
+    ciudad_de_prueba(datos)
+
+    # A SECOND city, deliberately empty: the guide only appears where there is
+    # nothing yet, and the first fixture has an agent so the sheets can render.
+    try:
+        vacia = serve.cities.crea("navtest", "sin-nadie", usar=False)
+    except (OSError, ValueError):
+        vacia = ""
+
+    servidor = serve.Servidor(("127.0.0.1", 0), serve.Manejador)
+    hilo = threading.Thread(target=servidor.serve_forever, daemon=True)
+    hilo.start()
+    url = f"http://127.0.0.1:{servidor.server_port}/?PASE={serve.PASE}"
+    try:
+        salida = subprocess.run(
+            ["node", os.path.join(AQUI, "navegador.mjs"), url, vacia],
+            capture_output=True,
+            text=True,
+            timeout=300,
+        )
+        texto = (salida.stdout or "") + (salida.stderr or "")
+        if "skipped" in texto and salida.returncode == 0:
+            print("  no browser on this machine — the clicking checks were skipped")
+            print("\n  navegador ok — 0 checks (no browser on this machine)\n")
+            return 0
+        # Each browser check counts as one here: a suite that reports "1 check"
+        # for eleven assertions hides both its coverage and which one broke.
+        vistas = 0
+        for linea in texto.splitlines():
+            limpia = linea.strip()
+            if limpia.startswith("ok  ·") or limpia.startswith("FAIL·"):
+                vistas += 1
+                afirma("· " + limpia.split("·", 1)[1].strip(), limpia.startswith("ok"), "")
+        if not vistas:
+            afirma("· the browser checks ran at all", False, texto.strip()[-500:])
+        elif salida.returncode != 0:
+            afirma("· the browser driver finished cleanly", False, texto.strip()[-300:])
+    finally:
+        servidor.shutdown()
+        servidor.server_close()
+        for k, v in previo.items():
+            if v is None:
+                os.environ.pop(k, None)
+            else:
+                os.environ[k] = v
+        shutil.rmtree(datos, ignore_errors=True)
+        shutil.rmtree(casa, ignore_errors=True)
+    return resumen("navegador")
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/bin/test-seat.py

@@ -25,6 +25,7 @@ is said when a machine cannot do this at all.
 import importlib.machinery as mach
 import importlib.util as iu
 import base64
+import json
 import os
 import shlex
 import shutil
@@ -37,7 +38,7 @@ RAIZ = os.path.dirname(AQUI)
 sys.path.insert(0, AQUI)
 sys.path.insert(0, os.path.join(RAIZ, "plugin", "scripts"))
 
-from testlib import comprueba, afirma, resumen  # noqa: E402
+from testlib import comprueba, afirma, resumen, roster  # noqa: E402
 
 
 def carga_seat():
@@ -95,11 +96,7 @@ def camino_feliz():
     os.makedirs(datos)
     ficha = os.path.join(datos, "ana.md")
     S.escribe_ficha(
-        ficha,
-        "ana",
-        "cpto",
-        ["api", "web"],
-        repo_roles={"api": "data-engineer", "web": "seo"},
+        ficha, "ana", "cpto", roster(("api", "code", "data-engineer"), ("web", "code", "seo"))
     )
 
     texto = open(ficha).read()
@@ -108,7 +105,8 @@ def camino_feliz():
         ("user", "ana"),
         ("role", "cpto"),
         ("agent", "ana/lead"),
-        ("repos", "[api, web]"),
+        ("agents", "[api, web]"),
+        ("kind.api", "code"),
         ("role.api", "data-engineer"),
         ("role.web", "seo"),
     ):
@@ -120,11 +118,23 @@ def camino_feliz():
 
     # The one field the session actually reads, read the way the session reads it.
     leido = subprocess.run(
-        ["python3", os.path.join(RAIZ, "plugin", "scripts", "read-card.py"), ficha, "repos"],
+        ["python3", os.path.join(RAIZ, "plugin", "scripts", "read-card.py"), ficha, "agents"],
         capture_output=True,
         text=True,
     ).stdout.strip()
-    comprueba("· read-card.py gets the repos back out", leido, "api,web")
+    comprueba("· read-card.py gets the roster back out", leido, "api,web")
+    # And the shape nothing writes any more is still READ, forever: an old city
+    # on somebody's disk keeps opening exactly as it did.
+    vieja = os.path.join(datos, "vieja.md")
+    with open(vieja, "w", encoding="utf-8") as f:
+        f.write("---\nuser: leg\nagent: leg/lead\nrepos: [api, web]\nrole.api: dev\n---\n")
+    heredado = subprocess.run(
+        ["python3", os.path.join(RAIZ, "plugin", "scripts", "read-card.py"), vieja, "repos"],
+        capture_output=True,
+        text=True,
+    ).stdout.strip()
+    comprueba("· a legacy repos: card is still read, though nothing writes one",
+              heredado, "api,web")
     agente = subprocess.run(
         ["python3", os.path.join(RAIZ, "plugin", "scripts", "read-card.py"), ficha, "agent"],
         capture_output=True,
@@ -337,7 +347,7 @@ def caminos_infelices():
     # could keep up with every vendor's flags.
     mixto = tempfile.mkdtemp()
     fmix = os.path.join(mixto, "zzmix.md")
-    S.escribe_ficha(fmix, "zzmix", "dev", [], None)
+    S.escribe_ficha(fmix, "zzmix", "dev")
     import card as _c2
 
     afirma(
@@ -509,7 +519,9 @@ def maquinas_hostiles():
         "· an old cached Claude plugin is updated through Claude's own CLI",
         llamadas
         and llamadas[0][:4] == ["claude", "plugin", "update", "city@agents-city"]
-        and "0.3.0-beta.21" in salida.getvalue(),
+        # The version comes from package.json, not from a literal here: a
+        # release must never mean editing an assertion in a test.
+        and version_del_paquete() in salida.getvalue(),
         f"calls={llamadas!r} output={salida.getvalue()!r}",
     )
 
@@ -673,7 +685,7 @@ def puesto_completo():
         "by": "this quarter",
     }
     ficha = os.path.join(casa, "ana.md")
-    S.escribe_ficha(ficha, "ana", "cpto", ["api"], meta)
+    S.escribe_ficha(ficha, "ana", "cpto", roster(("api",)), meta)
     texto = open(ficha).read()
     afirma("· a card with a goal says so in its frontmatter", "goals_defined: true" in texto)
     vuelta = card.objetivo(texto, "ana")
@@ -683,7 +695,7 @@ def puesto_completo():
     # A goal with no command must come back as no command, not as the prose that
     # stands in for one on the page.
     sin = dict(meta, command="")
-    S.escribe_ficha(ficha, "ana", "cpto", ["api"], sin)
+    S.escribe_ficha(ficha, "ana", "cpto", roster(("api",)), sin)
     afirma(
         '· "manual" is shown to a reader but is not read back as a command',
         card.objetivo(open(ficha).read(), "ana")["command"] == "",
@@ -691,7 +703,7 @@ def puesto_completo():
     )
 
     # No goal at all.
-    S.escribe_ficha(ficha, "ana", "cpto", ["api"], None)
+    S.escribe_ficha(ficha, "ana", "cpto", roster(("api",)), None)
     texto = open(ficha).read()
     afirma("· no goal says goals_defined: false", "goals_defined: false" in texto)
     comprueba("· and reads back as no goal", card.objetivo(texto, "ana"), None)
@@ -888,7 +900,7 @@ import importlib.machinery as m, importlib.util as u
 s = u.spec_from_loader('seat', m.SourceFileLoader('seat', {seat_aislado!r}))
 mod = u.module_from_spec(s); s.loader.exec_module(mod)
 ficha = {os.path.join(jaula, "datos", "ana.md")!r}
-mod.escribe_ficha(ficha, 'ana', 'cpto', [], None)
+mod.escribe_ficha(ficha, 'ana', 'cpto')
 print(open(ficha).read())
 """)
     os.makedirs(os.path.join(jaula, "datos"), exist_ok=True)
@@ -1150,11 +1162,7 @@ def arranque_escalonado():
         os.makedirs(d)
     ficha = os.path.join(datos, "ana.md")
     S.escribe_ficha(
-        ficha,
-        "ana",
-        "dev",
-        ["api", "docs"],
-        repo_roles={"api": "data-engineer", "docs": "seo"},
+        ficha, "ana", "dev", roster(("api", "code", "data-engineer"), ("docs", "code", "seo"))
     )
     card.pon_campo(ficha, "runs.docs", "codex --yolo")
 
@@ -1299,11 +1307,25 @@ def arranque_escalonado():
         and "adapter.js" not in docs,
         docs[:300],
     )
-    afirma(
-        "· Codex avoids an outer seatbelt so its MCPs can use one native sandbox",
-        "sandbox-exec" not in docs and "CITY_OUTER_CAGE=1" not in docs,
-        docs[:500],
-    )
+    # The Codex exemption is a SEATBELT constraint, not a fact about Codex: the
+    # macOS kernel refuses a nested sandbox_apply, and bubblewrap does not. So
+    # the contract differs by kernel, and this suite decodes a REAL launcher —
+    # asserting the macOS shape everywhere is how a Linux Codex window ended up
+    # able to read ~/.ssh while every other window in the city had it sealed.
+    if sys.platform == "darwin":
+        afirma(
+            "· on macOS Codex avoids the outer seatbelt so its MCPs keep one native sandbox",
+            "sandbox-exec" not in docs and "CITY_OUTER_CAGE=1" not in docs,
+            docs[:500],
+        )
+    else:
+        import cage as _cage
+
+        afirma(
+            "· off macOS Codex is caged like every other runtime, when a cage exists",
+            ("bwrap" in docs) == _cage.disponible(),
+            f"disponible={_cage.disponible()} :: {docs[:400]}",
+        )
     afirma(
         "· and it does not consume a turn either, so no gap is wasted",
         "sleep 9" not in " ".join(lineas),
@@ -1369,11 +1391,209 @@ def arranque_escalonado():
     shutil.rmtree(casa)
 
 
+# ══ the roster: a city is its agents, asked for one at a time ══════════════
+def _mundo_de_prueba():
+    """A disk with two repos, a folder of documents and one installable skill."""
+    base = tempfile.mkdtemp(prefix="agents-city-roster-")
+    datos = os.path.join(base, "city")
+    os.makedirs(datos)
+    for nombre in ("api", "web", "handbook"):
+        os.makedirs(os.path.join(base, nombre))
+    skill = os.path.join(base, "triage-skill")
+    os.makedirs(skill)
+    with open(os.path.join(skill, "SKILL.md"), "w") as f:
+        f.write("---\nname: triage\n---\nhow triage is done here\n")
+    catalogo = {
+        "filas": [("api", os.path.join(base, "api"), "", ""),
+                  ("web", os.path.join(base, "web"), "", "")],
+        "rutas": {"api": os.path.join(base, "api"), "web": os.path.join(base, "web")},
+        "dueno": "",
+        "mios": set(),
+    }
+    return base, datos, catalogo, skill
+
+
+def _guion(unas, pides, elige=()):
+    """Script the three widgets the roster asks through."""
+    it_una, it_pide = iter(unas), iter(pides)
+    return {
+        "una": lambda *a, **k: next(it_una),
+        "pide": lambda *a, **k: next(it_pide),
+        "elige": lambda *a, **k: list(elige),
+        "pantalla": lambda *a, **k: True,
+    }
+
+
+def plantilla_de_agentes():
+    print("  the roster: one agent at a time, each asked for in full")
+    base, datos, catalogo, skill = _mundo_de_prueba()
+    docs = os.path.join(base, "handbook")
+    try:
+        # One agent that answers for TWO repos AND a folder of documents — the
+        # shape the old "tick your folders" step could not express at all.
+        guion = _guion(
+            unas=["knowledge", "triage", "claude", "fin"],
+            pides=["urgencias", docs, "", "haiku", "low", skill, ""],
+            elige=["api", "web"],
+        )
+        with finge(ui, **guion), finge(S, catalogo_de_repos=lambda u: catalogo):
+            roster = S.pregunta_agentes("ana", "healthcare", datos)
+        uno = roster[0] if roster else {}
+        afirma(
+            "· one agent can mount several repos and a document folder at once",
+            len(roster) == 1 and sorted(os.path.basename(m) for m in uno["mounts"])
+            == ["api", "handbook", "web"],
+            str(uno.get("mounts")),
+        )
+        comprueba("· its kind is asked, not assumed to be code", uno.get("clase"), "knowledge")
+        comprueba("· its role is its own, not the seat's", uno.get("rol"), "triage")
+        comprueba(
+            "· its model and effort are asked on the agent itself",
+            {k: v for k, v in uno["motor"].items() if v},
+            {"model.urgencias": "haiku", "effort.urgencias": "low"},
+        )
+        comprueba("· and the skills it starts with are installed there", uno["skills"],
+                  ["triage-skill"])
+        instalada = os.path.join(
+            S.workspace.workspace_de(datos, "urgencias"), ".claude", "skills", "triage-skill"
+        )
+        afirma("· the skill really lands in that agent's own home",
+               os.path.isfile(os.path.join(instalada, "SKILL.md")), instalada)
+
+        # The loop is the point: it keeps offering another until you end it.
+        guion = _guion(
+            unas=["code", "dev", "claude", "otro", "knowledge", "blank", "claude", "fin"],
+            pides=["nova", "", "", "", "prensa", docs, "", "", ""],
+            elige=[],
+        )
+        with finge(ui, **guion), finge(S, catalogo_de_repos=lambda u: catalogo):
+            dos = S.pregunta_agentes("ana", "software", datos)
+        comprueba("· 'add another agent' keeps asking until the city is complete",
+                  [a["nombre"] for a in dos], ["nova", "prensa"])
+
+        # An empty city is a real answer: a seat that reaches others over roads.
+        with finge(ui, **_guion(unas=[], pides=[], elige=[])), finge(
+            ui, pantalla=lambda *a, **k: False
+        ):
+            vacio = S.pregunta_agentes("ana", "software", datos)
+        comprueba("· a city with no agents is a valid answer, not a dead end", vacio, [])
+    finally:
+        shutil.rmtree(base, ignore_errors=True)
+
+
+def ficha_de_agentes():
+    print("  the roster on the card, and on disk")
+    base, datos, catalogo, _ = _mundo_de_prueba()
+    ficha = os.path.join(datos, "ana.md")
+    try:
+        mio = [
+            {"nombre": "urgencias", "slug": "urgencias", "clase": "knowledge", "rol": "triage",
+             "mounts": [os.path.join(base, "handbook"), os.path.join(base, "api")],
+             "motor": {"runs.urgencias": "", "model.urgencias": "haiku",
+                       "effort.urgencias": "low"},
+             "skills": []},
+        ]
+        S.escribe_ficha(ficha, "ana", "cpto", mio, None, "city")
+        texto = open(ficha, encoding="utf-8").read()
+        afirma(
+            "· a new card is written agents-first, with no repos: list at all",
+            "agents: [urgencias]" in texto
+            and "kind.urgencias: knowledge" in texto
+            and "role.urgencias: triage" in texto
+            and "mounts.urgencias: [" in texto
+            and "repos:" not in texto,
+            texto.split("---")[1],
+        )
+        comprueba(
+            "· every engine answer becomes the card key the launcher resolves",
+            S.claves_de_agentes(mio)["model.urgencias"],
+            "haiku",
+        )
+        S.materializa_agentes(datos, ficha)
+        enlaces = [e for e, _ in S.workspace.mounts_en_disco(datos, "urgencias")]
+        comprueba("· and every mount is a real symlink in that agent's workspace",
+                  sorted(enlaces), ["api", "handbook"])
+
+        # The upgrade path: a legacy repos: card re-enters the roster as the
+        # agents it always was, so re-running the wizard adds instead of losing.
+        vieja = os.path.join(datos, "leg.md")
+        with open(vieja, "w", encoding="utf-8") as f:
+            f.write("---\nuser: leg\nname: leg\nrole: cpto\nagent: leg/city\n"
+                    "repos: [api, web]\nrole.api: dev\ngoals_defined: false\n---\n")
+        previo = S.agentes_de_ficha(vieja, datos)
+        afirma(
+            "· a legacy repos: card is read back as the agents it always was",
+            [a["nombre"] for a in previo] == ["api", "web"]
+            and previo[0]["clase"] == "code"
+            and previo[0]["rol"] == "dev",
+            str(previo),
+        )
+    finally:
+        shutil.rmtree(base, ignore_errors=True)
+
+
+def agentes_no_felices():
+    print("  the roster's unhappy paths")
+    base, datos, catalogo, _ = _mundo_de_prueba()
+    try:
+        # Two agents that slug to one identity would silently share a window,
+        # a workspace and a bus actor. The name question refuses it up front.
+        vistos = []
+
+        def pide_nombre(pregunta, defecto="", validar=None, ayuda=""):
+            if validar and "name" in pregunta:
+                vistos.append(validar("urgencias"))
+                return "otra"
+            return ""
+
+        # With one agent already there, the FIRST question is the add-another
+        # menu — the roster loop's own gate, before any question about a new one.
+        guion = _guion(unas=["otro", "knowledge", "blank", "claude", "fin"], pides=[])
+        guion["pide"] = pide_nombre
+        with finge(ui, **guion), finge(S, catalogo_de_repos=lambda u: catalogo):
+            S.pregunta_agentes(
+                "ana", "software", datos,
+                [{"nombre": "urgencias", "slug": "urgencias", "clase": "code", "rol": "blank",
+                  "mounts": [], "motor": {}, "skills": []}],
+            )
+        afirma("· a second agent cannot take an existing agent's identity",
+               vistos and "already an agent" in vistos[0], str(vistos))
+
+        # A folder that is not there is a retry, never a mount pointing nowhere.
+        avisos = []
+        respuestas = iter(["/nope/nothing/here", ""])
+        with finge(ui, pide=lambda *a, **k: next(respuestas),
+                   elige=lambda *a, **k: [], una=lambda *a, **k: "claude"):
+            montajes = S.pregunta_montajes("nova", {"filas": [], "rutas": {}, "dueno": "",
+                                                    "mios": set()})
+        comprueba("· a folder that does not exist is refused, not mounted", montajes, [])
+        del avisos
+
+        # Skills are the Claude runtime's format; offering them for an engine
+        # that ignores them would be selling something that does nothing.
+        with finge(ui, pide=lambda *a, **k: "/should/never/be/asked"):
+            comprueba(
+                "· an agent on another engine is not offered skills it would ignore",
+                S.pregunta_skills_de_agente(datos, "nova", "nova", "codex --full-auto"),
+                [],
+            )
+    finally:
+        shutil.rmtree(base, ignore_errors=True)
+
+
+def version_del_paquete():
+    with open(os.path.join(RAIZ, "package.json"), encoding="utf-8") as f:
+        return json.load(f)["version"]
+
+
 def main():
     print()
     camino_feliz()
     dos_puertas()
     puesto_completo()
+    plantilla_de_agentes()
+    ficha_de_agentes()
+    agentes_no_felices()
     motores_del_puesto()
     arranque_escalonado()
     caminos_infelices()