orbi-cli 0.7.26__tar.gz → 0.7.27__tar.gz

{orbi_cli-0.7.26 → orbi_cli-0.7.27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orbi-cli
-Version: 0.7.26
+Version: 0.7.27
 Summary: Orbi — local AI development worker: claims GitHub Issues, runs Pi in isolated worktrees, and delivers PRs (GitHub Issues + labels are the only state store).
 Author: xqliu
 License-Expression: AGPL-3.0-only OR LicenseRef-Sustainable-Use-1.0

{orbi_cli-0.7.26 → orbi_cli-0.7.27}/pyproject.toml

@@ -44,7 +44,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "orbi-cli"
-version = "0.7.26"
+version = "0.7.27"
 description = "Orbi — local AI development worker: claims GitHub Issues, runs Pi in isolated worktrees, and delivers PRs (GitHub Issues + labels are the only state store)."
 readme = "README.md"
 requires-python = ">=3.14"

{orbi_cli-0.7.26 → orbi_cli-0.7.27}/src/orbi/__init__.py

@@ -18,4 +18,4 @@ the package would shadow the installed package for every process with
 the checkout root on sys.path. The direct-execution compatibility entry
 is `python3 -m orbi.cli` (development path only).
 """
-__version__ = "0.7.26"
+__version__ = "0.7.27"

{orbi_cli-0.7.26 → orbi_cli-0.7.27}/src/orbi/config.py

@@ -401,9 +401,16 @@ def load_config(path: Path, *, check_provider_api_keys: bool = True,
     # Runner-self health alert routing: the orbi repo that
     # receives the watchdog's crash_loop / stale_pickup Issues. Absent ->
     # None (the Runner derives the orbi repo from the deploy home's git
-    # origin); present -> must be a non-empty `owner/repo` string, used
-    # verbatim for fork/private deployments.
-    health_alert_repo = _optional_pi_string(data, "health_alert_repo")
+    # origin when it detects something); a string is kept verbatim — an
+    # explicit empty string turns alert FILING off while the detection and
+    # its `health_degraded` journal event stay (Issue #1985), any other
+    # value is the `owner/repo` the alert is filed in (fork/private
+    # deployments). A non-string fails the load fast.
+    health_alert_repo = data.get("health_alert_repo")
+    if health_alert_repo is not None and not isinstance(
+        health_alert_repo, str,
+    ):
+        raise ValueError("health_alert_repo must be a string")
     repo_dir = _config_path(data.get("repo_dir", "."), base)
     # Deployment home: the orbi source checkout — the editable
     # CLI install source, the systemd/ unit templates, labels.toml and the

{orbi_cli-0.7.26 → orbi_cli-0.7.27}/src/orbi/example_config.toml

@@ -213,7 +213,8 @@ max_concurrency = 1
 # by `orbi doctor` under unmanaged_units.
 # unit_name = "core"
 # Runner health alerts (crash_loop/stale_pickup) go here when set; absent
-# derives the Orbi repository from the deploy-home origin.
+# derives the Orbi repository from the deploy-home origin; "" turns alert
+# Issues OFF while the detection and its health_degraded journal event stay.
 # health_alert_repo = "OWNER/ORBI-REPO"
 # Repository policy may override the ready label for this delivery source.
 # dispatch_label = "ai-ready"

{orbi_cli-0.7.26 → orbi_cli-0.7.27}/src/orbi/runner_health.py

@@ -627,9 +627,13 @@ def _run_health_check_locked(config: RunnerConfig, *, run_command) -> list[str]:
         # `health_alert_repo` override wins (fork/private deployments);
         # otherwise the orbi repo is derived from the deploy home's git
         # origin. Undeterminable -> log and skip (bypass: never guess a
-        # repo, never file the alert in the delivery repo).
+        # repo, never file the alert in the delivery repo). An explicit
+        # empty string (Issue #1985) turns alert FILING off: no
+        # alert-repository lookup at all, while the detection and its
+        # `health_degraded` event stay.
         alert_repo = config.health_alert_repo
-        if not alert_repo:
+        alerts_off = alert_repo == ""
+        if alert_repo is None:
             alert_repo = orbi_repo_from_deploy_home(
                 config.deploy_home, run_command,
             )
@@ -653,13 +657,7 @@ def _run_health_check_locked(config: RunnerConfig, *, run_command) -> list[str]:
                 "health_degraded", check="crash_loop", crashes=crashes,
                 window_minutes=CRASH_WINDOW_MINUTES, kind=kind,
             )
-            if not alert_repo:
-                event(
-                    "health_alert_repo_undetermined",
-                    level=logging.WARNING, check="crash_loop",
-                    crashes=crashes,
-                )
-            else:
+            if alert_repo:
                 detail = (
                     f"service crashed {crashes} times in the last "
                     f"{CRASH_WINDOW_MINUTES} minutes"
@@ -676,6 +674,12 @@ def _run_health_check_locked(config: RunnerConfig, *, run_command) -> list[str]:
                     dispatchable=(kind == "bug"),
                 )
                 alerts.append("crash_loop")
+            elif not alerts_off:
+                event(
+                    "health_alert_repo_undetermined",
+                    level=logging.WARNING, check="crash_loop",
+                    crashes=crashes,
+                )
         # 2. Repeated same-fingerprint run failures (#246 scene).
         for finding in repeated_failure_findings(state):
             key = (
@@ -748,12 +752,7 @@ def _run_health_check_locked(config: RunnerConfig, *, run_command) -> list[str]:
                         time.time() - state["last_pickup_ts"],
                     ),
                 )
-                if not alert_repo:
-                    event(
-                        "health_alert_repo_undetermined",
-                        level=logging.WARNING, check="stale_pickup",
-                    )
-                else:
+                if alert_repo:
                     create_health_issue(
                         alert_repo, "stale_pickup",
                         (
@@ -764,6 +763,11 @@ def _run_health_check_locked(config: RunnerConfig, *, run_command) -> list[str]:
                         run_command=run_command,
                     )
                     alerts.append("stale_pickup")
+                elif not alerts_off:
+                    event(
+                        "health_alert_repo_undetermined",
+                        level=logging.WARNING, check="stale_pickup",
+                    )
     finally:
         save_health_state(state_path, state)
     return alerts

{orbi_cli-0.7.26 → orbi_cli-0.7.27}/src/orbi_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: orbi-cli
-Version: 0.7.26
+Version: 0.7.27
 Summary: Orbi — local AI development worker: claims GitHub Issues, runs Pi in isolated worktrees, and delivers PRs (GitHub Issues + labels are the only state store).
 Author: xqliu
 License-Expression: AGPL-3.0-only OR LicenseRef-Sustainable-Use-1.0

{orbi_cli-0.7.26 → orbi_cli-0.7.27}/tests/test_ci_workflow.py

@@ -496,6 +496,51 @@ def test_ci_workflow_pins_the_mintlify_cli_version():
         )
 
 
+# Issue #1983: `mint@4.2.890` validates through @mintlify/previewing's
+# `is-online@10` connectivity probe: three got requests raced under a
+# `pTimeout`, and when the timeout fired it called `.cancel()` on every
+# probe — got's p-cancelable throws "The `onCancel` handler was attached
+# after the promise settled." for a probe that had already settled, inside
+# the `.catch()` handler, so the throw is uncaught and kills the CLI
+# (2026-10-28, run 40708890646: one slow probe on a GitHub runner). The
+# newer @mintlify/previewing pulls no `is-online`/`got` probe at all: its
+# own `local-preview/is-online.js` uses native `fetch` under an
+# AbortController and `catch { return false }`, so a slow probe can no
+# longer terminate the process. `mint@4.2.1157` is the pinned version of
+# that fixed tree; the pin is a FLOOR (bumping further is the deliberate
+# one-line change #744 describes, a downgrade comes back to the crash).
+MINTLIFY_MIN_VERSION = (4, 2, 1157)
+
+
+def test_ci_workflow_pins_the_mintlify_cli_without_the_fragile_connectivity_probe():
+    """Issue #1983: the docs build smoke must not run a Mintlify CLI whose
+    `validate` ships the p-cancelable/is-online probe that aborts the whole
+    process when a connectivity probe is slow. A slow probe is runner
+    weather, not a docs defect, and it turned `main` red."""
+    commands = step_commands(steps_of(load_workflow()))
+    installs = [
+        command for command in commands
+        if re.search(r"npm (i|install)( -g)? mint\b", command)
+    ]
+    assert installs, (
+        "CI must install the official Mintlify CLI (mint), "
+        f"steps run: {commands!r}"
+    )
+    for command in installs:
+        match = re.search(r"\bmint@([0-9]+)\.([0-9]+)\.([0-9]+)\b", command)
+        assert match, (
+            "the Mintlify CLI install must pin an exact version "
+            f"(npm install -g mint@<semver>, Issue #744), got: {command!r}"
+        )
+        pinned = tuple(int(part) for part in match.groups())
+        assert pinned >= MINTLIFY_MIN_VERSION, (
+            "the pinned Mintlify CLI must be at least "
+            f"{'.'.join(str(part) for part in MINTLIFY_MIN_VERSION)}: older "
+            "versions ship the is-online/got connectivity probe that crashes "
+            f"`mint validate` on a slow probe (Issue #1983), got: {command!r}"
+        )
+
+
 def test_testing_documents_remote_ci():
     """Issue #241: the remote CI contract lives in docs/testing.mdx
     (the README homepage keeps only the summary plus the docs link):

{orbi_cli-0.7.26 → orbi_cli-0.7.27}/tests/test_runner_config.py

@@ -429,14 +429,29 @@ def test_load_config_health_alert_repo_default_and_override(tmp_path):
         "fork-owner/orbi-fork"
 
 
-def test_load_config_rejects_empty_health_alert_repo(tmp_path):
+def test_load_config_keeps_empty_health_alert_repo_as_off(tmp_path):
+    """Issue #1985: an explicit empty string turns health-alert FILING off
+    while the detection stays; it loads instead of failing the whole
+    config."""
     config_path = tmp_path / "orbi.toml"
     config_path.write_text(
         'source_repos = ["owner/repo"]\nhealth_alert_repo = ""\n',
         encoding="utf-8",
     )
+    assert config_domain.load_config(config_path).health_alert_repo == ""
+
+
+def test_load_config_rejects_non_string_health_alert_repo(tmp_path):
+    """Issue #1985: the two documented values are "" (off) and
+    "owner/repo" (route it there) — anything that is not a string is a
+    misconfiguration and fails the load fast."""
+    config_path = tmp_path / "orbi.toml"
+    config_path.write_text(
+        'source_repos = ["owner/repo"]\nhealth_alert_repo = 42\n',
+        encoding="utf-8",
+    )
     with pytest.raises(
-        ValueError, match="health_alert_repo must be a non-empty string",
+        ValueError, match="health_alert_repo must be a string",
     ):
         config_domain.load_config(config_path)
 

{orbi_cli-0.7.26 → orbi_cli-0.7.27}/tests/test_runner_health.py

@@ -1151,6 +1151,52 @@ def test_health_alert_repo_override_wins(tmp_path):
     assert fake.commands("remote get-url origin") == []
 
 
+def test_empty_health_alert_repo_keeps_detection_without_filing(tmp_path, caplog):
+    """Issue #1985: `health_alert_repo = ""` turns alert FILING off — the
+    crash loop is still detected and journaled, but no alert-repository
+    lookup runs and no alert Issue is filed."""
+    write_state(tmp_path, {"runs": [], "last_pickup_ts": time.time(),
+                           "alerted": []})
+    fake = FakeRunCommand({
+        "journalctl --user -u orbi@1.service": THREE_CRASH_JOURNAL,
+        "journalctl --user -u orbi@2.service": "",
+    })
+    with caplog.at_level("INFO"):
+        alerts = runner_health.run_health_check(
+            make_config(tmp_path, health_alert_repo=""), run_command=fake,
+        )
+    assert alerts == []
+    assert "health_degraded check=crash_loop" in caplog.text
+    assert fake.commands("gh issue") == []
+    assert fake.commands("remote get-url origin") == []
+
+
+def test_stale_pickup_empty_health_alert_repo_detects_without_filing(
+    tmp_path, caplog,
+):
+    """Issue #1985: a stale pickup with `health_alert_repo = ""` is still
+    detected (the ready-queue probe on the delivery repo stays) and
+    journaled, but no alert-repository lookup and no alert Issue happen."""
+    write_state(tmp_path, {"runs": [],
+                           "last_pickup_ts": time.time() - 48 * 3600,
+                           "alerted": []})
+    fake = FakeRunCommand({
+        "journalctl --user -u orbi@1.service": "",
+        "journalctl --user -u orbi@2.service": "",
+        "--label ai-ready": json.dumps([{"number": 7}]),
+    })
+    with caplog.at_level("INFO"):
+        alerts = runner_health.run_health_check(
+            make_config(tmp_path, health_alert_repo=""), run_command=fake,
+        )
+    assert alerts == []
+    assert "health_degraded check=stale_pickup" in caplog.text
+    # The detection probe stays: the ai-ready queue on the delivery repo.
+    assert len(fake.commands("--label ai-ready")) == 1
+    assert fake.commands("gh issue create") == []
+    assert fake.commands("remote get-url origin") == []
+
+
 def test_undeterminable_alert_repo_skips_the_issue(tmp_path, caplog):
     """Issue #345: when the orbi repo cannot be determined the alert is
     skipped (bypass) — never filed in the delivery repo, never guessed."""