agents-city 0.3.0-beta.21

package/bin/test-crecimiento.py

@@ -0,0 +1,164 @@
+#!/usr/bin/env python3
+"""Polymorphic growth: a house grows by what its agent actually does.
+
+Under a throwaway data dir with a fixed clock (CITY_GROWTH_NOW). The point of
+the suite: a knowledge agent with zero git grows from its documents, a
+coordinator from its decisions, and a code agent uses an injected PR counter —
+so nobody is stuck at an empty lot for lacking a repo.
+"""
+
+import contextlib
+import os
+import shutil
+import sys
+import tempfile
+
+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 crecimiento as cr  # noqa: E402
+import workspace as ws  # noqa: E402
+from testlib import afirma, comprueba, resumen  # noqa: E402
+
+
+@contextlib.contextmanager
+def _reloj_fijo(epoch="1000000000"):
+    """Pin CITY_GROWTH_NOW, restoring any prior value rather than clobbering it."""
+    previo = os.environ.get("CITY_GROWTH_NOW")
+    os.environ["CITY_GROWTH_NOW"] = epoch
+    try:
+        yield
+    finally:
+        if previo is None:
+            os.environ.pop("CITY_GROWTH_NOW", None)
+        else:
+            os.environ["CITY_GROWTH_NOW"] = previo
+
+
+def _agente(nombre, clase, data, mounts=()):
+    return ws.Agente(nombre, nombre, "blank", "claude", clase,
+                     ws.workspace_de(data, nombre), list(mounts), legacy=False)
+
+
+def knowledge_crece_sin_git():
+    base = tempfile.mkdtemp(prefix="agents-city-grow-")
+    try:
+        with _reloj_fijo():
+            docs = os.path.join(base, "handbook")
+            os.makedirs(docs)
+            for n in ("a.md", "b.txt", "c.pdf", "ignore.py"):
+                with open(os.path.join(docs, n), "w") as f:
+                    f.write("x")
+            os.utime(os.path.join(docs, "a.md"), (1000000000 - 100, 1000000000 - 100))  # recent
+            os.utime(os.path.join(docs, "b.txt"), (1, 1))  # old
+            ws.crea_workspace(base, "writer")
+            ws.monta(base, "writer", docs)
+            a = _agente("writer", "knowledge", base)
+            r = cr.crece(a, base)
+            comprueba("floors count the documents, not the code files", r["floors"], 3)
+            comprueba("the signal names documents", r["signal"], "documents")
+            afirma("recent edits count as activity", r["activity30"] >= 1)
+    finally:
+        shutil.rmtree(base, ignore_errors=True)
+
+
+def knowledge_suma_workspace_y_mounts():
+    # Mounting a folder must ADD to the house, never replace the workspace:
+    # the `or`-fallback once made an agent's own documents vanish the moment
+    # it mounted anything — an empty mount shrank the house to zero.
+    base = tempfile.mkdtemp(prefix="agents-city-grow-")
+    try:
+        with _reloj_fijo():
+            ws.crea_workspace(base, "writer")
+            taller = ws.workspace_de(base, "writer")
+            for n in ("propio.md", "notas.txt"):
+                with open(os.path.join(taller, n), "w") as f:
+                    f.write("x")
+            a = _agente("writer", "knowledge", base)
+            antes = cr.crece(a, base)["floors"]
+            vacio = os.path.join(base, "vacio")
+            os.makedirs(vacio)
+            ws.monta(base, "writer", vacio)
+            r = cr.crece(a, base)
+            comprueba("an empty mount never shrinks the house", r["floors"], antes)
+            lleno = os.path.join(base, "docs")
+            os.makedirs(lleno)
+            with open(os.path.join(lleno, "extra.md"), "w") as f:
+                f.write("x")
+            ws.monta(base, "writer", lleno)
+            comprueba("a mounted document adds to the workspace's own",
+                      cr.crece(a, base)["floors"], antes + 1)
+    finally:
+        shutil.rmtree(base, ignore_errors=True)
+
+
+def _pon_deliberacion(base, ident, updated_at):
+    # The real store shape: deliberations/<id>/state.json, schema-tagged.
+    import json
+    carpeta = os.path.join(base, "deliberations", ident)
+    os.makedirs(carpeta)
+    estado = {"schema": "agents-city/deliberation@1", "status": "decided",
+              "brief": {"question": "q", "participants": []},
+              "decisions": [{"outcome": "go"}], "updatedAt": updated_at}
+    with open(os.path.join(carpeta, "state.json"), "w") as f:
+        json.dump(estado, f)
+
+
+def coordinator_crece_por_decisiones():
+    # The id must match deliberations.ID_RE: delib_<ts>_<hex>.
+    base = tempfile.mkdtemp(prefix="agents-city-grow-")
+    try:
+        with _reloj_fijo():
+            _pon_deliberacion(base, "delib_20260101010101_aaaaaaaa", "2001-09-09T01:00:00+00:00")
+            _pon_deliberacion(base, "delib_20260101010102_bbbbbbbb", "2001-09-09T01:00:00+00:00")
+            a = _agente("chair", "coordinator", base)
+            r = cr.crece(a, base)
+            comprueba("real deliberation directories become floors (not always 0)",
+                      r["floors"], 2)
+            comprueba("the signal names decisions", r["signal"], "decisions")
+    finally:
+        shutil.rmtree(base, ignore_errors=True)
+
+
+def code_usa_contador_inyectado():
+    base = tempfile.mkdtemp(prefix="agents-city-grow-")
+    try:
+        a = _agente("nova", "code", base)
+        comprueba("without a git counter a code house is empty, not crashed",
+                  cr.crece(a, base)["floors"], 0)
+        r = cr.crece(a, base, contador_git=lambda ag, d: (7, 3, 5))
+        comprueba("with the injected counter, floors are merged PRs", r["floors"], 7)
+        comprueba("bricks are commits", r["bricks"], 3)
+        comprueba("the signal names pull requests", r["signal"], "pull-requests")
+    finally:
+        shutil.rmtree(base, ignore_errors=True)
+
+
+def forma_uniforme():
+    base = tempfile.mkdtemp(prefix="agents-city-grow-")
+    try:
+        for clase in ("code", "knowledge", "coordinator"):
+            r = cr.crece(_agente("x", clase, base), base)
+            afirma(f"{clase} returns the uniform shape",
+                   set(r) == {"floors", "bricks", "activity30", "signal"})
+    finally:
+        shutil.rmtree(base, ignore_errors=True)
+
+
+def fecha_naive_es_utc():
+    # A naive timestamp must be read as UTC, not local, or recency drifts by the
+    # machine's offset. epoch 1e9 == 2001-09-09T01:46:40Z; a naive stamp one
+    # minute earlier is recent regardless of the runner's timezone.
+    comprueba("a naive ISO timestamp is parsed as UTC",
+              round(cr._epoch("2001-09-09T01:45:40")), 999999940)
+
+
+knowledge_crece_sin_git()
+knowledge_suma_workspace_y_mounts()
+coordinator_crece_por_decisiones()
+code_usa_contador_inyectado()
+forma_uniforme()
+fecha_naive_es_utc()
+sys.exit(resumen("crecimiento"))

package/bin/test-demo.py

@@ -0,0 +1,308 @@
+#!/usr/bin/env python3
+"""The account-free product demo, over the same real local WebSocket bus.
+
+The happy path runs Aurora's complete committee against an ephemeral city and
+asserts the durable spectator stream. Non-happy checks prove the script refuses
+an invalid roster, a missing Hall spectator and impossible timing without ever
+opening a browser, starting tmux or contacting a model provider.
+"""
+import glob
+import json
+import os
+import shutil
+import signal
+import subprocess
+import sys
+import tempfile
+import time
+
+
+AQUI = os.path.dirname(os.path.abspath(__file__))
+RAIZ = os.path.dirname(AQUI)
+SHOW = os.path.join(RAIZ, "demo", "show.py")
+FIXTURE = os.path.join(RAIZ, "demo", "city")
+sys.path.insert(0, AQUI)
+from testlib import afirma, comprueba, resumen  # noqa: E402
+
+
+def city(valid=True):
+    base = tempfile.mkdtemp(prefix="agents-city-demo-test-")
+    data = os.path.join(base, "city")
+    app = os.path.join(base, "app")
+    shutil.copytree(FIXTURE, data)
+    os.makedirs(app)
+    if not valid:
+        card_path = os.path.join(data, "ada.md")
+        card_text = open(card_path, encoding="utf-8").read()
+        card_text = card_text.replace(
+            "repos: [nova, store-service, telemetry-collector, engine-core, launcher]",
+            "repos: [nova, store-service]",
+        )
+        open(card_path, "w", encoding="utf-8").write(card_text)
+    env = dict(
+        os.environ,
+        AGENTS_CITY_HOME=app,
+        AGENTS_CITY_DATA=data,
+        AGENTS_CITY_USER="ada",
+        CITY_ADDRESS="ada/aurora-games",
+    )
+    for key in ("CITY_BUS_URL", "CITY_BUS_TOKEN", "CITY_DIR"):
+        env.pop(key, None)
+    return base, data, app, env
+
+
+def run(env, *args):
+    return subprocess.run(
+        [sys.executable, SHOW, *args],
+        capture_output=True,
+        text=True,
+        env=env,
+        timeout=25,
+    )
+
+
+def activities(app):
+    paths = glob.glob(os.path.join(app, ".runtime", "bus", "*", "activity.jsonl"))
+    if not paths:
+        return []
+    return [json.loads(line) for line in open(paths[0], encoding="utf-8") if line.strip()]
+
+
+def stop_hubs(app):
+    for path in glob.glob(os.path.join(app, ".runtime", "bus", "*", "endpoint.json")):
+        try:
+            pid = int(json.load(open(path, encoding="utf-8"))["pid"])
+            os.kill(pid, signal.SIGTERM)
+        except (OSError, KeyError, TypeError, ValueError, json.JSONDecodeError):
+            pass
+    time.sleep(0.1)
+
+
+def ordered(actual, expected):
+    cursor = 0
+    for item in actual:
+        if cursor < len(expected) and item == expected[cursor]:
+            cursor += 1
+    return cursor == len(expected)
+
+
+def main():
+    global FIXTURE
+    print("\n  full Aurora demo on the real local bus")
+    roots = []
+    try:
+        base, data, app, env = city()
+        roots.append((base, app))
+        result = run(env, "--no-wait", "--step", "0")
+        events = activities(app)
+        kinds = [event.get("kind") for event in events]
+        afirma(
+            "· happy: the guided demo completes without a provider account",
+            result.returncode == 0 and "Guided committee complete" in result.stdout,
+            result.stderr,
+        )
+        comprueba("· it produces the complete visible conversation", len(events), 22)
+        afirma(
+            "· every item crossed the authenticated activity protocol",
+            all(event.get("protocol") == "agents-city-activity/1" for event in events),
+        )
+        afirma(
+            "· the first blind round reveals three repo agents only after its barrier",
+            kinds.count("committee.position.submitted") == 3
+            and kinds.count("committee.position.revealed") == 3
+            and kinds.index("committee.positions.revealed")
+            < kinds.index("committee.position.revealed"),
+            str(kinds),
+        )
+        afirma(
+            "· the game speakers are the chair and real repo actors, never fake people",
+            {event["actor"] for event in events}
+            == {"seat", "nova", "store-service", "telemetry-collector"},
+            str(sorted({event["actor"] for event in events})),
+        )
+        afirma(
+            "· two specialists request permission, receive it and speak to the committee",
+            kinds.count("committee.floor.requested") == 2
+            and kinds.count("committee.floor.granted") == 2
+            and kinds.count("committee.floor.spoke") == 2
+            and all(
+                event.get("target") == "committee"
+                for event in events
+                if event.get("kind") == "committee.floor.spoke"
+            ),
+            str(kinds),
+        )
+        afirma(
+            "· decision, independent verification and closure stay ordered",
+            ordered(
+                kinds,
+                [
+                    "committee.opened",
+                    "committee.positions.revealed",
+                    "committee.synthesis.published",
+                    "committee.floor.spoke",
+                    "committee.decision.recorded",
+                    "committee.verification.pass",
+                    "committee.closed",
+                ],
+            ),
+            str(kinds),
+        )
+        seqs = [event["seq"] for event in events]
+        afirma("· its WebSocket ledger is monotonic and duplicate-free", seqs == list(range(1, 23)))
+        # The story deliberately walks the failure lane: a verification that
+        # fails, a replan, and only then a verified close.
+        afirma(
+            "· the first plan fails verification and the chair replans before closing",
+            kinds.count("committee.verification.fail") == 1
+            and kinds.count("committee.replanned") == 1
+            and kinds.index("committee.verification.fail")
+            < kinds.index("committee.replanned")
+            < kinds.index("committee.verification.pass"),
+            str(kinds),
+        )
+        acts = glob.glob(os.path.join(data, "deliberations", "*", "ACT.md"))
+        afirma(
+            "· the same demo leaves a human-readable verified act",
+            len(acts) == 1
+            and "Partidas restauradas" in open(acts[0], encoding="utf-8").read()
+            and "## Verification" in open(acts[0], encoding="utf-8").read(),
+            str(acts),
+        )
+
+        card = open(os.path.join(FIXTURE, "ada.md"), encoding="utf-8").read()
+        afirma(
+            "· Aurora demonstrates role-per-repo and mixed runtime metadata",
+            all(
+                token in card
+                for token in (
+                    "role.nova: po",
+                    "role.store-service: security",
+                    "runs.nova: claude",
+                    "runs.store-service: codex",
+                    "runs.telemetry-collector: opencode",
+                    "runs.engine-core: kimi",
+                )
+            ),
+        )
+
+        # Every domain's story plays on its own city, with its own cast. This
+        # is also the regression net for agents-first on the bus: the clinic
+        # and the firm declare `agents:` (knowledge/coordinator), not `repos:`,
+        # so these two runs fail loudly if the roster ever regresses to
+        # repos-only.
+        fixture_original = FIXTURE
+        for fixture, historia, reparto in (
+            ("clinica", "medicina", {"seat", "urgencias", "laboratorio", "farmacia"}),
+            ("despacho", "legal", {"seat", "contratos", "litigios", "archivo"}),
+        ):
+            FIXTURE = os.path.join(RAIZ, "demo", fixture)
+            dom_base, _, dom_app, dom_env = city()
+            roots.append((dom_base, dom_app))
+            dom_result = run(dom_env, "--no-wait", "--step", "0", "--story", historia)
+            dom_events = activities(dom_app)
+            dom_kinds = [event.get("kind") for event in dom_events]
+            afirma(
+                f"· the {historia} story plays on its own city with agents-first actors",
+                dom_result.returncode == 0
+                and len(dom_events) == 22
+                and {event["actor"] for event in dom_events} == reparto
+                and dom_kinds.count("committee.verification.fail") == 1
+                and dom_kinds.count("committee.replanned") == 1,
+                dom_result.stderr + str(sorted({event["actor"] for event in dom_events})),
+            )
+        FIXTURE = fixture_original
+
+        bad_base, _, bad_app, bad_env = city(valid=False)
+        roots.append((bad_base, bad_app))
+        rejected = run(bad_env, "--no-wait", "--step", "0")
+        rejected_events = activities(bad_app)
+        afirma(
+            "· non-happy: a story cannot impersonate an agent absent from the roster",
+            rejected.returncode != 0
+            and "not a repo support agent" in rejected.stderr
+            and [event.get("kind") for event in rejected_events]
+            == ["committee.command.rejected"],
+            rejected.stderr + json.dumps(rejected_events),
+        )
+
+        wait_base, _, wait_app, wait_env = city()
+        roots.append((wait_base, wait_app))
+        no_hall = run(wait_env, "--wait-timeout", "0", "--step", "0")
+        afirma(
+            "· non-happy: autoplay refuses to run before a Hall spectator connects",
+            no_hall.returncode != 0
+            and "Hall did not connect" in no_hall.stderr
+            and not activities(wait_app),
+            no_hall.stderr,
+        )
+
+        timing = run(env, "--step", "-1")
+        afirma(
+            "· non-happy: an impossible negative turn delay is rejected at the CLI",
+            timing.returncode != 0 and "zero or greater" in timing.stderr,
+            timing.stderr,
+        )
+
+        invented = run(env, "--no-wait", "--step", "0", "--story", "cocina")
+        afirma(
+            "· non-happy: a story that does not exist is rejected before touching the bus",
+            invented.returncode != 0 and "invalid choice" in invented.stderr,
+            invented.stderr,
+        )
+
+        # Two demos may seed at once (one per domain): the seeder must never
+        # write a fixed path two runs would overwrite mid-flight.
+        semilla = open(os.path.join(RAIZ, "city", "scripts", "seed.py"), encoding="utf-8").read()
+        afirma(
+            "· concurrent demos cannot clobber each other's seed SQL",
+            "mkstemp" in semilla and "/tmp/agents-city-seed.sql" not in semilla,
+        )
+
+        help_result = subprocess.run(
+            [os.path.join(RAIZ, "bin", "demo"), "--help"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        afirma(
+            "· the public demo explains Hall, WebSockets, bubbles and account-free use",
+            help_result.returncode == 0
+            and all(
+                token in help_result.stdout
+                for token in ("Town Hall", "WebSocket", "speech bubbles", "No Claude/Codex account")
+            ),
+            help_result.stdout + help_result.stderr,
+        )
+
+        launcher = open(os.path.join(RAIZ, "bin", "demo"), encoding="utf-8").read()
+        worker = open(
+            os.path.join(RAIZ, "city", "worker", "src", "index.ts"), encoding="utf-8"
+        ).read()
+        hall = open(os.path.join(RAIZ, "bin", "serve.py"), encoding="utf-8").read()
+        afirma(
+            "· the disposable launcher owns and cleans only its temporary runtime",
+            "mktemp -d" in launcher
+            and "trap cleanup EXIT" in launcher
+            and 'AGENTS_CITY_HOME=$DEMO_APP' in launcher
+            and 'if [ "$ABRIR" -eq 1 ]; then' in launcher
+            and "HALL_ARGS" not in launcher
+            and "~/.agents-city/state/demo" not in launcher,
+        )
+        afirma(
+            "· Hall discovers the matching city map instead of the first open map port",
+            "/api/identity" in worker
+            and "CITY_ID?: string" in worker
+            and "identidad == esperada" in hall
+            and "range(8787, 8797)" in hall,
+        )
+    finally:
+        for base, app in roots:
+            stop_hubs(app)
+            shutil.rmtree(base, ignore_errors=True)
+
+    return resumen("demo")
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/bin/test-doctor.py

@@ -0,0 +1,106 @@
+#!/usr/bin/env python3
+"""doctor: an old config is detected, explained, backed up, rewritten — once.
+
+Runs against a temp file. The load-bearing cases: migrations are idempotent
+(re-running changes nothing), a dry-run never writes, a real fix leaves a
+backup, and several migrations converge in one pass.
+"""
+
+import json
+import os
+import shutil
+import sys
+import tempfile
+
+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 doctor  # noqa: E402
+from testlib import afirma, comprueba, resumen  # noqa: E402
+
+
+def diagnostico():
+    viejo = {"busUrl": "https://x", "gateway": {}}
+    pendientes = [m.id for m in doctor.diagnostica(viejo)]
+    afirma("the renamed key is detected", "bus-url-renamed-to-roads-url" in pendientes)
+    afirma("the missing bind default is detected",
+           "gateway-bind-defaults-to-loopback" in pendientes)
+    nuevo, _ = doctor.cura(viejo)
+    afirma("busUrl becomes roadsUrl", "roadsUrl" in nuevo and "busUrl" not in nuevo)
+    comprueba("the value is carried over", nuevo["roadsUrl"], "https://x")
+    comprueba("the gateway bind is pinned to loopback", nuevo["gateway"]["bind"], "loopback")
+    afirma("the cage default is recorded on", nuevo["security"]["cage"] is True)
+
+
+def configs_malformadas():
+    # doctor must not crash on the malformed config it exists to repair.
+    for malo in ({"security": None}, {"security": "on"}, {"security": ["x"]}, {"security": 3}):
+        try:
+            nuevo, _ = doctor.cura(malo)
+            afirma(f"a non-dict security ({malo['security']!r}) does not crash cura", True)
+            afirma("and such a config is left untouched (no bogus migration)",
+                   nuevo == malo)
+        except (TypeError, ValueError):
+            afirma(f"a non-dict security ({malo['security']!r}) does not crash cura", False)
+
+
+def idempotencia():
+    canonico = {"roadsUrl": "https://x", "gateway": {"bind": "loopback"},
+                "security": {"cage": True}}
+    comprueba("a canonical config needs no migration", doctor.diagnostica(canonico), [])
+    _, aplicadas = doctor.cura(canonico)
+    comprueba("curing a canonical config changes nothing", aplicadas, [])
+    curado, _ = doctor.cura({"busUrl": "u"})
+    _, otra_vez = doctor.cura(curado)
+    comprueba("a second pass is a no-op (idempotent)", otra_vez, [])
+
+
+def fichero():
+    base = tempfile.mkdtemp(prefix="agents-city-doctor-")
+    try:
+        ruta = os.path.join(base, "openclaw.json")
+        with open(ruta, "w") as f:
+            json.dump({"busUrl": "https://x", "gateway": {}}, f)
+        seco = doctor.cura_fichero(ruta, "T1", dry_run=True)
+        afirma("a dry-run reports migrations", seco["migrations"])
+        afirma("a dry-run writes nothing", not seco["wrote"] and seco["backup"] is None)
+        antes = open(ruta).read()
+        afirma("the file is untouched after dry-run", json.loads(antes).get("busUrl") == "https://x")
+
+        rep = doctor.cura_fichero(ruta, "T1", dry_run=False)
+        afirma("a real fix wrote the file", rep["wrote"])
+        afirma("a backup was left", os.path.exists(rep["backup"]))
+        despues = json.load(open(ruta))
+        afirma("the rewritten file is canonical",
+               "roadsUrl" in despues and despues["gateway"]["bind"] == "loopback")
+        afirma("the backup preserved the original shape",
+               json.load(open(rep["backup"])).get("busUrl") == "https://x")
+
+        rep2 = doctor.cura_fichero(ruta, "T2", dry_run=False)
+        afirma("a canonical file needs no second rewrite", not rep2["wrote"])
+    finally:
+        shutil.rmtree(base, ignore_errors=True)
+
+
+def preserva_permisos():
+    base = tempfile.mkdtemp(prefix="agents-city-doctor-")
+    try:
+        ruta = os.path.join(base, "openclaw.json")
+        with open(ruta, "w") as f:
+            json.dump({"busUrl": "https://x", "gateway": {}}, f)
+        os.chmod(ruta, 0o600)
+        doctor.cura_fichero(ruta, "T1", dry_run=False)
+        modo = oct(os.stat(ruta).st_mode & 0o777)
+        comprueba("a 0600 config stays 0600 after a rewrite (never widened)", modo, "0o600")
+    finally:
+        shutil.rmtree(base, ignore_errors=True)
+
+
+diagnostico()
+configs_malformadas()
+idempotencia()
+fichero()
+preserva_permisos()
+sys.exit(resumen("doctor"))