factorly 0.18.1__tar.gz → 0.20.0__tar.gz

{factorly-0.18.1 → factorly-0.20.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: factorly
-Version: 0.18.1
+Version: 0.20.0
 Summary: Security and governance layer for AI agent tool access
 License: GPL-3.0
 Project-URL: Homepage, https://github.com/factorly-dev/factorly

{factorly-0.18.1 → factorly-0.20.0}/factorly/__init__.py

@@ -3,4 +3,4 @@
 
 """Factorly — security and governance layer for AI agent tool access."""
 
-__version__ = "0.18.1"
+__version__ = "0.20.0"

factorly-0.20.0/factorly/cli.py

@@ -0,0 +1,182 @@
+# Copyright 2026 Jordan Sherer <hi@jordansherer.com>
+# SPDX-License-Identifier: gpl
+
+"""Factorly CLI wrapper — downloads and runs the Go binary."""
+
+import hashlib
+import os
+import platform
+import stat
+import subprocess
+import sys
+import urllib.request
+
+from factorly import __version__
+
+REPO = "factorly-dev/factorly"
+
+PLATFORM_MAP = {
+    "Darwin": "darwin",
+    "Linux": "linux",
+    "Windows": "windows",
+}
+
+ARCH_MAP = {
+    "x86_64": "amd64",
+    "AMD64": "amd64",
+    "aarch64": "arm64",
+    "arm64": "arm64",
+}
+
+
+def get_bin_dir():
+    """Return the directory where the binary is stored."""
+    return os.path.join(os.path.dirname(os.path.abspath(__file__)), "bin")
+
+
+def get_binary_path():
+    """Return the full path to the factorly binary."""
+    ext = ".exe" if platform.system() == "Windows" else ""
+    return os.path.join(get_bin_dir(), f"factorly{ext}")
+
+
+def get_binary_name():
+    """Return the platform-specific binary name for download."""
+    plat = PLATFORM_MAP.get(platform.system())
+    arch = ARCH_MAP.get(platform.machine())
+
+    if not plat:
+        print(f"Unsupported platform: {platform.system()}", file=sys.stderr)
+        sys.exit(1)
+    if not arch:
+        print(f"Unsupported architecture: {platform.machine()}", file=sys.stderr)
+        sys.exit(1)
+
+    ext = ".exe" if platform.system() == "Windows" else ""
+    return f"factorly-{__version__}-{plat}-{arch}{ext}"
+
+
+def is_installed():
+    """Check if the correct version is already installed."""
+    binary = get_binary_path()
+    if not os.path.exists(binary):
+        return False
+    try:
+        # The probe runs on every launch; keep the binary's own daily
+        # update check out of it so the probe can't block on the network.
+        env = dict(os.environ, FACTORLY_NO_UPDATE_CHECK="1")
+        result = subprocess.run(
+            [binary, "version"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+            env=env,
+        )
+        return __version__ in result.stdout
+    except Exception:
+        return False
+
+
+def expected_checksum(checksums_text, binary_name):
+    """Return the sha256 listed for binary_name in a checksums.txt body
+    (``<hex>  <name>`` per line, as sha256sum writes it), or None."""
+    for line in checksums_text.splitlines():
+        parts = line.split()
+        if len(parts) >= 2 and parts[-1] == binary_name:
+            return parts[0].lower()
+    return None
+
+
+def verify_checksum(data, checksums_text, binary_name):
+    """Raise ValueError if data's sha256 does not match the published one.
+    A checksums file that does not list the binary is also an error."""
+    want = expected_checksum(checksums_text, binary_name)
+    if want is None:
+        raise ValueError(f"{binary_name} is not listed in checksums.txt")
+    got = hashlib.sha256(data).hexdigest()
+    if got != want:
+        raise ValueError(f"sha256 mismatch for {binary_name}: got {got}, expected {want}")
+
+
+def _fetch(url):
+    req = urllib.request.Request(url, headers={"User-Agent": "factorly-pip-installer"})
+    with urllib.request.urlopen(req) as response:
+        return response.read()
+
+
+def download_binary():
+    """Download the factorly binary from GitHub Releases and verify it
+    against the release's checksums.txt."""
+    binary_name = get_binary_name()
+    base = f"https://github.com/{REPO}/releases/download/v{__version__}"
+    url = f"{base}/{binary_name}"
+
+    # Everything the wrapper says goes to stderr: on a first launch the
+    # command may be `factorly serve`, whose stdout is an MCP client's
+    # JSON-RPC stream.
+    log = lambda msg: print(msg, file=sys.stderr)
+    log(f"Downloading factorly {__version__} for {platform.system()}/{platform.machine()}...")
+    log(f"  {url}")
+
+    bin_dir = get_bin_dir()
+    os.makedirs(bin_dir, exist_ok=True)
+    binary_path = get_binary_path()
+
+    try:
+        data = _fetch(url)
+    except urllib.error.HTTPError as e:
+        log(f"Download failed: HTTP {e.code}")
+        log("")
+        log("Install manually from:")
+        log(f"  https://github.com/{REPO}/releases/tag/v{__version__}")
+        sys.exit(1)
+    except Exception as e:
+        log(f"Download failed: {e}")
+        sys.exit(1)
+
+    # Verify against the release's checksums.txt. A release without one
+    # cannot be verified and says so; a mismatch is a hard stop.
+    try:
+        checksums = _fetch(f"{base}/checksums.txt").decode("utf-8", "replace")
+    except urllib.error.HTTPError as e:
+        log(f"warning: checksums.txt not available for v{__version__} (HTTP {e.code}); binary not verified")
+        checksums = None
+    except Exception as e:
+        log(f"warning: could not fetch checksums.txt ({e}); binary not verified")
+        checksums = None
+    if checksums is not None:
+        try:
+            verify_checksum(data, checksums, binary_name)
+        except ValueError as e:
+            log(f"Download rejected: {e}")
+            sys.exit(1)
+        log("  sha256 verified")
+
+    with open(binary_path, "wb") as f:
+        f.write(data)
+
+    # Make executable
+    if platform.system() != "Windows":
+        st = os.stat(binary_path)
+        os.chmod(binary_path, st.st_mode | stat.S_IEXEC | stat.S_IXGRP | stat.S_IXOTH)
+
+    log(f"Installed factorly to {binary_path}")
+
+
+def main():
+    """Entry point: ensure binary exists, then run it."""
+    if not is_installed():
+        download_binary()
+
+    binary = get_binary_path()
+    if not os.path.exists(binary):
+        print("factorly binary not found after download attempt.", file=sys.stderr)
+        print("Run: pip install --force-reinstall factorly", file=sys.stderr)
+        sys.exit(127)
+
+    result = subprocess.run([binary] + sys.argv[1:])
+    sys.exit(result.returncode)
+
+
+if __name__ == "__main__":
+    main()

{factorly-0.18.1 → factorly-0.20.0}/factorly.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: factorly
-Version: 0.18.1
+Version: 0.20.0
 Summary: Security and governance layer for AI agent tool access
 License: GPL-3.0
 Project-URL: Homepage, https://github.com/factorly-dev/factorly

{factorly-0.18.1 → factorly-0.20.0}/factorly.egg-info/SOURCES.txt

@@ -7,4 +7,5 @@ factorly.egg-info/PKG-INFO
 factorly.egg-info/SOURCES.txt
 factorly.egg-info/dependency_links.txt
 factorly.egg-info/entry_points.txt
-factorly.egg-info/top_level.txt
+factorly.egg-info/top_level.txt
+tests/test_cli.py

{factorly-0.18.1 → factorly-0.20.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "factorly"
-version = "0.18.1"
+version = "0.20.0"
 description = "Security and governance layer for AI agent tool access"
 readme = "README.md"
 license = {text = "GPL-3.0"}

factorly-0.20.0/tests/test_cli.py

@@ -0,0 +1,36 @@
+# Copyright 2026 Jordan Sherer <hi@jordansherer.com>
+# SPDX-License-Identifier: gpl
+
+import hashlib
+import unittest
+
+from factorly.cli import expected_checksum, verify_checksum
+
+
+class ChecksumTests(unittest.TestCase):
+    def setUp(self):
+        self.data = b"binary bytes"
+        self.digest = hashlib.sha256(self.data).hexdigest()
+        self.text = (
+            f"{self.digest}  factorly-0.1.0-linux-amd64\n"
+            "deadbeef  factorly-0.1.0-darwin-arm64\n"
+        )
+
+    def test_expected_checksum_finds_binary(self):
+        self.assertEqual(expected_checksum(self.text, "factorly-0.1.0-linux-amd64"), self.digest)
+        self.assertIsNone(expected_checksum(self.text, "factorly-0.1.0-windows-amd64.exe"))
+
+    def test_verify_accepts_matching_digest(self):
+        verify_checksum(self.data, self.text, "factorly-0.1.0-linux-amd64")
+
+    def test_verify_rejects_mismatch(self):
+        with self.assertRaises(ValueError):
+            verify_checksum(b"tampered", self.text, "factorly-0.1.0-linux-amd64")
+
+    def test_verify_rejects_unlisted_binary(self):
+        with self.assertRaises(ValueError):
+            verify_checksum(self.data, self.text, "factorly-0.1.0-windows-amd64.exe")
+
+
+if __name__ == "__main__":
+    unittest.main()

factorly-0.18.1/factorly/cli.py

@@ -1,128 +0,0 @@
-# Copyright 2026 Jordan Sherer <hi@jordansherer.com>
-# SPDX-License-Identifier: gpl
-
-"""Factorly CLI wrapper — downloads and runs the Go binary."""
-
-import os
-import platform
-import stat
-import subprocess
-import sys
-import urllib.request
-
-from factorly import __version__
-
-REPO = "factorly-dev/factorly"
-
-PLATFORM_MAP = {
-    "Darwin": "darwin",
-    "Linux": "linux",
-    "Windows": "windows",
-}
-
-ARCH_MAP = {
-    "x86_64": "amd64",
-    "AMD64": "amd64",
-    "aarch64": "arm64",
-    "arm64": "arm64",
-}
-
-
-def get_bin_dir():
-    """Return the directory where the binary is stored."""
-    return os.path.join(os.path.dirname(os.path.abspath(__file__)), "bin")
-
-
-def get_binary_path():
-    """Return the full path to the factorly binary."""
-    ext = ".exe" if platform.system() == "Windows" else ""
-    return os.path.join(get_bin_dir(), f"factorly{ext}")
-
-
-def get_binary_name():
-    """Return the platform-specific binary name for download."""
-    plat = PLATFORM_MAP.get(platform.system())
-    arch = ARCH_MAP.get(platform.machine())
-
-    if not plat:
-        print(f"Unsupported platform: {platform.system()}", file=sys.stderr)
-        sys.exit(1)
-    if not arch:
-        print(f"Unsupported architecture: {platform.machine()}", file=sys.stderr)
-        sys.exit(1)
-
-    ext = ".exe" if platform.system() == "Windows" else ""
-    return f"factorly-{__version__}-{plat}-{arch}{ext}"
-
-
-def is_installed():
-    """Check if the correct version is already installed."""
-    binary = get_binary_path()
-    if not os.path.exists(binary):
-        return False
-    try:
-        result = subprocess.run(
-            [binary, "version"],
-            capture_output=True,
-            text=True,
-            timeout=5,
-        )
-        return __version__ in result.stdout
-    except Exception:
-        return False
-
-
-def download_binary():
-    """Download the factorly binary from GitHub Releases."""
-    binary_name = get_binary_name()
-    url = f"https://github.com/{REPO}/releases/download/v{__version__}/{binary_name}"
-
-    print(f"Downloading factorly {__version__} for {platform.system()}/{platform.machine()}...")
-    print(f"  {url}")
-
-    bin_dir = get_bin_dir()
-    os.makedirs(bin_dir, exist_ok=True)
-    binary_path = get_binary_path()
-
-    try:
-        req = urllib.request.Request(url, headers={"User-Agent": "factorly-pip-installer"})
-        with urllib.request.urlopen(req) as response:
-            data = response.read()
-    except urllib.error.HTTPError as e:
-        print(f"Download failed: HTTP {e.code}", file=sys.stderr)
-        print(f"", file=sys.stderr)
-        print(f"Install manually from:", file=sys.stderr)
-        print(f"  https://github.com/{REPO}/releases/tag/v{__version__}", file=sys.stderr)
-        sys.exit(1)
-    except Exception as e:
-        print(f"Download failed: {e}", file=sys.stderr)
-        sys.exit(1)
-
-    with open(binary_path, "wb") as f:
-        f.write(data)
-
-    # Make executable
-    if platform.system() != "Windows":
-        st = os.stat(binary_path)
-        os.chmod(binary_path, st.st_mode | stat.S_IEXEC | stat.S_IXGRP | stat.S_IXOTH)
-
-    print(f"Installed factorly to {binary_path}")
-
-
-def main():
-    """Entry point: ensure binary exists, then run it."""
-    if not is_installed():
-        download_binary()
-
-    binary = get_binary_path()
-    if not os.path.exists(binary):
-        print("factorly binary not found after download attempt.", file=sys.stderr)
-        print("Run: pip install --force-reinstall factorly", file=sys.stderr)
-        sys.exit(127)
-
-    result = subprocess.run([binary] + sys.argv[1:])
-    sys.exit(result.returncode)
-
-
-if __name__ == "__main__":
-    main()