agents-city 0.3.0-beta.21

package/plugin/scripts/runtime_log.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python3
+"""Append secret-scrubbed operational diagnostics for one local city."""
+import argparse
+import datetime
+import json
+import os
+import re
+import uuid
+
+import runtime_processes
+
+
+def _clean(value, limit=2000):
+    text = str(value or '').strip()
+    text = re.sub(r'([?&](?:token|secret|key)=)[^&\s]+', r'\1[redacted]', text,
+                  flags=re.IGNORECASE)
+    text = re.sub(r'Bearer\s+\S+', 'Bearer [redacted]', text, flags=re.IGNORECASE)
+    text = re.sub(r'(Authorization:\s*)\S+(?:\s+\S+)?', r'\1[redacted]', text,
+                  flags=re.IGNORECASE)
+    text = re.sub(r'(--(?:token|password|secret|api-key)(?:=|\s+))\S+',
+                  r'\1[redacted]', text, flags=re.IGNORECASE)
+    text = re.sub(r'((?:TOKEN|SECRET|PASSWORD|API_KEY)=)[^\s]+',
+                  r'\1[redacted]', text, flags=re.IGNORECASE)
+    return text[:limit]
+
+
+def append(data, component, event, **fields):
+    """Best-effort logging: diagnostics must never stop an agent."""
+    try:
+        directory = runtime_processes.ruta(data)
+        os.makedirs(directory, mode=0o700, exist_ok=True)
+        path = os.path.join(directory, 'diagnostics.jsonl')
+        record = {
+            'protocol': 'agents-city-diagnostic/1',
+            'id': 'diagnostic_' + uuid.uuid4().hex,
+            'at': datetime.datetime.now(datetime.timezone.utc).isoformat(),
+            'pid': os.getpid(),
+            'component': _clean(component, 80),
+            'event': _clean(event, 120),
+        }
+        for key, value in fields.items():
+            if value is None:
+                continue
+            record[key] = ('[redacted]' if re.search(
+                r'token|secret|authorization|credential', key, re.IGNORECASE)
+                else _clean(value))
+        fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_APPEND, 0o600)
+        with os.fdopen(fd, 'a', encoding='utf-8') as stream:
+            stream.write(json.dumps(record, ensure_ascii=False) + '\n')
+    except Exception:
+        pass
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('event')
+    parser.add_argument('--data', default=os.environ.get('AGENTS_CITY_DATA', ''))
+    parser.add_argument('--component', default='launcher')
+    parser.add_argument('--actor', default=os.environ.get('CITY_BUS_ACTOR', ''))
+    parser.add_argument('--outcome', default='')
+    parser.add_argument('--message', default='')
+    args = parser.parse_args()
+    if args.data:
+        append(args.data, args.component, args.event, actor=args.actor,
+               outcome=args.outcome, message=args.message)
+
+
+if __name__ == '__main__':
+    main()

package/plugin/scripts/runtime_processes.py

@@ -0,0 +1,132 @@
+#!/usr/bin/env python3
+"""Exact process markers for one city's local bus and runtime gateways."""
+import json
+import os
+import re
+import shlex
+import subprocess
+
+import cities
+
+
+def ruta(datos):
+    ident = cities.identidad(datos)
+    key = re.sub(r'[^a-z0-9-]+', '-', ident.lower()).strip('-')[:80] or 'city'
+    return os.path.join(cities.raiz(), '.runtime', 'bus', key)
+
+
+def procesos(datos):
+    """Return every exact city runtime, including one that lost its marker.
+
+    Marker files are the fast path. A crashed or racing predecessor can lose
+    its endpoint while the process survives, so also inspect argv and accept
+    only a known entrypoint whose literal ``--data`` resolves to this city.
+    """
+    datos = os.path.realpath(datos)
+    base = ruta(datos)
+    candidatos = []
+    try:
+        endpoint = json.load(open(os.path.join(base, 'endpoint.json'), encoding='utf-8'))
+        candidatos.append(('bus hub', int(endpoint.get('pid', 0)), 'local-hub.js'))
+    except (OSError, ValueError, TypeError, json.JSONDecodeError):
+        pass
+    for folder, label, marker in (
+            ('gateways', 'gateway', 'runtime-gateway.js'),
+            ('adapters', 'terminal fallback', 'adapter.js')):
+        directory = os.path.join(base, folder)
+        try:
+            nombres = [n for n in os.listdir(directory) if n.endswith('.pid')]
+        except OSError:
+            nombres = []
+        for nombre in nombres:
+            try:
+                pid = int(open(os.path.join(directory, nombre), encoding='utf-8').read().strip())
+            except (OSError, ValueError):
+                continue
+            candidatos.append((f'{label} {nombre[:-4]}', pid, marker))
+
+    vistos = set()
+    fuera = []
+    for etiqueta, pid, componente in candidatos:
+        if pid <= 0:
+            continue
+        try:
+            comando = subprocess.run(
+                ['ps', '-p', str(pid), '-o', 'command='],
+                capture_output=True, text=True, timeout=3).stdout.strip()
+        except (OSError, subprocess.TimeoutExpired):
+            comando = ''
+        if componente in comando and datos in comando:
+            fuera.append({'label': etiqueta, 'pid': pid})
+            vistos.add(pid)
+    for proceso in _procesos_sin_marca(datos):
+        if proceso['pid'] not in vistos:
+            fuera.append(proceso)
+            vistos.add(proceso['pid'])
+    return fuera
+
+
+def _procesos_sin_marca(datos):
+    """Discover only node entrypoints with an exact ``--data <city>`` argv."""
+    try:
+        salida = subprocess.run(
+            ['ps', '-Ao', 'pid=,command='], capture_output=True, text=True,
+            timeout=5).stdout
+    except (OSError, subprocess.TimeoutExpired):
+        return []
+    componentes = {
+        'local-hub.js': 'bus hub',
+        'runtime-gateway.js': 'gateway',
+        'adapter.js': 'terminal fallback',
+    }
+    encontrados = []
+    for linea in salida.splitlines():
+        match = re.match(r'\s*(\d+)\s+(.*)', linea)
+        if not match:
+            continue
+        pid, comando = int(match.group(1)), match.group(2)
+        if pid in (os.getpid(), os.getppid()):
+            continue
+        try:
+            argv = shlex.split(comando)
+        except ValueError:
+            continue
+        indice = next(
+            (i for i, value in enumerate(argv[:3])
+             if os.path.basename(value) in componentes), None)
+        if indice is None:
+            continue
+        try:
+            data_index = argv.index('--data', indice + 1)
+            data = os.path.realpath(argv[data_index + 1])
+        except (ValueError, IndexError):
+            continue
+        if data != datos:
+            continue
+        componente = os.path.basename(argv[indice])
+        etiqueta = componentes[componente]
+        if componente in ('runtime-gateway.js', 'adapter.js'):
+            try:
+                actor = argv[argv.index('--actor', indice + 1) + 1]
+                etiqueta = f'{etiqueta} {actor}'
+            except (ValueError, IndexError):
+                pass
+        encontrados.append({'label': etiqueta, 'pid': pid})
+    return encontrados
+
+
+def limpia_marcas(datos):
+    base = ruta(datos)
+    rutas = [os.path.join(base, 'endpoint.json'), os.path.join(base, 'hub.lock')]
+    for folder in ('gateways', 'adapters'):
+        directory = os.path.join(base, folder)
+        try:
+            rutas += [os.path.join(directory, n) for n in os.listdir(directory)
+                      if n.endswith('.pid')]
+        except OSError:
+            pass
+    for path in rutas:
+        try:
+            os.unlink(path)
+        except OSError:
+            pass

package/plugin/scripts/rutas.py

@@ -0,0 +1,83 @@
+#!/usr/bin/env python3
+"""Path containment, resolved twice, in one place.
+
+Every part of the security layer that trusts a path — the cage deciding what to
+re-allow for writing, the broker deciding which repo a token may act on — needs
+the same three questions answered the same way:
+
+1. Where does this path *really* point, even if its leaf does not exist yet?
+   A non-existent leaf under a symlinked parent still redirects, so we resolve
+   through the deepest ancestor that does exist.
+2. Is it inside a forbidden root?
+3. Does it *cover* a forbidden root (an ancestor of it)? Re-allowing `~` would
+   silently re-open `~/.ssh`; that is the bug this module exists to refuse.
+
+Kept dependency-free and pure so both the cage and the broker import it, and so
+the tests can drive it on any platform without a sandbox.
+"""
+
+import os
+
+
+def canonicaliza(ruta):
+    """Absolute real path, resolved through the deepest ancestor that exists.
+
+    `os.path.realpath` already does this on most inputs, but it stops resolving
+    once it meets a missing component; we walk up to the first existing ancestor,
+    resolve *that*, then re-attach the missing tail. A symlinked parent with a
+    not-yet-created child therefore still lands on the real target.
+    """
+    ruta = os.path.abspath(os.path.expanduser(ruta))
+    cola = []
+    actual = ruta
+    while not os.path.exists(actual):
+        padre = os.path.dirname(actual)
+        if padre == actual:
+            break
+        cola.append(os.path.basename(actual))
+        actual = padre
+    base = os.path.realpath(actual)
+    for segmento in reversed(cola):
+        base = os.path.join(base, segmento)
+    return base
+
+
+def _segmentos(ruta):
+    return [s for s in canonicaliza(ruta).split(os.sep) if s]
+
+
+def _dentro_seg(h, p):
+    return len(h) >= len(p) and h[: len(p)] == p
+
+
+def _cubre_seg(a, d):
+    return len(a) < len(d) and d[: len(a)] == a
+
+
+def dentro_de(hijo, padre):
+    """True when `hijo` is `padre` or lives under it — compared segment-wise so
+    `/a/bc` is never judged to be inside `/a/b`."""
+    return _dentro_seg(_segmentos(hijo), _segmentos(padre))
+
+
+def cubre(ancestro, descendiente):
+    """True when `ancestro` is a strict parent of `descendiente` (covers it)."""
+    return _cubre_seg(_segmentos(ancestro), _segmentos(descendiente))
+
+
+def motivo_bloqueo(ruta, bloqueados):
+    """Why `ruta` may not be trusted against a set of forbidden roots, or None.
+
+    Bidirectional on purpose: a path is refused both when it sits inside a
+    forbidden root and when it is an ancestor that would re-open one. `ruta` is
+    canonicalized once here and compared segment-wise against every root.
+    """
+    r_can = canonicaliza(ruta)
+    r_seg = [s for s in r_can.split(os.sep) if s]
+    for raiz in bloqueados:
+        raiz_seg = _segmentos(raiz)
+        if _dentro_seg(r_seg, raiz_seg):
+            return f'{r_can} is inside sealed {canonicaliza(raiz)}'
+        if _cubre_seg(r_seg, raiz_seg):
+            return f'{r_can} covers sealed {canonicaliza(raiz)}'
+    return None