ground-control-cli 0.5.0__tar.gz → 0.5.2__tar.gz

{ground_control_cli-0.5.0 → ground_control_cli-0.5.2}/PKG-INFO

@@ -1,5 +1,5 @@
 Metadata-Version: 2.4
 Name: ground-control-cli
-Version: 0.5.0
+Version: 0.5.2
 Summary: What runs on a developer's machine: the command line and the agent's plugin.
 Requires-Python: >=3.12

{ground_control_cli-0.5.0 → ground_control_cli-0.5.2}/probes/__init__.py

@@ -13,7 +13,7 @@ from __future__ import annotations
 
 from collections.abc import Callable
 
-from . import code, deploy, gh, git, health, queue, request, tests, workspace
+from . import code, gh, git, health, queue, request, tests, workspace
 
 # Every probe the client runs: its name -> the function of (params, root) that runs it.
 RUNS: dict[str, Callable[[dict, object], dict]] = {
@@ -41,8 +41,6 @@ RUNS: dict[str, Callable[[dict, object], dict]] = {
     "git.remote_branch": git.remote_branch,
     "request.read": request.read,
     "workspace.changes": workspace.changes,
-    "deploy.commit": deploy.commit,
-    "deploy.discover": deploy.discover,
     "queue.waiting": queue.waiting,
 }
 

{ground_control_cli-0.5.0 → ground_control_cli-0.5.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ground-control-cli"
-version = "0.5.0"
+version = "0.5.2"
 description = "What runs on a developer's machine: the command line and the agent's plugin."
 requires-python = ">=3.12"
 dependencies = []

{ground_control_cli-0.5.0 → ground_control_cli-0.5.2}/service.py

@@ -343,44 +343,6 @@ class Service:
         """
         return self.call("GET", "/api/plugin/settings?" + urlencode({"repo": repo}))
 
-    def run_checks(
-        self, repo: str, feature: str, step: str, moment: str, root, entering=None
-    ) -> list[dict]:
-        """Have a step's checks run on the service, running here the probes it asks for.
-
-        Args:
-            repo: The repo, as its host writes it, such as owner/repo.
-            feature: The feature, `<lane>/<name>`.
-            step: The step entered or exited.
-            moment: entry or exit.
-            root: The checkout the probes run in.
-            entering: The fields of the step_enter row being entered, for the entry checks.
-
-        Returns:
-            Every check of the step, as the service decided it, in run order.
-
-        Raises:
-            ServiceError: If the service refuses, cannot be reached, or asks again for a probe
-                it was given.
-
-        Company: the one at the address.
-        """
-        body = {"repo": repo, "feature": feature, "step": step, "moment": moment}
-        body["entering"] = dict(entering or {})
-        found: list[dict] = []
-        ran: set[str] = set()
-        while True:
-            answer = self.call("POST", "/api/plugin/check", body | {"facts": found})
-            if not answer["need"]:
-                return answer["checks"]
-            for probe in answer["need"]:
-                key = json.dumps(probe, sort_keys=True)
-                if key in ran:
-                    raise ServiceError(None, f"the service asked again for {probe['name']}")
-                ran.add(key)
-                fact = probes.run(probe["name"], probe["params"], root)
-                found.append(probe | {"fact": fact})
-
     def create_plan(self, repo: str, feature: str, role: str, issue: str = "") -> int:
         """Have the service make a feature's plan, as its first version.
 

ground_control_cli-0.5.0/probes/deploy.py

@@ -1,261 +0,0 @@
-"""The deploy probes: which commit production runs, and where production says it.
-
-Production is asked from the developer's machine, never from the service. deploy.commit asks the
-health address once, or every poll until production runs the commit waited for or a descendant
-of it; deploy.discover finds the health address in the repo. A fact is a commit, an address, a
-status, a field's name; never what an answer said beyond the commit.
-"""
-
-from __future__ import annotations
-
-import json
-import re
-import subprocess
-import time
-import urllib.error
-import urllib.request
-from pathlib import Path
-from urllib.parse import urlsplit
-
-from . import errors
-
-MIN_PREFIX = 7
-HEALTH_PATHS = ("/healthz", "/health", "/healthcheck", "/api/health", "/status", "/ready", "/livez")
-ENV_EXAMPLES = (".env.example", ".env.sample", ".env.template", "example.env", "sample.env")
-PRODUCTION_KEY_RE = re.compile(
-    r"""^\s*(?:export\s+)?([A-Z0-9_]*PROD[A-Z0-9_]*_(?:URL|DOMAIN|HOST))\s*=\s*["']?([^"'\s#]+)"""
-)
-TOML_SECTION_RE = re.compile(r"^\s*\[([^\]]+)\]\s*$")
-TOML_HEALTH_RE = re.compile(r"""^\s*healthcheckPath\s*=\s*["']([^"']+)["']""")
-HEX_RE = re.compile(r"^[0-9a-fA-F]+$")
-# The extensions a code reader reads, and the shebang of a script it reads: where discovery looks
-# for a health path as a string literal.
-SOURCE = (".py", ".js", ".mjs", ".cjs", ".jsx", ".ts", ".tsx", ".html", ".sh")
-SHEBANG_RE = re.compile(r"#!\s*(?:\S*/)?(?:env\s+(?:-\S+\s+)*)?(?:\S*/)?(?:bash|sh)(?:\s|$)")
-
-
-def _git(root, *args) -> subprocess.CompletedProcess:
-    return subprocess.run(["git", *args], cwd=root, capture_output=True, text=True)
-
-
-def _resolve(root, ref: str) -> str:
-    out = _git(root, "rev-parse", "--verify", "-q", f"{ref}^{{commit}}")
-    return out.stdout.strip() if out.returncode == 0 else ""
-
-
-def _commit_of(root, prefix: str) -> str:
-    """The full commit a prefix names, fetching origin once when it is not known yet; or ""."""
-    if not (len(prefix) >= MIN_PREFIX and HEX_RE.match(prefix)):
-        return ""
-    found = _resolve(root, prefix)
-    if not found:
-        _git(root, "fetch", "-q", "origin")
-        found = _resolve(root, prefix)
-    return found
-
-
-def _covers(root, returned: str, release: str) -> bool:
-    return bool(returned and release) and (
-        _git(root, "merge-base", "--is-ancestor", release, returned).returncode == 0
-    )
-
-
-def _fetch(url: str, limit: float) -> tuple:
-    """(the reply's JSON, None, status) or (None, why, status)."""
-    try:
-        with urllib.request.urlopen(url, timeout=limit) as reply:
-            body, status = reply.read(), reply.status
-    except urllib.error.HTTPError as e:
-        return None, "not_2xx", e.code
-    except (urllib.error.URLError, OSError, ValueError):
-        return None, "no_reply", None
-    try:
-        return json.loads(body.decode("utf-8", errors="replace")), None, status
-    except json.JSONDecodeError:
-        return None, "not_json", status
-
-
-def fields(reply) -> dict:
-    """The top-level fields of a JSON object, and those one level down as `outer.inner`."""
-    out = {}
-    if not isinstance(reply, dict):
-        return out
-    for key, value in reply.items():
-        out[key] = value
-        if isinstance(value, dict):
-            for inner, deeper in value.items():
-                out[f"{key}.{inner}"] = deeper
-    return out
-
-
-def commit(params: dict, root) -> dict:
-    """deploy.commit: the commit production runs, waiting for one when asked to.
-
-    Args:
-        params: {"url", "commit_field", "until", "timeout", "poll", "limit"}.
-        root: The repo, where commits are resolved.
-
-    Returns:
-        The DeployFacts fields.
-
-    Company: assumes none.
-    """
-    until, end = params.get("until") or "", time.monotonic() + float(params.get("timeout") or 0)
-    seen = ""
-    while True:
-        reply, _, _ = _fetch(params["url"], float(params.get("limit") or 5))
-        value = fields(reply).get(params["commit_field"]) if reply is not None else None
-        seen = _commit_of(root, value.lower()) if isinstance(value, str) else ""
-        if not until or _covers(root, seen, until):
-            break
-        left = end - time.monotonic()
-        if left <= 0:
-            break
-        time.sleep(min(float(params.get("poll") or 30), left))
-    if not seen:
-        return {"error": errors.NOT_FOUND}
-    return {"commit": seen, "covers": bool(until) and _covers(root, seen, until)}
-
-
-# --- discover ----------------------------------------------------------------------------------
-
-
-def _read(root, name: str) -> str:
-    try:
-        return (Path(root) / name).read_text(encoding="utf-8", errors="replace")
-    except OSError:
-        return ""
-
-
-def _is_source(root, name: str) -> bool:
-    if Path(name).suffix.lower() in SOURCE:
-        return True
-    first = _read(root, name).split("\n", 1)[0]
-    return bool(SHEBANG_RE.match(first.strip()))
-
-
-def _base(value: str) -> str:
-    parts = urlsplit(value if "://" in value else f"https://{value}")
-    return f"{parts.scheme}://{parts.netloc}" if parts.netloc else ""
-
-
-def _domain(root, files: list) -> str:
-    for name in files:
-        if Path(name).name == "vercel.json":
-            try:
-                alias = json.loads(_read(root, name)).get("alias")
-            except (json.JSONDecodeError, AttributeError):
-                alias = None
-            alias = alias[0] if isinstance(alias, list) and alias else alias
-            if isinstance(alias, str) and _base(alias.strip()):
-                return _base(alias.strip())
-    for name in files:
-        if Path(name).name == "CNAME":
-            host = _read(root, name).strip().splitlines()
-            if host and _base(host[0].strip()):
-                return _base(host[0].strip())
-    for name in files:
-        if Path(name).name in ENV_EXAMPLES or Path(name).name.endswith(".env.example"):
-            for line in _read(root, name).splitlines():
-                m = PRODUCTION_KEY_RE.match(line)
-                if m and _base(m.group(2)):
-                    return _base(m.group(2))
-    return ""
-
-
-def _host_path(root, files: list) -> str:
-    for name in files:
-        base = Path(name).name
-        if base == "railway.json":
-            try:
-                deploy = json.loads(_read(root, name)).get("deploy") or {}
-                path = deploy.get("healthcheckPath", "")
-            except (json.JSONDecodeError, AttributeError):
-                path = ""
-            if isinstance(path, str) and path.startswith("/"):
-                return path
-        elif base == "railway.toml":
-            section = ""
-            for line in _read(root, name).splitlines():
-                m = TOML_SECTION_RE.match(line)
-                if m:
-                    section = m.group(1).strip()
-                    continue
-                m = TOML_HEALTH_RE.match(line)
-                if m and section == "deploy" and m.group(1).startswith("/"):
-                    return m.group(1)
-    return ""
-
-
-def _paths(root, files: list) -> list:
-    """The host settings' health path, then each usual one written as a literal in the source."""
-    out = [p for p in (_host_path(root, files),) if p]
-    texts = [_read(root, n) for n in files if (Path(root) / n).is_file() and _is_source(root, n)]
-    for path in HEALTH_PATHS:
-        literal = re.compile(r"""(["'`])""" + re.escape(path) + r"\1")
-        if path not in out and any(literal.search(t) for t in texts):
-            out.append(path)
-    return out
-
-
-def discover(params: dict, root) -> dict:
-    """deploy.discover: the first health address whose JSON reply names a commit on origin/main.
-
-    Args:
-        params: {"domain", "commit_field"}.
-        root: The repo.
-
-    Returns:
-        The DiscoverFacts fields.
-
-    Company: assumes none.
-    """
-    out = _git(root, "ls-files", "-z")
-    if out.returncode != 0:
-        return {"error": errors.failed(out.stderr)}
-    files = [f for f in out.stdout.split("\0") if f]
-    base = _base(params["domain"]) if params.get("domain") else _domain(root, files)
-    if not base:
-        return {"no_domain": True}
-    paths = _paths(root, files)
-    if not paths:
-        return {"no_path": True}
-    _git(root, "fetch", "-q", "origin", "main")
-    listed = _git(root, "rev-list", "origin/main")
-    main = listed.stdout.split() if listed.returncode == 0 else []
-    wanted, tried = params.get("commit_field") or "", []
-    for path in paths:
-        url = base + path
-        reply, why, status = _fetch(url, 5)
-        if reply is None:
-            tried.append({"url": url, "reason": why, "status": status})
-            continue
-        found = {
-            name: value
-            for name, value in fields(reply).items()
-            if isinstance(value, str)
-            and len(value) >= MIN_PREFIX
-            and HEX_RE.match(value)
-            and any(c.startswith(value.lower()) for c in main)
-        }
-        if not found:
-            names = sorted(fields(reply))
-            tried.append(
-                {"url": url, "reason": "no_commit_field", "status": status, "fields": names}
-            )
-            continue
-        if wanted:
-            if wanted in found:
-                return {"url": url, "commit_field": wanted, "value": found[wanted], "tried": tried}
-            tried.append(
-                {"url": url, "reason": "not_that_field", "status": status, "fields": sorted(found)}
-            )
-            continue
-        if len(found) > 1:
-            tried.append(
-                {"url": url, "reason": "several_fields", "status": status, "fields": sorted(found)}
-            )
-            return {"tried": tried}
-        [(name, value)] = found.items()
-        return {"url": url, "commit_field": name, "value": value, "tried": tried}
-    return {"tried": tried}