boost-skill-cli 1.0.138__tar.gz → 1.0.140__tar.gz

{boost_skill_cli-1.0.138 → boost_skill_cli-1.0.140}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.0.138
+Version: 1.0.140
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License: GNU GENERAL PUBLIC LICENSE

{boost_skill_cli-1.0.138 → boost_skill_cli-1.0.140}/boost_cli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.0.138'
-__version_tuple__ = version_tuple = (1, 0, 138)
+__version__ = version = '1.0.140'
+__version_tuple__ = version_tuple = (1, 0, 140)
 
 __commit_id__ = commit_id = None

{boost_skill_cli-1.0.138 → boost_skill_cli-1.0.140}/boost_cli/cli.py

@@ -14,6 +14,7 @@ from typing import List
 
 from . import PRODUCT, TAGLINE, __version__
 from .core import logs
+from .core import nethttp
 from .core import output as out
 from .errors import BoostError
 
@@ -223,6 +224,11 @@ def _extract_globals(argv: List[str]) -> tuple[dict, List[str]]:
 
 def main(argv: List[str] | None = None) -> int:
     argv = list(sys.argv[1:] if argv is None else argv)
+    # Belt-and-suspenders fork safety: a host may fork() into `boost mcp
+    # --stdio` without the no_proxy env boost injects at registration, leaving
+    # the process one default getproxies() away from a macOS _scproxy SIGABRT.
+    # Seed the guard for every invocation before any code path can trip it.
+    nethttp.harden_fork_safety()
     opts, argv = _extract_globals(argv)
     logs.configure(verbose=opts["verbose"], debug=opts["debug"],
                    quiet=opts["quiet"])

{boost_skill_cli-1.0.138 → boost_skill_cli-1.0.140}/boost_cli/core/nethttp.py

@@ -15,12 +15,39 @@ fork-safe while still honoring ``HTTP(S)_PROXY`` and ``NO_PROXY``.
 """
 from __future__ import annotations
 
+import os
 import urllib.request
 from typing import Union
 
 _Request = Union[str, urllib.request.Request]
 
 
+def harden_fork_safety() -> bool:
+    """Neutralize the macOS Obj-C fork-safety abort for *this whole process*.
+
+    :func:`build_opener` keeps boost's own requests off the fork-unsafe
+    ``getproxies()`` sysconf path, but that only covers calls that go through
+    this module. A host that ``fork()``s into ``boost mcp --stdio`` from a
+    stale or hand-written config (one that lacks the ``no_proxy=*`` launch env
+    boost injects at registration), or any stray *default*-opener call inside
+    the process, can still reach ``getproxies_macosx_sysconf()`` → ``_scproxy``
+    and ``SIGABRT`` on the child side of a fork.
+
+    Seed ``no_proxy`` so the stdlib default ``getproxies()`` short-circuits on
+    ``getproxies_environment()`` and never consults SystemConfiguration — but
+    only when the user has configured *no* proxy at all, so a real
+    ``HTTP(S)_PROXY`` is never clobbered (in that case ``getproxies_environment``
+    already wins and the sysconf branch is unreachable anyway). Idempotent.
+
+    Returns ``True`` when it installed the guard, ``False`` when it left the
+    environment untouched (a proxy was already configured).
+    """
+    if urllib.request.getproxies_environment():
+        return False  # user has a proxy set — respect it, and sysconf is unreached
+    os.environ.setdefault("no_proxy", "*")
+    return True
+
+
 def build_opener() -> urllib.request.OpenerDirector:
     """Build an opener whose proxy config comes only from the environment.
 

{boost_skill_cli-1.0.138 → boost_skill_cli-1.0.140}/boost_skill_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boost-skill-cli
-Version: 1.0.138
+Version: 1.0.140
 Summary: boost — Homebrew for AI coding skills
 Author: Jonathan Reyes
 License: GNU GENERAL PUBLIC LICENSE

{boost_skill_cli-1.0.138 → boost_skill_cli-1.0.140}/boost_skill_cli.egg-info/SOURCES.txt

@@ -152,6 +152,7 @@ docs/roadmap/items/markdown-consistency-markdownlint-cli2.md
 docs/roadmap/items/mcp-hub-diagram-node-text-overflow.md
 docs/roadmap/items/mcp-launch-objc-fork-safety.md
 docs/roadmap/items/mcp-register-names-server-before-env.md
+docs/roadmap/items/mcp-startup-self-harden-fork-safety.md
 docs/roadmap/items/memoize-config-load-in-process.md
 docs/roadmap/items/modernization-smells-refurb-pyupgrade.md
 docs/roadmap/items/mutation-hardening-core-frontmatter-py.md

boost_skill_cli-1.0.140/docs/roadmap/items/mcp-startup-self-harden-fork-safety.md

@@ -0,0 +1,29 @@
+---
+id: mcp-startup-self-harden-fork-safety
+board: code
+section: compat
+status: shipped
+category: Compatibility · macOS
+complexity: S
+impact: Med
+wow: 3
+note: self-seed no_proxy at startup
+order: 9
+owner: loop/mcp-startup-fork-safety
+pr: 162
+title: Self-harden every boost process against the macOS fork-safety abort
+---
+The launch-env fix (<a href="#mcp-launch-objc-fork-safety">#119</a>) only
+           protects hosts that register boost <em>through boost</em>, which
+           injects <code>no_proxy=*</code>. A host that <code>fork()</code>s into
+           <code>boost mcp --stdio</code> from a stale or hand-written config —
+           or any stray default-opener call inside the process — is still one
+           <code>getproxies()</code> away from the macOS <code>_scproxy</code>
+           Obj-C <code>SIGABRT</code>. Close the gap from inside: at the top of
+           <code>main()</code>, seed <code>no_proxy</code> for the current
+           process (only when no <code>*_proxy</code> env is already set, so a
+           real proxy is never clobbered) so the stdlib default
+           <code>getproxies()</code> short-circuits on
+           <code>getproxies_environment()</code> and never consults
+           SystemConfiguration. Belt-and-suspenders atop the
+           <code>nethttp</code> opener (<a href="#fork-safe-network-proxy-handler">#115</a>).

{boost_skill_cli-1.0.138 → boost_skill_cli-1.0.140}/docs/roadmap.html

@@ -118,7 +118,7 @@
       <div class="stat"><b>16</b><span>Shipped</span></div>
       <div class="stat"><b>1</b><span>Next up</span></div>
       <div class="stat"><b>4</b><span>Planned</span></div>
-      <div class="stat"><b>101</b><span>Loop finds</span></div>
+      <div class="stat"><b>102</b><span>Loop finds</span></div>
       <!-- /ROADMAP:stats -->
     </div>
   </section>
@@ -1785,6 +1785,31 @@ and the work stays visible.</p>
         </div>
       </article>
 
+      <article class="cap rcard">
+        <div class="head"><span class="pill shipped">Shipped</span><span class="cat">Compatibility · macOS</span></div>
+        <h3>Self-harden every boost process against the macOS fork-safety abort</h3>
+        <p>The launch-env fix (<a href="#mcp-launch-objc-fork-safety">#119</a>) only
+           protects hosts that register boost <em>through boost</em>, which
+           injects <code>no_proxy=*</code>. A host that <code>fork()</code>s into
+           <code>boost mcp --stdio</code> from a stale or hand-written config —
+           or any stray default-opener call inside the process — is still one
+           <code>getproxies()</code> away from the macOS <code>_scproxy</code>
+           Obj-C <code>SIGABRT</code>. Close the gap from inside: at the top of
+           <code>main()</code>, seed <code>no_proxy</code> for the current
+           process (only when no <code>*_proxy</code> env is already set, so a
+           real proxy is never clobbered) so the stdlib default
+           <code>getproxies()</code> short-circuits on
+           <code>getproxies_environment()</code> and never consults
+           SystemConfiguration. Belt-and-suspenders atop the
+           <code>nethttp</code> opener (<a href="#fork-safe-network-proxy-handler">#115</a>).</p>
+        <div class="meta">
+          <span class="m">Complexity <b>S</b></span>
+          <span class="m">Impact <b>Med</b></span>
+          <span class="m">Wow <b class="wow">★★★</b></span>
+          <span class="m">self-seed no_proxy at startup</span>
+        </div>
+      </article>
+
       <article class="cap rcard">
         <div class="head"><span class="pill shipped">Shipped</span><span class="cat">Bug · MCP</span></div>
         <h3>Order the server name before -e flags in `boost mcp register`</h3>

{boost_skill_cli-1.0.138 → boost_skill_cli-1.0.140}/tests/unit/test_nethttp.py

@@ -5,6 +5,7 @@ The whole point of the module is to keep proxy resolution on the pure-env
 (``getproxies()`` / ``getproxies_macosx_sysconf()``), which aborts on the child
 side of a ``fork()``. These tests pin that contract.
 """
+import os
 import urllib.request
 
 import pytest
@@ -83,3 +84,37 @@ class TestUrlopen:
     def test_timeout_is_required(self):
         with pytest.raises(TypeError):
             nethttp.urlopen("http://x.invalid")  # type: ignore[call-arg]
+
+
+class TestHardenForkSafety:
+    def test_seeds_no_proxy_when_no_env_proxy(self, monkeypatch):
+        # No *_proxy vars configured -> the default getproxies() would fall
+        # through to the fork-unsafe macOS sysconf path. harden seeds no_proxy
+        # so getproxies_environment() wins instead.
+        monkeypatch.setattr(urllib.request, "getproxies_environment", dict)
+        monkeypatch.delenv("no_proxy", raising=False)
+        assert nethttp.harden_fork_safety() is True
+        assert os.environ["no_proxy"] == "*"
+
+    def test_respects_existing_proxy_config(self, monkeypatch):
+        # A real proxy is set -> getproxies_environment() already wins and the
+        # sysconf branch is unreachable, so harden must not touch the env.
+        monkeypatch.setattr(urllib.request, "getproxies_environment",
+                            lambda: {"https": "http://proxy.example:8080"})
+        monkeypatch.delenv("no_proxy", raising=False)
+        assert nethttp.harden_fork_safety() is False
+        assert "no_proxy" not in os.environ
+
+    def test_does_not_clobber_existing_no_proxy(self, monkeypatch):
+        # setdefault semantics: a user's own no_proxy value survives untouched.
+        monkeypatch.setattr(urllib.request, "getproxies_environment", dict)
+        monkeypatch.setenv("no_proxy", "example.com")
+        assert nethttp.harden_fork_safety() is True
+        assert os.environ["no_proxy"] == "example.com"
+
+    def test_idempotent(self, monkeypatch):
+        monkeypatch.setattr(urllib.request, "getproxies_environment", dict)
+        monkeypatch.delenv("no_proxy", raising=False)
+        assert nethttp.harden_fork_safety() is True
+        assert nethttp.harden_fork_safety() is True
+        assert os.environ["no_proxy"] == "*"