stackhelx 1.0.0__py3-none-any.whl

stackhelx/docker.py

@@ -0,0 +1,202 @@
+"""Arranque y reinicio de Docker Desktop, a pedido del usuario.
+
+Vive fuera de `doctor` a proposito: ese modulo diagnostica sin arrancar nada, y
+lo dice en su primera linea. Aca no hay chequeos; el "esta apagado" sigue
+saliendo de `doctor._docker`, que es quien ya lo sabe.
+"""
+
+from __future__ import annotations
+
+import subprocess
+from collections.abc import Sequence
+
+# El plugin del CLI y no el ejecutable. `docker` ya es una dependencia del
+# proyecto y ya tiene que estar en el PATH para que un stack con compose sirva
+# de algo; el ejecutable de Docker Desktop no esta en el PATH en ninguna
+# plataforma, vive en una ruta distinta por sistema operativo, y en Windows
+# lanzarlo con `start` lo hace buscar tambien en el directorio actual, que es
+# el del proyecto que estes mirando.
+#
+# `--detach` porque sin el, el comando espera a que el motor termine: entre 30 y
+# 60 segundos con un request colgado en el threadpool que FastAPI comparte con
+# apagar y con matar procesos. Ver server._probe_late_http, que existe por haber
+# aprendido eso mismo.
+#
+# Diccionario y no un string armado con lo que llegue: lo unico que puede pedir
+# la red es una de estas dos claves, y el comando sale de aca.
+ACTIONS = {
+    "start": ("docker", "desktop", "start", "--detach"),
+    "restart": ("docker", "desktop", "restart", "--detach"),
+}
+TIMEOUT = 10.0
+
+HECHO = {
+    "start": "Docker Desktop esta arrancando",
+    "restart": "Docker Desktop se esta reiniciando",
+}
+
+
+def run(action: str) -> tuple[bool, str]:
+    """Pide `start` o `restart` de Docker Desktop. Devuelve si se pudo, y que decir.
+
+    Mira el resultado en vez de disparar y olvidarse. Un lanzamiento que nadie
+    espera contesta "listo" siempre, tambien cuando Docker no esta instalado, y
+    el usuario se queda mirando una interfaz que le mintio.
+
+    Que el comando haya salido bien no es que el motor este arriba: eso tarda y
+    lo reporta la vista de estado, que ya sondea `docker info`.
+    """
+    command = ACTIONS[action]
+    try:
+        done = subprocess.run(
+            list(command),
+            capture_output=True,
+            text=True,
+            errors="replace",
+            timeout=TIMEOUT,
+        )
+    except FileNotFoundError:
+        return False, "docker no esta en el PATH"
+    except subprocess.TimeoutExpired:
+        return False, f"docker no contesto en {TIMEOUT:.0f}s"
+    except OSError as exc:
+        return False, f"no se pudo ejecutar docker: {exc}"
+
+    if done.returncode != 0:
+        return False, _motivo(done, action)
+    return True, HECHO[action]
+
+
+def _motivo(done: subprocess.CompletedProcess, action: str) -> str:
+    """La primera linea util de la salida, o el codigo si no dijo nada.
+
+    Docker Desktop para Linux no trae el plugin `desktop`, y ahi el error es
+    'docker: desktop is not a docker command'. Decirlo tal cual es mas util que
+    un "no se pudo" que obliga a ir a buscar por que.
+    """
+    for stream in (done.stderr, done.stdout):
+        primera = next((line.strip() for line in (stream or "").splitlines() if line.strip()), "")
+        if primera:
+            return primera[:200]
+    return f"docker desktop {action} fallo con codigo {done.returncode}"
+
+
+def running() -> list[str]:
+    """Nombres de los contenedores corriendo.
+
+    Reiniciar el motor los baja a todos, incluidos los de proyectos que no
+    estas mirando. No hay forma de reiniciarlo a medias, asi que lo unico que
+    se puede hacer por el usuario es decirle que se va a llevar antes de
+    llevarselo. Vacio si docker no contesta: la confirmacion sigue, con la
+    frase generica.
+    """
+    try:
+        done = subprocess.run(
+            ["docker", "ps", "--format", "{{.Names}}"],
+            capture_output=True,
+            text=True,
+            errors="replace",
+            timeout=TIMEOUT,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return []
+    if done.returncode != 0:
+        return []
+    return [line.strip() for line in (done.stdout or "").splitlines() if line.strip()]
+
+
+def usage() -> str | None:
+    """La tabla de `docker system df`, para que la confirmacion diga cuanto hay.
+
+    Sin parsear: Docker ya la formatea, y sacarle el numero a mano seria atarnos
+    a su formato de salida a cambio de nada. None si docker no contesta, y ahi
+    la confirmacion sigue sin la tabla en vez de cancelarse.
+    """
+    try:
+        done = subprocess.run(
+            ["docker", "system", "df"],
+            capture_output=True,
+            text=True,
+            errors="replace",
+            timeout=TIMEOUT,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return None
+    return done.stdout.strip() or None if done.returncode == 0 else None
+
+
+# Que limpia cada categoria, con su comando propio. `docker system prune` los
+# tira todos juntos y no deja elegir: el cache de build puede ser decenas de GB
+# que se regeneran solas, y las imagenes sin tag pueden ser la capa base que vas
+# a volver a bajar. No es lo mismo y el usuario tiene que poder separarlo.
+#
+# Diccionario y no un comando armado con lo que llegue: lo unico que puede pedir
+# la red son estas claves.
+TARGETS = {
+    "containers": ("docker", "container", "prune", "-f"),
+    "images": ("docker", "image", "prune", "-f"),
+    "networks": ("docker", "network", "prune", "-f"),
+    "cache": ("docker", "builder", "prune", "-f"),
+    # Aparte del resto en todos lados: adentro hay datos y no se regeneran. Ni
+    # el default del CLI ni el de la interfaz lo incluyen, y el MCP lo rechaza.
+    "volumes": ("docker", "volume", "prune", "-f"),
+}
+
+# Lo que se limpia cuando no se elige nada. `volumes` queda afuera a proposito.
+DEFAULT_TARGETS = ("containers", "images", "networks", "cache")
+
+ETIQUETAS = {
+    "containers": "contenedores parados",
+    "images": "imagenes sin tag",
+    "networks": "redes sin usar",
+    "cache": "cache de build",
+    "volumes": "volumenes anonimos",
+}
+
+PRUNE_TIMEOUT = 60.0
+
+
+def prune(targets: Sequence[str] | None = None) -> tuple[bool, str]:
+    """Limpia las categorias pedidas, una por una.
+
+    Devuelve si todas salieron bien, y un resumen con lo que reclamo cada una.
+    Una que falle no cancela a las demas: son independientes, y quedarse a mitad
+    sin decir cual fallo es peor que terminar y contarlo.
+    """
+    elegidos = list(targets) if targets else list(DEFAULT_TARGETS)
+    desconocidos = [t for t in elegidos if t not in TARGETS]
+    if desconocidos:
+        return False, f"categoria desconocida: {', '.join(desconocidos)}"
+
+    partes, fallo = [], False
+    for target in elegidos:
+        ok, detalle = _prune_one(target)
+        fallo = fallo or not ok
+        partes.append(f"{ETIQUETAS[target]}: {detalle}")
+    return not fallo, " · ".join(partes)
+
+
+def _prune_one(target: str) -> tuple[bool, str]:
+    try:
+        done = subprocess.run(
+            list(TARGETS[target]),
+            capture_output=True,
+            text=True,
+            errors="replace",
+            timeout=PRUNE_TIMEOUT,
+        )
+    except FileNotFoundError:
+        return False, "docker no esta en el PATH"
+    except subprocess.TimeoutExpired:
+        return False, f"excedio los {PRUNE_TIMEOUT:.0f}s"
+    except OSError as exc:
+        return False, f"no se pudo ejecutar docker: {exc}"
+
+    if done.returncode != 0:
+        return False, _motivo(done, f"{target} prune")
+
+    # La ultima linea de docker es el "Total reclaimed space". Lo demas es la
+    # lista de lo borrado, que en un resumen de una linea no entra.
+    lineas = [line.strip() for line in (done.stdout or "").splitlines() if line.strip()]
+    reclamado = next((line for line in reversed(lineas) if "reclaimed" in line.lower()), "")
+    return True, reclamado.split(":")[-1].strip() if reclamado else "listo"

stackhelx/doctor.py

@@ -0,0 +1,356 @@
+"""Diagnostico: por que este proyecto no arranca, sin arrancarlo.
+
+Vive en su propio modulo y no en `cli.py` porque cruza cuatro modulos y porque
+la interfaz web va a querer los mismos chequeos. `run` devuelve datos; imprimir
+es problema de quien llame.
+"""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+
+from . import config, detect, ports, registry
+
+UI_PORT = 7666
+DOCKER_TIMEOUT = 5.0
+
+
+@dataclass(frozen=True)
+class Check:
+    """Un chequeo y su resultado.
+
+    `fix` es un comando copiable o una accion de una linea. Un chequeo en rojo
+    sin `fix` deja al usuario donde estaba: sabiendo que algo anda mal y no que
+    hacer. Por eso todo lo que sale `fail` lo lleva.
+    """
+
+    name: str
+    level: str  # "ok" | "warn" | "fail"
+    detail: str
+    fix: str = ""
+
+
+def run(root: Path) -> list[Check]:
+    """Entorno siempre, proyecto si hay algo que revisar."""
+    return environment() + project(root)
+
+
+def blocking(checks: list[Check]) -> bool:
+    """Si algo impide arrancar. Los avisos no cuentan, o el codigo de salida
+    daria 1 todo el dia y dejaria de significar algo."""
+    return any(c.level == "fail" for c in checks)
+
+
+# entorno ------------------------------------------------------------------
+
+
+def environment() -> list[Check]:
+    return [_token(), _ui_port(), *_registered()]
+
+
+def _token() -> Check:
+    try:
+        registry.token()
+    except Exception as exc:  # noqa: BLE001 - cualquier fallo aca es el mismo problema
+        return Check(
+            "token",
+            "fail",
+            f"no se pudo leer ni generar {registry.HOME / 'token'}: {exc}",
+            "revisa los permisos de la carpeta, o defini STACKHELX_TOKEN",
+        )
+    return Check("token", "ok", str(registry.HOME / "token"))
+
+
+def _ui_port() -> Check:
+    status = ports.scan(UI_PORT)
+    if status.free:
+        return Check("puerto de la interfaz", "ok", f"{UI_PORT} libre")
+    quien = status.name or "desconocido"
+    return Check(
+        "puerto de la interfaz",
+        "warn",
+        f"{UI_PORT} ocupado por {quien} (pid {status.pid})",
+        f"si no es StackHelx: stackhelx free {UI_PORT}",
+    )
+
+
+def _registered() -> list[Check]:
+    known = registry.paths()
+    if not known:
+        return [
+            Check("proyectos registrados", "ok", "ninguno", "para registrar: stackhelx add .")
+        ]
+    perdidos = [p for p in known if not p.is_dir()]
+    checks = [Check("proyectos registrados", "ok", f"{len(known)}")]
+    for path in perdidos:
+        checks.append(
+            Check(
+                "proyecto sin carpeta",
+                "warn",
+                str(path),
+                f'stackhelx remove "{path}"',
+            )
+        )
+    return checks
+
+
+# proyecto -----------------------------------------------------------------
+
+
+def project(root: Path) -> list[Check]:
+    try:
+        stack = detect.stack_for(root)
+        services = stack.resolve()
+    except config.ConfigError as exc:
+        # Un stack.yaml roto es una falla; no tener ninguno, corriendo doctor en
+        # una carpeta cualquiera, es lo normal recien instalado.
+        if _archivo(root) is None:
+            return [Check("proyecto", "ok", f"{root} no es un proyecto conocido")]
+        return [
+            Check(
+                "stack",
+                "fail",
+                str(exc),
+                "corregi el archivo (ver stack.example.yaml) o borralo para que se detecte",
+            )
+        ]
+
+    origen = "detectado" if stack.detected else str(stack.path)
+    checks = [Check("stack", "ok", f"{origen} ({len(services)} servicios)")]
+    checks += _dotenv(root)
+    checks += _executables(services)
+    if any(_program(s.command) == "docker" for s in services):
+        checks.append(_docker())
+    checks += _ports(services)
+    checks += _compartidos(stack.root, services)
+    return checks
+
+
+def _compartidos(root: Path, services: list[config.Service]) -> list[Check]:
+    """Otros proyectos registrados que declaran los mismos puertos.
+
+    Aviso y no falla: dos proyectos con el mismo puerto conviven mientras no
+    corran a la vez. Lo que hoy no existe es enterarse antes, en vez de cuando
+    el segundo no arranca y el error habla de un puerto ocupado sin decir por
+    quien.
+    """
+    wanted = {s.port for s in services if s.port}
+    if not wanted:
+        return []
+    try:
+        mio = root.resolve()
+    except OSError:
+        mio = root
+
+    duenos = registry.declared_ports()
+    checks = []
+    for port in sorted(wanted):
+        otros = [p for p in duenos.get(port, []) if p != mio]
+        if not otros:
+            continue
+        checks.append(
+            Check(
+                f"puerto {port} compartido",
+                "warn",
+                f"tambien lo declara {', '.join(str(p) for p in otros)}",
+                "arrancalos de a uno, o cambia el port: en uno de los stack.yaml",
+            )
+        )
+    return checks
+
+
+def _parse_env_keys(path: Path) -> dict[str, str]:
+    """Claves y valores de un .env. Lo que no entienda queda afuera.
+
+    ponytail: parte en el primer `=`, saltea vacias y comentarios, y nada mas.
+    Sin comillas, escapes, `export` ni valores multilinea. El techo: un archivo
+    con un valor de varias lineas lee la segunda como una clave rara y la da
+    por faltante. El dia que aparezca uno, hay librerias para esto.
+    """
+    result = {}
+    try:
+        content = path.read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        return result
+    for line in content.splitlines():
+        line = line.strip()
+        if not line or line.startswith("#"):
+            continue
+        if "=" in line:
+            k, v = line.split("=", 1)
+            result[k.strip()] = v.strip()
+    return result
+
+
+_PLACEHOLDER_SECRETS = {
+    "changeme",
+    "change_me",
+    "your_secret_here",
+    "your_api_key",
+    "your-secret-here",
+    "your-api-key",
+    "secret",
+    "password",
+    "admin",
+    "123456",
+    "todo",
+}
+
+
+def _dotenv(root: Path) -> list[Check]:
+    examples = [p for p in (root / ".env.example", root / ".env.template") if p.is_file()]
+    if not examples:
+        return []
+    example_path = examples[0]
+    ejemplo = example_path.name
+    env_path = root / ".env"
+
+    if not env_path.is_file():
+        return [
+            Check(
+                "variables de entorno",
+                "warn",
+                f"{ejemplo} existe pero falta .env local",
+                f"cp {ejemplo} .env",
+            )
+        ]
+
+    # Nombres de claves, nunca valores: esto sale por HTTP en /api/doctor.
+    declaradas = _parse_env_keys(example_path)
+    propias = _parse_env_keys(env_path)
+    faltan = [k for k in declaradas if k not in propias]
+    vacias = [k for k in declaradas if k in propias and not propias[k]]
+    placeholders = [
+        k
+        for k, v in propias.items()
+        if v.strip().strip("'\"").lower() in _PLACEHOLDER_SECRETS
+        or v.strip().strip("'\"").lower().startswith(("your_", "your-"))
+    ]
+
+    # Las advertencias en `warn` y no en `fail`. En este comando `fail` esta reservado
+    # para lo que no puede arrancar y se sabe con certeza: un binario que no
+    # esta en el PATH, docker apagado, un stack.yaml invalido. Una clave que
+    # falta en el .env es una inferencia: puede ser opcional, o venir del
+    # entorno o del compose. Un rojo equivocado gasta el unico rojo que hay.
+    checks = []
+    if faltan:
+        checks.append(
+            Check(
+                "variables de entorno",
+                "warn",
+                f"{ejemplo} declara claves que el .env no tiene: {', '.join(faltan)}",
+                "agregalas al .env, o sacalas del ejemplo si ya no hacen falta",
+            )
+        )
+    if vacias:
+        checks.append(
+            Check(
+                "variables de entorno",
+                "warn",
+                f"sin valor en el .env: {', '.join(vacias)}",
+                "completalas, o dejalas asi si el vacio es a proposito",
+            )
+        )
+    if placeholders:
+        checks.append(
+            Check(
+                "variables de entorno",
+                "warn",
+                f"valores de ejemplo/inseguros en .env: {', '.join(placeholders)}",
+                "reemplaza los placeholders por credenciales reales y seguras",
+            )
+        )
+    return checks or [Check("variables de entorno", "ok", ".env completo")]
+
+
+def _executables(services: list[config.Service]) -> list[Check]:
+    """El primer token de cada comando tiene que estar en el PATH.
+
+    Cubre de una sola vez el gestor de paquetes del lockfile, docker, uvicorn y
+    lo que sea que el usuario haya escrito en su stack.yaml. Un chequeo por
+    tecnologia seria la misma pregunta escrita cuatro veces.
+    """
+    vistos: dict[str, list[str]] = {}
+    for service in services:
+        vistos.setdefault(_program(service.command), []).append(service.name)
+
+    checks = []
+    for programa, duenos in sorted(vistos.items()):
+        if not programa:
+            continue
+        ruta = shutil.which(programa)
+        if ruta:
+            checks.append(Check(f"comando {programa}", "ok", ruta))
+        else:
+            checks.append(
+                Check(
+                    f"comando {programa}",
+                    "fail",
+                    f"no esta en el PATH, lo pide {', '.join(duenos)}",
+                    f"instala {programa}, o corregi el comando en stack.yaml",
+                )
+            )
+    return checks
+
+
+def _docker() -> Check:
+    """El daemon, no el binario. `docker` instalado con Docker Desktop cerrado
+    es el caso que mas veces rompe un arranque, y el error que tira compose es
+    una linea de 200 caracteres con un named pipe adentro."""
+    try:
+        done = subprocess.run(
+            ["docker", "info", "--format", "{{.ServerVersion}}"],
+            capture_output=True,
+            text=True,
+            errors="replace",
+            timeout=DOCKER_TIMEOUT,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return Check("daemon de docker", "fail", "no contesto", "abri Docker Desktop")
+    if done.returncode != 0:
+        return Check("daemon de docker", "fail", "no esta en ejecucion", "abri Docker Desktop")
+    return Check("daemon de docker", "ok", f"servidor {done.stdout.strip()}")
+
+
+def _ports(services: list[config.Service]) -> list[Check]:
+    """Solo los puertos declarados. El de un `npm run dev` no se sabe hasta que
+    arranca, y adivinarlo seria peor que no decir nada."""
+    wanted = [s.port for s in services if s.port]
+    if not wanted:
+        return [Check("puertos", "ok", "ninguno declarado, se descubren al arrancar")]
+
+    scanned = ports.scan_many(wanted)
+    checks = []
+    for service in services:
+        if not service.port:
+            continue
+        status = scanned.get(service.port)
+        if status is None or status.free:
+            checks.append(Check(f"puerto {service.port}", "ok", f"libre ({service.name})"))
+            continue
+        quien = status.name or "desconocido"
+        checks.append(
+            Check(
+                f"puerto {service.port}",
+                "warn",
+                f"ocupado por {quien} (pid {status.pid}), lo pide {service.name}",
+                f"stackhelx free {service.port}",
+            )
+        )
+    return checks
+
+
+def _archivo(root: Path) -> Path | None:
+    try:
+        return config.find(root)
+    except config.ConfigError:
+        return None
+
+
+def _program(command: str) -> str:
+    """Primer token del comando, sin comillas."""
+    head = command.strip().split(maxsplit=1)
+    return head[0].strip('"\'') if head else ""

stackhelx/guardrails.py

@@ -0,0 +1,42 @@
+"""Validacion de los identificadores que se convierten en nombre de archivo.
+
+Aca no hay lista de comandos peligrosos, y es a proposito. Ver la nota en
+`CLAUDE.md`, "Los comandos de stack.yaml no se filtran por contenido".
+"""
+
+from __future__ import annotations
+
+import re
+
+# Longitud máxima permitida para identificadores seguros
+MAX_IDENT_LEN = 64
+
+# Identificadores alfanuméricos seguros para IDs de proyecto y servicios
+_IDENT_PATTERN = re.compile(r"^[a-zA-Z0-9_-]+$")
+
+# Nombres de dispositivos reservados en Windows (DOS Device Names)
+_WINDOWS_RESERVED = {
+    "CON", "PRN", "AUX", "NUL",
+    "COM1", "COM2", "COM3", "COM4", "COM5", "COM6", "COM7", "COM8", "COM9",
+    "LPT1", "LPT2", "LPT3", "LPT4", "LPT5", "LPT6", "LPT7", "LPT8", "LPT9",
+}
+
+
+class GuardrailError(ValueError):
+    """Identificador rechazado por no ser seguro como nombre de archivo."""
+
+
+def validate_identifier(ident: str, field_name: str = "identificador") -> str:
+    """Valida que un ID de proyecto o servicio sea alfanumérico seguro (sin path traversal ni DOS devices)."""
+    clean = str(ident).strip()
+    if not clean:
+        raise GuardrailError(f"{field_name} no puede estar vacío")
+    if len(clean) > MAX_IDENT_LEN:
+        raise GuardrailError(f"{field_name} excede la longitud máxima permitida ({MAX_IDENT_LEN} caracteres)")
+    if not _IDENT_PATTERN.match(clean):
+        raise GuardrailError(
+            f"{field_name} inválido ({clean!r}): solo se permiten letras, números, guiones y guiones bajos"
+        )
+    if clean.upper() in _WINDOWS_RESERVED:
+        raise GuardrailError(f"{field_name} inválido ({clean!r}): nombre de dispositivo reservado en Windows")
+    return clean

stackhelx/history.py

@@ -0,0 +1,86 @@
+import collections
+import json
+import threading
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from . import guardrails, registry
+
+MAX_LIMIT = 50
+MAX_ENTRIES = 500
+RETAIN_ENTRIES = 250
+_history_lock = threading.Lock()
+
+
+def _history_file(pid: str) -> Path:
+    clean_pid = guardrails.validate_identifier(pid, "pid")
+    return (registry.HOME / "history" / f"{clean_pid}.jsonl").resolve()
+
+
+def _read_tail_lines(path: Path, limit: int) -> list[str]:
+    """Lee las últimas `limit` líneas de un archivo sin cortes en líneas largas."""
+    if limit <= 0:
+        return []
+    try:
+        with path.open("r", encoding="utf-8", errors="replace") as f:
+            return [line.rstrip("\r\n") for line in collections.deque(f, maxlen=limit) if line.strip()]
+    except OSError:
+        return []
+
+
+def _rotate_if_needed(path: Path) -> None:
+    """Si el archivo supera el umbral de tamaño, lo trunca reteniendo solo los últimos RETAIN_ENTRIES."""
+    try:
+        if not path.is_file() or path.stat().st_size < 100_000:
+            return
+        last_lines = _read_tail_lines(path, RETAIN_ENTRIES)
+        if last_lines:
+            tmp_path = path.with_suffix(".tmp")
+            with tmp_path.open("w", encoding="utf-8") as f:
+                for line_str in last_lines:
+                    f.write(line_str.strip() + "\n")
+            tmp_path.replace(path)
+    except (OSError, ValueError):
+        pass
+
+
+def append(pid: str, data: dict[str, Any]) -> None:
+    if "timestamp" not in data:
+        data["timestamp"] = datetime.now(timezone.utc).isoformat()
+
+    try:
+        path = _history_file(pid)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with _history_lock:
+            with path.open("a", encoding="utf-8") as f:
+                f.write(json.dumps(data) + "\n")
+            _rotate_if_needed(path)
+    except (OSError, ValueError):
+        pass
+
+
+def read(pid: str, limit: int = 5) -> list[dict[str, Any]]:
+    limit = max(1, min(limit, MAX_LIMIT))
+    try:
+        path = _history_file(pid)
+    except ValueError:
+        return []
+
+    if not path.is_file():
+        return []
+
+    records = []
+    with _history_lock:
+        raw_lines = _read_tail_lines(path, limit)
+
+    for line in raw_lines:
+        if line.strip():
+            try:
+                record = json.loads(line)
+                if isinstance(record, dict):
+                    records.append(record)
+            except json.JSONDecodeError:
+                continue
+
+    return records