agents-city 0.4.0 → 0.5.2

package/bin/serve.py

@@ -23,10 +23,13 @@ import re
 import secrets
 import shutil
 import signal
+import sqlite3
 import socketserver
+import stat
 import subprocess
 import sys
 import threading
+import time
 import urllib.parse
 import webbrowser
 
@@ -40,9 +43,12 @@ import domains  # noqa: E402
 import gh  # noqa: E402
 import parcels  # noqa: E402
 import units  # noqa: E402
+import busca  # noqa: E402  the disk scanner, and the one list of where work lives
 import cities  # noqa: E402
+import diario  # noqa: E402  what happened, written down
 import demos  # noqa: E402  the recorded demos the Hall plays back
 import roads  # noqa: E402
+import reception  # noqa: E402
 import capabilities  # noqa: E402
 import deliberations  # noqa: E402
 import avatar  # noqa: E402
@@ -187,6 +193,22 @@ def estado_seguro_agentes(datos):
         return []
 
 
+def resumen_recepcion_segura():
+    """A damaged optional inbox must not make the whole local Hall disappear."""
+    try:
+        return reception.resumen()
+    except (OSError, sqlite3.Error, reception.ReceptionError) as e:
+        return {
+            "pending": 0,
+            "pendingBytes": 0,
+            "routingMode": "manual",
+            "reviewPolicy": "every_message",
+            "routerProfile": None,
+            "autoAvailable": False,
+            "error": str(e),
+        }
+
+
 def olvida_skills():
     """Forget the discovery memo: a skill was installed or removed, and that
     changes the answer without touching the card."""
@@ -401,24 +423,6 @@ def historia_del_demo(datos):
     historia = lee_clave(os.path.join(datos, "city.yml"), "domain")
     return historia if historia in DEMO_STORIES else "software"
 
-# Where people actually keep their code. The curses wizard offered `~/code` and
-# nothing else, which is wrong on most machines and silently scans a folder that
-# is not there. Offer the ones that exist, most-repos first, and let them type.
-CANDIDATAS = [
-    "code",
-    "codigo",
-    "src",
-    "dev",
-    "devel",
-    "projects",
-    "proyectos",
-    "work",
-    "trabajo",
-    "repos",
-    "git",
-    "Developer",
-    "Documents",
-]
 
 
 def glob_fichas(datos):
@@ -521,33 +525,28 @@ def actividad_viva(datos):
         return {"online": False, "url": "", "city": "", "started_at": ""}
 
 
+def _resumen_cuerpo(cuerpo):
+    """On success, the shape rather than the content: which fields arrived and
+    how long each was. A log that repeats every goal somebody types is a log
+    they will not send anywhere."""
+    if not isinstance(cuerpo, dict):
+        return {}
+    return {k: (len(v) if isinstance(v, (str, list)) else v) for k, v in cuerpo.items()}
+
+
 def _que_es_git(ruta):
     """`repo`, `worktree`, or nothing. A label on a row, never a filter: the
     picker shows every folder and lets the person decide which one matters."""
-    marca = os.path.join(ruta, ".git")
-    if os.path.isdir(marca):
-        return "repo"
-    if os.path.isfile(marca):
-        return "worktree"
-    return ""
+    try:
+        # One stat, not an isdir followed by an isfile: a clone's `.git` is a
+        # directory and a linked worktree's is a file, and that is the whole
+        # question.
+        modo = os.stat(os.path.join(ruta, ".git")).st_mode
+    except OSError:
+        return ""
+    return "repo" if stat.S_ISDIR(modo) else "worktree"
 
 
-def carpetas_probables():
-    """Existing folders under $HOME that look like where the work lives."""
-    casa = os.path.expanduser("~")
-    fuera = []
-    for n in CANDIDATAS:
-        ruta = os.path.join(casa, n)
-        if not os.path.isdir(ruta):
-            continue
-        try:
-            hijos = [x for x in os.listdir(ruta) if not x.startswith(".")]
-            gits = sum(1 for x in hijos if os.path.isdir(os.path.join(ruta, x, ".git")))
-        except OSError:
-            continue
-        fuera.append({"ruta": ruta, "nombre": n, "items": len(hijos), "gits": gits})
-    fuera.sort(key=lambda c: (-c["gits"], -c["items"]))
-    return fuera
 
 
 def catalogo_roles(dominio):
@@ -615,7 +614,27 @@ class Manejador(http.server.BaseHTTPRequestHandler):
         if os.environ.get("CITY_SETUP_DEBUG"):
             sys.stderr.write("  %s\n" % (format % args))
 
+    #: What this handler last answered, so the request log can say so without
+    #: every endpoint having to report for itself.
+    _ultimo = None
+    _error = None
+
+    def apunta(self, q, tipo, **campos):
+        """One journal line, in the journal of the city the request acted on.
+
+        Not the selected one: a request carries `?city=`, and writing its line
+        into whichever city happened to be current put the record of what
+        happened to one city in another city's file. Which is worse than no
+        record, because it is a record that lies about where.
+        """
+        try:
+            diario.apunta(self.ciudad(q), tipo, **campos)
+        except Exception:  # noqa: BLE001  logging must not break the request
+            pass
+
     def responde(self, cuerpo, tipo="application/json", codigo=200):
+        self._ultimo = codigo
+        self._error = cuerpo.get("error") if isinstance(cuerpo, dict) else None
         if not isinstance(cuerpo, bytes):
             cuerpo = json.dumps(cuerpo).encode()
         self.send_response(codigo)
@@ -702,9 +721,11 @@ class Manejador(http.server.BaseHTTPRequestHandler):
         "/api/instrucciones": "g_instrucciones",
         "/api/live": "g_live",
         "/api/carpeta": "g_carpeta",
+        "/api/diario": "g_diario",
         "/api/demos": "g_demos",
         "/api/domains": "g_domains",
         "/api/roles": "g_roles",
+        "/api/reception": "g_reception",
     }
     POSTS = {
         "/api/ficha": "p_ficha",
@@ -716,7 +737,9 @@ class Manejador(http.server.BaseHTTPRequestHandler):
         "/api/ciudad-archiva": "p_archiva_ciudad",
         "/api/ciudad-reinicia": "p_reinicia_ciudad",
         "/api/roads": "p_roads",
+        "/api/reception": "p_reception",
         "/api/agente": "p_agente",
+        "/api/diario": "p_diario",
         "/api/agentes": "p_agentes",
         "/api/montaje": "p_montaje",
         "/api/motor": "p_motor",
@@ -769,9 +792,24 @@ class Manejador(http.server.BaseHTTPRequestHandler):
             cuerpo = json.loads(self.rfile.read(largo) or b"{}")
         except (ValueError, json.JSONDecodeError) as e:
             return self.responde({"error": f"unreadable body: {e}"}, codigo=400)
-        if ruta in self.POSTS:
-            return getattr(self, self.POSTS[ruta])(q, cuerpo)
-        return self.responde({"error": "no such thing"}, codigo=404)
+        if ruta not in self.POSTS:
+            self.apunta(q, "post", ruta=ruta, estado=404, error="no such thing")
+            return self.responde({"error": "no such thing"}, codigo=404)
+        # Every write is recorded before it happens and judged after, so a
+        # request that never came back says so too — a handler that hangs or
+        # dies leaves a line with no verdict, which is itself the finding.
+        empezado = time.monotonic()
+        self._ultimo = None
+        try:
+            salida = getattr(self, self.POSTS[ruta])(q, cuerpo)
+        except Exception as e:  # noqa: BLE001  the log is the point
+            self.apunta(q, "post", ruta=ruta, error=f"{type(e).__name__}: {e}",
+                        cuerpo=cuerpo, ms=int((time.monotonic() - empezado) * 1000))
+            raise
+        self.apunta(q, "post", ruta=ruta, estado=self._ultimo,
+                    cuerpo=cuerpo if self._ultimo != 200 else _resumen_cuerpo(cuerpo),
+                    error=self._error, ms=int((time.monotonic() - empezado) * 1000))
+        return salida
 
     def g_estado(self, q):
         datos = self.ciudad(q)
@@ -837,6 +875,7 @@ class Manejador(http.server.BaseHTTPRequestHandler):
                 # Registration is earned by writing to one, never by looking.
                 "ciudades": lista_con(datos),
                 "roads": roads.lee(datos),
+                "reception": resumen_recepcion_segura(),
                 "invitation": roads.invitacion(datos, owner),
                 "skills": habilidades,
                 "deliberations": deliberations.lista(datos),
@@ -855,6 +894,13 @@ class Manejador(http.server.BaseHTTPRequestHandler):
     def g_live(self, q):
         return self.responde(actividad_viva(self.ciudad(q)))
 
+    def g_reception(self, q):
+        """Owner-level remote quarantine; it is deliberately not city-scoped."""
+        try:
+            return self.responde(reception.estado(seat.quien_soy(), actual=self.ciudad(q)))
+        except (OSError, sqlite3.Error, reception.ReceptionError) as e:
+            return self.responde({"error": str(e)}, codigo=503)
+
     def g_demos(self, q):
         """The recorded demos, and one of them in full when asked by name.
 
@@ -864,18 +910,24 @@ class Manejador(http.server.BaseHTTPRequestHandler):
         the browser owning a second, drifting copy of the state machine.
         """
         cual = q.get("story", [""])[0]
-        catalogo = demos.catalogo()
         if not cual:
-            return self.responde({"demos": catalogo})
-        historia = next((d for d in catalogo if d["id"] == cual), None)
-        if not historia:
-            return self.responde({"error": "no such demo"}, codigo=404)
+            return self.responde({"demos": demos.catalogo()})
+        # One read of one file: the card is derived from the very events being
+        # served, rather than building the whole shelf to look one row up.
         eventos = demos.eventos(cual)
         if not eventos:
-            return self.responde(
-                {"error": "that demo has no recording; run demo/graba.py"}, codigo=409
-            )
-        return self.responde({**historia, "eventos": eventos})
+            return self.responde({"error": "no such demo"}, codigo=404)
+        return self.responde({**(demos.ficha(cual, eventos) or {}), "eventos": eventos})
+
+    def g_diario(self, q):
+        """The journal, for `doctor --log` and for anybody about to send it."""
+        try:
+            cuantas = max(1, min(2000, int(q.get("n", ["200"])[0])))
+        except ValueError:
+            cuantas = 200
+        return self.responde(
+            {"ruta": diario.ruta(self.ciudad(q)), "lineas": diario.lee(self.ciudad(q), cuantas)}
+        )
 
     def g_carpeta(self, q):
         """One folder, listed: what is in it, and what each thing is.
@@ -911,10 +963,6 @@ class Manejador(http.server.BaseHTTPRequestHandler):
                             "nombre": e.name,
                             "ruta": os.path.join(ruta, e.name),
                             "dir": es_dir,
-                            # What kind of place this is, said plainly rather
-                            # than used to filter anything out: a folder is
-                            # yours to pick whether or not it holds a .git.
-                            "git": _que_es_git(os.path.join(ruta, e.name)) if es_dir else "",
                             "enlace": e.is_symlink(),
                         }
                     )
@@ -923,40 +971,31 @@ class Manejador(http.server.BaseHTTPRequestHandler):
         # Folders first, then files, each alphabetical and case-insensitive —
         # the order every file picker has used for forty years.
         entradas.sort(key=lambda x: (not x["dir"], x["nombre"].lower()))
+        recortada = len(entradas) > 2000
+        entradas = entradas[:2000]
+        # Only now, and only for the rows that will be sent. Asking every entry
+        # in a twenty-thousand-item directory whether it holds a `.git` was
+        # eighteen thousand pairs of stat calls for rows nobody would see. What
+        # kind of place this is gets said plainly rather than used to filter
+        # anything out: a folder is yours to pick whether or not it holds one.
+        for e in entradas:
+            e["git"] = _que_es_git(e["ruta"]) if e["dir"] else ""
         casa = os.path.expanduser("~")
         arriba = os.path.dirname(ruta)
         return self.responde(
             {
                 "ruta": ruta,
                 "arriba": arriba if arriba != ruta else "",
-                "casa": casa,
                 "atajos": [
                     {"nombre": os.path.basename(c) or c, "ruta": c}
-                    for c in [casa] + [os.path.join(casa, n) for n in CANDIDATAS]
+                    for c in [casa] + [os.path.join(casa, n) for n in busca.CANDIDATAS]
                     if os.path.isdir(c)
                 ],
-                "entradas": entradas[:2000],
-                "recortada": len(entradas) > 2000,
+                "entradas": entradas,
+                "recortada": recortada,
             }
         )
 
-    def g_arranque(self, q):
-        plants = W.plantillas()
-        return self.responde(
-            {
-                "kinds": plants,
-                "destino": DESTINO,
-                "casa": os.path.expanduser("~"),
-                "carpetas": carpetas_probables(),
-                # Only whether the CLI is there. Whether it is logged in is the
-                # orgs endpoint's answer, and asking it here would make every
-                # page load wait on a network call.
-                "gh": bool(shutil.which("gh")),
-                "existe": os.path.isdir(DESTINO),
-                "paleta": [{"hex": c, "nombre": n} for c, n in W.PALETA],
-                "arquitectos": sorted(ARQUITECTOS),
-            }
-        )
 
     def g_roles(self, q):
         if q.get("scope", [""])[0] == "agent":
@@ -974,29 +1013,7 @@ class Manejador(http.server.BaseHTTPRequestHandler):
             }
         )
 
-    def g_orgs(self, q):
-        return self.responde({"orgs": W.orgs_de_gh()})
 
-    def g_repos(self, q):
-        org = q.get("org", [""])[0]
-        if org:
-            hallados = [
-                {"nombre": n, "detalle": d, "fecha": f, "ruta": ""}
-                for n, d, f in W.repos_de_org(org)
-            ]
-            return self.responde({"repos": hallados})
-        base = os.path.expanduser(q.get("ruta", [""])[0])
-        if not base or not os.path.isdir(base):
-            return self.responde({"repos": [], "error": f"{base or '(empty)'} is not a folder"})
-        # Two different third columns, and saying so beats guessing in the page:
-        # a git repo reports its last commit, any-folder reports what is inside.
-        if q.get("modo", ["git"])[0] == "git":
-            crudo = W.repos_del_disco(base)
-            repos = [{"nombre": n, "ruta": r, "detalle": "", "fecha": f} for n, r, f in crudo]
-        else:
-            crudo = W.carpetas_del_disco(base)
-            repos = [{"nombre": n, "ruta": r, "detalle": d, "fecha": ""} for n, r, d in crudo]
-        return self.responde({"repos": repos})
 
     def g_gente(self, q):
         org = q.get("org", [""])[0]
@@ -1242,6 +1259,51 @@ class Manejador(http.server.BaseHTTPRequestHandler):
             return self.responde({"error": str(e)}, codigo=400)
         return self.responde({"ok": True, "roads": roads.lee(origen)})
 
+    def p_reception(self, q, cuerpo):
+        """One human decision, committed before any city can consume the text."""
+        if cuerpo.get("action") == "configure":
+            try:
+                return self.responde(
+                    reception.configura(
+                        seat.quien_soy(),
+                        cuerpo.get("routing_mode"),
+                        cuerpo.get("rules"),
+                        self.ciudad(q),
+                    )
+                )
+            except reception.ReceptionError as e:
+                return self.responde({"error": str(e)}, codigo=400)
+            except (OSError, sqlite3.Error) as e:
+                return self.responde({"error": f"reception unavailable: {e}"}, codigo=503)
+        if cuerpo.get("action") == "send":
+            try:
+                return self.responde(
+                    reception.envia(cuerpo.get("connection_id"), cuerpo.get("text")),
+                    codigo=202,
+                )
+            except reception.ReceptionError as e:
+                return self.responde({"error": str(e)}, codigo=400)
+            except (OSError, sqlite3.Error) as e:
+                return self.responde({"error": f"reception unavailable: {e}"}, codigo=503)
+        destinos = cuerpo.get("destinations") or []
+        if not isinstance(destinos, list):
+            return self.responde({"error": "destinations must be a list"}, codigo=400)
+        try:
+            resultado = reception.decide(
+                seat.quien_soy(),
+                cuerpo.get("message_id"),
+                cuerpo.get("action"),
+                destinos,
+                cuerpo.get("reason"),
+                self.ciudad(q),
+            )
+        except reception.ReceptionError as e:
+            codigo = 409 if "already" in str(e) or "conflict" in str(e) else 400
+            return self.responde({"error": str(e)}, codigo=codigo)
+        except (OSError, sqlite3.Error) as e:
+            return self.responde({"error": f"reception unavailable: {e}"}, codigo=503)
+        return self.responde(resultado)
+
     def p_mapa(self, q, cuerpo):
         # Bake and serve the map, detached. First run builds the front end and
         # seeds the local D1, so the page polls /api/estado until it is up.
@@ -1290,7 +1352,12 @@ class Manejador(http.server.BaseHTTPRequestHandler):
     # nothing, never a shell fragment". `runtime` maps to `runs.` — the launcher's
     # own key — and the web deliberately cannot reach the terminal: fallback.
     CAMPOS_DE_AGENTE = {
-        "model": ("model", re.compile(r"[a-z0-9][a-z0-9.-]{0,63}"), "that is not a model alias"),
+        # A model name is whatever the CLI in play calls it: `opus`, but also
+        # `gpt-5.6-sol` and OpenCode's `anthropic/claude-sonnet-4`. Slash,
+        # underscore and colon are in; whitespace, quotes and every shell
+        # metacharacter stay out, because this value ends up on a command line.
+        "model": ("model", re.compile(r"[a-z0-9][a-z0-9./:_-]{0,63}"),
+                  "that is not a model name"),
         "effort": ("effort", frozenset(("low", "medium", "high", "xhigh", "max")),
                    "effort is low..max or empty"),
         "runtime": ("runs", frozenset(("claude",) + seat.OTROS_MOTORES),
@@ -1314,8 +1381,23 @@ class Manejador(http.server.BaseHTTPRequestHandler):
             return self.responde({"error": "this city has no owner card yet"}, codigo=409)
         nombre = " ".join(str(cuerpo.get("name") or "").split())
         slug = card.ventana(nombre)
-        if not nombre or not card.ventana_valida(slug):
+        # `card.ventana` falls back to the word `repo` when nothing in the name
+        # survives slugging — which is right for a repository whose folder is
+        # punctuation, and wrong here: a house called `///` would be created
+        # with the window `repo`, and the name a person reads would stop being
+        # the thing the city addresses. A name has to carry a letter or a digit.
+        legible = bool(re.search(r"[a-z0-9]", nombre.lower()))
+        if not nombre or not card.ventana_valida(slug) or not legible:
             return self.responde({"error": "an agent needs a plain name"}, codigo=400)
+        # A window slug is cut at 80 characters, so a longer name would be
+        # stored in full on the card and addressed by a truncated one — the
+        # name a person reads and the window it opens quietly stop being the
+        # same thing. Refuse rather than silently rename.
+        if len(nombre) > 80:
+            return self.responde(
+                {"error": "an agent's name has to fit in a window title: 80 characters"},
+                codigo=400,
+            )
         clase = str(cuerpo.get("kind") or workspace.CLASE_DEFECTO).strip().lower()
         if clase not in workspace.CLASES:
             return self.responde(
@@ -1410,6 +1492,24 @@ class Manejador(http.server.BaseHTTPRequestHandler):
             }
         )
 
+    def p_diario(self, q, cuerpo):
+        """The browser's half of the log.
+
+        Half of what goes wrong here goes wrong in the page — a handler that
+        threw, a fetch that never came back, a button that did nothing. A log
+        that stops at the network boundary tells half the story, so the page
+        writes into the same file the server does, and one file answers "what
+        happened" instead of two that have to be lined up by hand.
+        """
+        diario.apunta(
+            self.ciudad(q),
+            "browser",
+            que=str(cuerpo.get("que") or "")[:120],
+            detalle=cuerpo.get("detalle"),
+            donde=str(cuerpo.get("donde") or "")[:200],
+        )
+        return self.responde({"ok": True})
+
     def p_agente(self, q, cuerpo):
         """Tune one agent from its character sheet: model, effort, runtime and
         avatar seed, written to the card keys the launcher already resolves. An

package/bin/test

@@ -22,7 +22,7 @@ if [ -d .git ] && [ -x .githooks/pre-commit ] \
     && printf '  pre-commit gate armed (core.hooksPath .githooks)\n'
 fi
 
-SUITES=(widgets card parcels domains busca serve seat cities channel committee live-feed runtime claude-runtime runtime-ui runtime-failures stress adapter benchmark demo contracts exit rutas cage broker evidencia admision pairing hall-protocol doctor security workspace avatar crecimiento atajos navegador actualiza desinstala launch)
+SUITES=(widgets card parcels domains busca arnes i18n diario serve seat cities channel connect committee live-feed runtime claude-runtime runtime-ui runtime-failures stress adapter benchmark demo contracts exit rutas cage broker evidencia admision pairing hall-protocol doctor security workspace avatar crecimiento atajos navegador actualiza desinstala launch)
 [ $# -gt 0 ] && SUITES=("$@")
 
 fallos=0
@@ -90,16 +90,27 @@ necesarios = ["bin/agents-city.js", "bin/hall", "bin/seat", "bin/city", "bin/dem
               "plugin/scripts/workspace.py", "plugin/scripts/avatar.py",
               "plugin/scripts/crecimiento.py",
               "plugin/scripts/reset.py", "plugin/scripts/desinstala.py",
-              "plugin/scripts/demos.py", "plugin/scripts/capabilities.py",
+              "plugin/scripts/demos.py", "plugin/scripts/arnes.py",
+              "plugin/scripts/diario.py",
+              "plugin/channel/runtime/arnes.json", "plugin/scripts/capabilities.py",
               "plugin/scripts/deliberations.py",
               "plugin/scripts/runtime_processes.py",
               "plugin/scripts/runtime_log.py", "plugin/scripts/logs.py",
               "plugin/scripts/launch.py", "plugin/scripts/hook_activity.py",
+              "plugin/scripts/reception.py",
               "plugin/scripts/city-session.sh", "plugin/scripts/city-runtime.sh",
               "plugin/scripts/find-repos.sh",
               "plugin/scripts/busca.py",
               "plugin/channel/bus.js", "plugin/channel/local-hub.js",
               "plugin/channel/client.js", "plugin/channel/adapter.js",
+              "plugin/channel/managed-connect-client.js",
+              "plugin/channel/managed-connect-client.d.ts",
+              "plugin/channel/managed-connect-client.manifest.json",
+              "plugin/channel/trust/agents-city-sandbox-roots.json",
+              "plugin/channel/kinsh_vodozemac_wasm_bg.wasm",
+              "plugin/channel/agents_city_hybrid_crypto_bg.wasm",
+              "plugin/channel/licenses/CONNECT_CLIENT_THIRD_PARTY_NOTICES.md",
+              "plugin/channel/managed-connect-cli.js", "bin/connect",
               "plugin/channel/runtime-gateway.js",
               "plugin/.mcp.json",
               "bin/cities", "bin/road", "bin/bus", "bin/committee", "bin/agents",
@@ -111,7 +122,8 @@ necesarios = ["bin/agents-city.js", "bin/hall", "bin/seat", "bin/city", "bin/dem
               "benchmarks/latency/fake-native-server.mjs",
               "benchmarks/latency/fake-claude-cli.mjs",
               "benchmarks/stress/run.py", "benchmarks/stress/README.md",
-              "city/web/src/repo-roles.ts",
+              "benchmarks/reception/run.mjs", "benchmarks/reception/README.md",
+              "city/web/src/repo-roles.ts", "city/web/src/vista.ts",
               "demo/show.py", "demo/city/city.yml", "demo/city/ada.md",
               "city/scripts/seed.py", "city/worker/schema.sql", "demo/parcels.yml"]
 problemas = [f"missing: {n}" for n in necesarios if n not in dentro]