codebase-memory-mcp 0.12.0__tar.gz → 0.12.1__tar.gz

{codebase_memory_mcp-0.12.0 → codebase_memory_mcp-0.12.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codebase-memory-mcp
-Version: 0.12.0
+Version: 0.12.1
 Summary: Fast code intelligence for AI coding agents — installs a verified native runtime set
 Project-URL: Homepage, https://github.com/DeusData/codebase-memory-mcp
 Project-URL: Repository, https://github.com/DeusData/codebase-memory-mcp
@@ -38,6 +38,8 @@ pipx install codebase-memory-mcp
 
 There is one composition per platform: the graph UI ships in every build, so no variant selection is needed.
 
+For testing, `CBM_DOWNLOAD_URL` overrides the download base URL (default `https://github.com/DeusData/codebase-memory-mcp/releases/download/v<version>`): the archive and `checksums.txt` are fetched from `<CBM_DOWNLOAD_URL>/<file>`. It must be `https://`, or plain `http://` to exactly `localhost`, `127.0.0.1`, or `[::1]` (optional port; no proxy, no redirects).
+
 ## Usage
 
 ```bash

{codebase_memory_mcp-0.12.0 → codebase_memory_mcp-0.12.1}/README.md

@@ -16,6 +16,8 @@ pipx install codebase-memory-mcp
 
 There is one composition per platform: the graph UI ships in every build, so no variant selection is needed.
 
+For testing, `CBM_DOWNLOAD_URL` overrides the download base URL (default `https://github.com/DeusData/codebase-memory-mcp/releases/download/v<version>`): the archive and `checksums.txt` are fetched from `<CBM_DOWNLOAD_URL>/<file>`. It must be `https://`, or plain `http://` to exactly `localhost`, `127.0.0.1`, or `[::1]` (optional port; no proxy, no redirects).
+
 ## Usage
 
 ```bash

{codebase_memory_mcp-0.12.0 → codebase_memory_mcp-0.12.1}/pyproject.toml

@@ -8,7 +8,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "codebase-memory-mcp"
-version = "0.12.0"
+version = "0.12.1"
 description = "Fast code intelligence for AI coding agents — installs a verified native runtime set"
 readme = "README.md"
 license = { text = "MIT" }

{codebase_memory_mcp-0.12.0 → codebase_memory_mcp-0.12.1}/src/codebase_memory_mcp/_cli.py

@@ -1,6 +1,5 @@
 """Downloads codebase-memory-mcp on first run, then runs its native entry point."""
 
-import collections
 import errno
 import hashlib
 import json
@@ -39,26 +38,19 @@ _WINDOWS_ARCHIVE_NAMES = (
 # file://, ftp://, and custom schemes — a redirect or tainted URL source
 # could otherwise turn a download into an arbitrary-local-file read.
 _ALLOWED_SCHEMES = frozenset({"https"})
+# install.sh's loopback pattern: plain HTTP only to an exact loopback
+# authority, for local smoke tests (CBM_DOWNLOAD_URL).
+_LOOPBACK_HTTP_URL = re.compile(
+    r"http://(localhost|127\.0\.0\.1|\[::1\])(:[0-9]+)?([/?#].*)?"
+)
+_LOOPBACK_HOSTNAMES = frozenset({"localhost", "127.0.0.1", "::1"})
 _MAX_REDIRECTS = 5
 _NETWORK_TIMEOUT_SECONDS = 120
 _CANDIDATE_TIMEOUT_SECONDS = 15
-_MAX_CHECKSUM_MANIFEST_BYTES = 1024 * 1024
-# Release archive resource limits. Keep in sync with the Go wrapper
-# (pkg/go/cmd/codebase-memory-mcp/main.go) and the npm wrapper (install.js).
-_MAX_RELEASE_ARCHIVE_BYTES = 256 * 1024 * 1024
+# Entry-count guard for the archive namespace check. Keep in sync with the
+# Go wrapper (pkg/go/cmd/codebase-memory-mcp/main.go) and the npm wrapper.
 _MAX_ARCHIVE_MEMBERS = 64
-_MAX_ARCHIVE_MEMBER_BYTES = 256 * 1024 * 1024
-_MAX_ARCHIVE_EXPANDED_BYTES = 512 * 1024 * 1024
 _ARCHIVE_COPY_CHUNK_BYTES = 64 * 1024
-_ArchiveLimits = collections.namedtuple(
-    "_ArchiveLimits", "compressed_bytes members member_bytes expanded_bytes"
-)
-_DEFAULT_ARCHIVE_LIMITS = _ArchiveLimits(
-    compressed_bytes=_MAX_RELEASE_ARCHIVE_BYTES,
-    members=_MAX_ARCHIVE_MEMBERS,
-    member_bytes=_MAX_ARCHIVE_MEMBER_BYTES,
-    expanded_bytes=_MAX_ARCHIVE_EXPANDED_BYTES,
-)
 _REDIRECT_CODES = frozenset({301, 302, 303, 307, 308})
 _RUNTIME_LOCK_NAME = ".codebase-memory-mcp-runtime.lock"
 _RUNTIME_LOCK_WAIT_SECONDS = 45
@@ -79,13 +71,50 @@ _runtime_lock_claim_observer = None
 
 
 class _NoRedirectHandler(urllib.request.HTTPRedirectHandler):
-    """Expose redirects to _download_https for explicit per-hop validation."""
+    """Expose redirects to _download_file for explicit per-hop validation."""
 
     def redirect_request(self, req, fp, code, msg, headers, newurl):
         return None
 
 
 _HTTPS_OPENER = urllib.request.build_opener(_NoRedirectHandler())
+# A loopback fetch never goes through a proxy.
+_LOOPBACK_OPENER = urllib.request.build_opener(
+    urllib.request.ProxyHandler({}), _NoRedirectHandler()
+)
+
+
+def _download_base(version: str, environ=None):
+    """Return (base, loopback) for release downloads.
+
+    CBM_DOWNLOAD_URL replaces the release download base (for testing), with
+    install.sh's policy: HTTPS, or plain HTTP to an exact loopback authority.
+    """
+    env = os.environ if environ is None else environ
+    override = env.get("CBM_DOWNLOAD_URL")
+    if not override:
+        return f"https://github.com/{REPO}/releases/download/v{version}", False
+    if override.startswith("https://"):
+        return override, False
+    if _LOOPBACK_HTTP_URL.fullmatch(override):
+        return override, True
+    sys.exit(
+        f"codebase-memory-mcp: refusing non-HTTPS download URL "
+        f"(CBM_DOWNLOAD_URL): {override}"
+    )
+
+
+def _validate_loopback_url(url: str) -> None:
+    """Reject anything but plain HTTP to an exact loopback authority."""
+    parsed = urllib.parse.urlparse(url)
+    if (
+        not _LOOPBACK_HTTP_URL.fullmatch(url)
+        or parsed.scheme != "http"
+        or parsed.hostname not in _LOOPBACK_HOSTNAMES
+        or parsed.username is not None
+        or parsed.password is not None
+    ):
+        sys.exit(f"codebase-memory-mcp: refusing non-loopback HTTP URL: {url}")
 
 
 def _validate_url_scheme(url: str) -> None:
@@ -103,23 +132,33 @@ def _validate_url_scheme(url: str) -> None:
         )
 
 
-def _download_https(url: str, dest: str, max_bytes: int = 0) -> None:
-    """Download through a bounded HTTPS-only opener into dest."""
+def _validate_download_url(url: str, loopback: bool) -> None:
+    if loopback:
+        _validate_loopback_url(url)
+    else:
+        _validate_url_scheme(url)
+
+
+def _download_file(url: str, dest: str, loopback: bool = False) -> None:
+    """Download into dest: HTTPS with checked redirects, or one loopback hop."""
+    opener = _LOOPBACK_OPENER if loopback else _HTTPS_OPENER
     current_url = url
     for redirect_count in range(_MAX_REDIRECTS + 1):
-        _validate_url_scheme(current_url)
+        _validate_download_url(current_url, loopback)
         request = urllib.request.Request(
             current_url, headers={"User-Agent": "codebase-memory-mcp-installer"}
         )
         try:
-            response = _HTTPS_OPENER.open(
-                request, timeout=_NETWORK_TIMEOUT_SECONDS
-            )
+            response = opener.open(request, timeout=_NETWORK_TIMEOUT_SECONDS)
         except urllib.error.HTTPError as exc:
             if exc.code not in _REDIRECT_CODES:
                 raise
             location = exc.headers.get("Location")
             exc.close()
+            if loopback:
+                raise RuntimeError(
+                    f"refusing redirect from loopback download: {current_url}"
+                )
             if not location:
                 raise RuntimeError(f"redirect has no Location: {current_url}")
             if redirect_count == _MAX_REDIRECTS:
@@ -129,18 +168,8 @@ def _download_https(url: str, dest: str, max_bytes: int = 0) -> None:
             continue
 
         with response:
-            _validate_url_scheme(response.geturl())
-            declared = (response.headers.get("Content-Length") or "").strip()
-            # Only plain ASCII digits are a length (str.isdigit also accepts
-            # characters that int() rejects); anything else is left to the
-            # byte counter below.
-            if max_bytes and re.fullmatch(r"[0-9]+", declared):
-                if int(declared) > max_bytes:
-                    raise RuntimeError(
-                        f"download exceeds the {max_bytes}-byte safety limit"
-                    )
+            _validate_download_url(response.geturl(), loopback)
             deadline = time.monotonic() + _NETWORK_TIMEOUT_SECONDS
-            total = 0
             try:
                 with open(dest, "wb") as out:
                     while True:
@@ -151,12 +180,6 @@ def _download_https(url: str, dest: str, max_bytes: int = 0) -> None:
                         chunk = response.read(65536)
                         if not chunk:
                             return
-                        total += len(chunk)
-                        if max_bytes and total > max_bytes:
-                            raise RuntimeError(
-                                f"download exceeds the {max_bytes}-byte "
-                                f"safety limit"
-                            )
                         out.write(chunk)
             except BaseException:
                 # Never leave a partial download behind for a later step to
@@ -236,106 +259,51 @@ def _validate_archive_names(names, archive_names, casefold: bool = False):
         )
 
 
-def _validate_archive_limits(limits) -> None:
-    if (
-        limits.compressed_bytes <= 0
-        or limits.members <= 0
-        or limits.member_bytes <= 0
-        or limits.expanded_bytes <= 0
-    ):
-        sys.exit("codebase-memory-mcp: invalid archive resource safety limits")
-
-
-def _require_compressed_archive_within_limit(archive_path: str, limits) -> None:
-    status = os.stat(archive_path)
-    if not stat.S_ISREG(status.st_mode):
+def _require_regular_archive(archive_path: str) -> None:
+    if not stat.S_ISREG(os.stat(archive_path).st_mode):
         sys.exit("codebase-memory-mcp: release archive is not a regular file")
-    if status.st_size > limits.compressed_bytes:
-        sys.exit(
-            f"codebase-memory-mcp: release archive exceeds the "
-            f"{limits.compressed_bytes}-byte compressed safety limit"
-        )
 
 
-def _require_member_count_within_limit(count: int, limits) -> None:
-    if count > limits.members:
+def _require_member_count_within_limit(count: int, max_members: int) -> None:
+    if count > max_members:
         sys.exit(
-            f"codebase-memory-mcp: archive exceeds the {limits.members}-member "
+            f"codebase-memory-mcp: archive exceeds the {max_members}-member "
             f"safety limit"
         )
 
 
-def _account_declared_archive_member(
-    name: str, size: int, declared_expanded: int, limits
-) -> int:
-    """Check one member's declared size; return the new declared total."""
+def _require_declared_size(name: str, size: int) -> None:
     if size < 0:
         sys.exit(
             f"codebase-memory-mcp: archive member has a negative declared "
             f"size: {name!r}"
         )
-    if size > limits.member_bytes:
-        sys.exit(
-            f"codebase-memory-mcp: archive member {name!r} exceeds the "
-            f"{limits.member_bytes}-byte expanded safety limit"
-        )
-    if declared_expanded > limits.expanded_bytes - size:
-        sys.exit(
-            f"codebase-memory-mcp: archive exceeds the {limits.expanded_bytes}-byte "
-            f"aggregate expanded safety limit"
-        )
-    return declared_expanded + size
 
 
-def _copy_archive_member_within_limits(
-    source, output, name: str, declared_size: int, actual_expanded: int, limits
-) -> int:
-    """Copy a member while counting bytes; return the new actual total.
+def _copy_archive_member(source, output, name: str, declared_size: int) -> int:
+    """Copy a member, then require the declared size; return the bytes copied.
 
-    Reads stop one byte past the smaller of the member and remaining aggregate
-    limits, so a member that yields more than it declares can never fill the
-    disk. The caller removes the target on failure.
+    The caller removes the target on failure.
     """
-    remaining = limits.expanded_bytes - actual_expanded
-    copy_limit = min(limits.member_bytes, remaining)
     copied = 0
     while True:
-        wanted = min(_ARCHIVE_COPY_CHUNK_BYTES, copy_limit + 1 - copied)
-        if wanted <= 0:
-            break
-        chunk = source.read(wanted)
+        chunk = source.read(_ARCHIVE_COPY_CHUNK_BYTES)
         if not chunk:
             break
         copied += len(chunk)
-        if copied > copy_limit:
-            break
         output.write(chunk)
-    if copied > limits.member_bytes:
-        sys.exit(
-            f"codebase-memory-mcp: archive member {name!r} exceeds the "
-            f"{limits.member_bytes}-byte actual expanded safety limit"
-        )
-    if copied > remaining:
-        sys.exit(
-            f"codebase-memory-mcp: archive exceeds the {limits.expanded_bytes}-byte "
-            f"aggregate actual expanded safety limit"
-        )
     if copied != declared_size:
         sys.exit(
             f"codebase-memory-mcp: archive member {name!r} actual size {copied} "
             f"does not match declared size {declared_size}"
         )
-    return actual_expanded + copied
+    return copied
 
 
-def _write_archive_member_within_limits(
-    source, target: str, name: str, declared_size: int, actual_expanded: int, limits
-) -> int:
+def _write_archive_member(source, target: str, name: str, declared_size: int) -> int:
     try:
         with open(target, "xb") as output:
-            return _copy_archive_member_within_limits(
-                source, output, name, declared_size, actual_expanded, limits
-            )
+            return _copy_archive_member(source, output, name, declared_size)
     except BaseException:
         _remove_quietly(target)
         raise
@@ -347,36 +315,29 @@ def _safe_extract_tar(
     archive_names=(),
     extract_names=(),
     ui: bool = False,
-    limits=_DEFAULT_ARCHIVE_LIMITS,
+    max_members: int = _MAX_ARCHIVE_MEMBERS,
 ):
     """Validate a tar namespace, then extract only its authenticated runtime set."""
-    _validate_archive_limits(limits)
     members = tf.getmembers()
-    _require_member_count_within_limit(len(members), limits)
-    declared_expanded = 0
+    _require_member_count_within_limit(len(members), max_members)
     for member in members:
         if not member.isfile():
             sys.exit(
                 f"codebase-memory-mcp: refusing unsafe tar entry "
                 f"(not a regular root file: {member.name!r})"
             )
-        declared_expanded = _account_declared_archive_member(
-            member.name, member.size, declared_expanded, limits
-        )
+        _require_declared_size(member.name, member.size)
     _validate_archive_names([member.name for member in members], archive_names)
     runtime_names = list(extract_names)
     by_name = {member.name: member for member in members}
     dest_abs = os.path.abspath(dest)
-    actual_expanded = 0
     for name in runtime_names:
         source = tf.extractfile(by_name[name])
         if source is None:
             sys.exit(f"codebase-memory-mcp: could not read archive member: {name}")
         target = os.path.join(dest_abs, name)
         with source:
-            actual_expanded = _write_archive_member_within_limits(
-                source, target, name, by_name[name].size, actual_expanded, limits
-            )
+            _write_archive_member(source, target, name, by_name[name].size)
     return tuple(runtime_names)
 
 
@@ -386,7 +347,7 @@ def _safe_extract_zip(
     archive_names=(),
     extract_names=(),
     ui: bool = False,
-    limits=_DEFAULT_ARCHIVE_LIMITS,
+    max_members: int = _MAX_ARCHIVE_MEMBERS,
 ):
     """Extract a zipfile after validating its Windows-style namespace.
 
@@ -394,16 +355,12 @@ def _safe_extract_zip(
     members before extraction prevents archive order from selecting the binary
     that a portable package-manager shim eventually executes.
     """
-    _validate_archive_limits(limits)
     dest_abs = os.path.abspath(dest)
     names = []
     infos = zf.infolist()
-    _require_member_count_within_limit(len(infos), limits)
-    declared_expanded = 0
+    _require_member_count_within_limit(len(infos), max_members)
     for info in infos:
-        declared_expanded = _account_declared_archive_member(
-            info.filename, info.file_size, declared_expanded, limits
-        )
+        _require_declared_size(info.filename, info.file_size)
         raw_name = info.filename
         name = raw_name.replace("\\", "/")
         segments_name = name[:-1] if name.endswith("/") else name
@@ -437,30 +394,24 @@ def _safe_extract_zip(
     # Extract only the validated runtime files. This avoids relying on
     # platform-specific zip path rewriting and always creates regular files.
     runtime_names = list(extract_names)
-    actual_expanded = 0
     for name in runtime_names:
         target = os.path.join(dest_abs, name)
         with zf.open(name) as source:
-            actual_expanded = _write_archive_member_within_limits(
-                source,
-                target,
-                name,
-                zf.getinfo(name).file_size,
-                actual_expanded,
-                limits,
-            )
+            _write_archive_member(source, target, name, zf.getinfo(name).file_size)
     return tuple(runtime_names)
 
 
-def _verify_checksum(archive_path: str, archive_name: str, version: str) -> None:
-    """Verify SHA256 checksum against checksums.txt from the release."""
-    url = f"https://github.com/{REPO}/releases/download/v{version}/checksums.txt"
+def _verify_checksum(
+    archive_path: str, archive_name: str, base: str, loopback: bool = False
+) -> None:
+    """Verify SHA256 checksum against checksums.txt from the same base."""
+    url = f"{base}/checksums.txt"
     tmp_path = None
     try:
-        _validate_url_scheme(url)
+        _validate_download_url(url, loopback)
         with tempfile.NamedTemporaryFile(suffix=".txt", delete=False) as tmp:
             tmp_path = tmp.name
-        _download_https(url, tmp_path, _MAX_CHECKSUM_MANIFEST_BYTES)
+        _download_file(url, tmp_path, loopback)
         expected = None
         with open(tmp_path, encoding="utf-8") as f:
             for line in f:
@@ -517,7 +468,7 @@ def _version() -> str:
         from importlib.metadata import version
         return version("codebase-memory-mcp")
     except Exception:
-        return "0.11.0"
+        return "0.12.0"
 
 
 def _os_name() -> str:
@@ -1344,8 +1295,9 @@ def _download(version: str) -> Path:
     # have no such variant. Keep in sync with install.sh / install.js / cli.c.
     portable = "-portable" if os_name == "linux" else ""
     archive = f"codebase-memory-mcp-{os_name}-{arch}{portable}.{ext}"
-    url = f"https://github.com/{REPO}/releases/download/v{version}/{archive}"
-    _validate_url_scheme(url)
+    base, loopback = _download_base(version)
+    url = f"{base}/{archive}"
+    _validate_download_url(url, loopback)
 
     dest = _bin_path(version)
     dest.parent.mkdir(parents=True, exist_ok=True)
@@ -1358,7 +1310,7 @@ def _download(version: str) -> Path:
     with tempfile.TemporaryDirectory() as tmp:
         tmp_archive = os.path.join(tmp, f"cbm.{ext}")
         try:
-            _download_https(url, tmp_archive, _MAX_RELEASE_ARCHIVE_BYTES)
+            _download_file(url, tmp_archive, loopback)
         except (OSError, RuntimeError, urllib.error.URLError) as e:
             sys.exit(
                 f"codebase-memory-mcp: download failed ({e})\n"
@@ -1366,10 +1318,8 @@ def _download(version: str) -> Path:
                 f"See https://github.com/{REPO}/releases for available versions."
             )
 
-        _verify_checksum(tmp_archive, archive, version)
-        _require_compressed_archive_within_limit(
-            tmp_archive, _DEFAULT_ARCHIVE_LIMITS
-        )
+        _verify_checksum(tmp_archive, archive, base, loopback)
+        _require_regular_archive(tmp_archive)
 
         bin_name = (
             _WINDOWS_BINARY_NAME if os_name == "windows" else "codebase-memory-mcp"

{codebase_memory_mcp-0.12.0 → codebase_memory_mcp-0.12.1}/tests/test_cli.py

@@ -1,5 +1,7 @@
+import contextlib
 import errno
 import hashlib
+import http.server
 import io
 import json
 import os
@@ -840,9 +842,10 @@ _cli._publish_runtime_set(
 class _FakeHttpsResponse:
     """Minimal stand-in for the opener's response: headers, geturl, read."""
 
-    def __init__(self, body: bytes, headers=None):
+    def __init__(self, body: bytes, headers=None, fail_after_first_chunk=False):
         self._body = body
         self._offset = 0
+        self._fail_after_first_chunk = fail_after_first_chunk
         self.headers = dict(headers or {})
 
     def __enter__(self):
@@ -855,6 +858,8 @@ class _FakeHttpsResponse:
         return "https://example.invalid/release.tar.gz"
 
     def read(self, size=-1):
+        if self._fail_after_first_chunk and self._offset:
+            raise OSError("connection reset")
         if size is None or size < 0:
             size = len(self._body) - self._offset
         chunk = self._body[self._offset : self._offset + size]
@@ -862,8 +867,31 @@ class _FakeHttpsResponse:
         return chunk
 
 
-def _limits_with(**overrides):
-    return _cli._DEFAULT_ARCHIVE_LIMITS._replace(**overrides)
+class _ZeroSource:
+    """Reader that yields `size` zero bytes without holding them."""
+
+    def __init__(self, size: int):
+        self._remaining = size
+
+    def read(self, size=-1):
+        if size is None or size < 0:
+            size = self._remaining
+        count = min(size, self._remaining)
+        self._remaining -= count
+        return bytes(count)
+
+
+class _CountingSink:
+    def __init__(self):
+        self.written = 0
+
+    def write(self, chunk):
+        self.written += len(chunk)
+        return len(chunk)
+
+
+# The size cap the 0.12.0 wrappers enforced, which refused every release.
+_FORMER_MEMBER_CAP_BYTES = 256 * 1024 * 1024
 
 
 def _write_tar_gz(archive, entries):
@@ -884,58 +912,32 @@ def _release_entries(names):
     return [(name, f"payload of {name}".encode()) for name in names]
 
 
-class ArchiveLimitTests(unittest.TestCase):
+class ArchiveExtractionTests(unittest.TestCase):
     URL = "https://example.invalid/release.tar.gz"
 
-    def _download(self, response, destination, max_bytes):
+    def _download(self, response, destination):
         with mock.patch.object(_cli._HTTPS_OPENER, "open", return_value=response):
-            _cli._download_https(self.URL, destination, max_bytes)
-
-    def test_download_rejects_a_declared_length_over_the_limit(self):
-        with tempfile.TemporaryDirectory() as root:
-            destination = os.path.join(root, "release.tar.gz")
-            response = _FakeHttpsResponse(b"", {"Content-Length": "9"})
-            with self.assertRaises(RuntimeError) as raised:
-                self._download(response, destination, 8)
-            self.assertIn("8-byte safety limit", str(raised.exception))
-            self.assertFalse(os.path.exists(destination))
+            _cli._download_file(self.URL, destination)
 
-    def test_download_rejects_a_body_over_the_limit_and_removes_the_partial_file(
+    def test_download_stores_a_body_whose_declared_length_exceeds_the_former_cap(
         self,
     ):
         with tempfile.TemporaryDirectory() as root:
             destination = os.path.join(root, "release.tar.gz")
-            response = _FakeHttpsResponse(b"x" * 1024)
-            with self.assertRaises(RuntimeError) as raised:
-                self._download(response, destination, 8)
-            self.assertIn("8-byte safety limit", str(raised.exception))
-            self.assertFalse(os.path.exists(destination))
-
-    def test_download_within_the_limit_stores_the_body(self):
-        with tempfile.TemporaryDirectory() as root:
-            destination = os.path.join(root, "release.tar.gz")
-            response = _FakeHttpsResponse(b"payload", {"Content-Length": "7"})
-            self._download(response, destination, 1024)
+            response = _FakeHttpsResponse(
+                b"payload", {"Content-Length": str(_FORMER_MEMBER_CAP_BYTES + 1)}
+            )
+            self._download(response, destination)
             with open(destination, "rb") as stored:
                 self.assertEqual(stored.read(), b"payload")
 
-    def test_download_counts_bytes_when_the_declared_length_is_not_a_number(self):
-        # A superscript two passes str.isdigit but not int(); such values and
-        # plain junk must fall through to the byte counter, never crash.
-        for declared in ("²", "abc", "", "1e3", "-1"):
-            with self.subTest(declared=declared), tempfile.TemporaryDirectory() as root:
-                destination = os.path.join(root, "release.tar.gz")
-                response = _FakeHttpsResponse(b"x" * 1024, {"Content-Length": declared})
-                with self.assertRaises(RuntimeError) as raised:
-                    self._download(response, destination, 8)
-                self.assertIn("8-byte safety limit", str(raised.exception))
-                self.assertFalse(os.path.exists(destination))
+    def test_download_removes_the_partial_file_when_the_body_fails(self):
         with tempfile.TemporaryDirectory() as root:
             destination = os.path.join(root, "release.tar.gz")
-            response = _FakeHttpsResponse(b"payload", {"Content-Length": "²"})
-            self._download(response, destination, 1024)
-            with open(destination, "rb") as stored:
-                self.assertEqual(stored.read(), b"payload")
+            response = _FakeHttpsResponse(b"x" * 200000, fail_after_first_chunk=True)
+            with self.assertRaises(OSError):
+                self._download(response, destination)
+            self.assertFalse(os.path.exists(destination))
 
     def test_unix_tar_rejects_more_members_than_the_limit(self):
         with tempfile.TemporaryDirectory() as root:
@@ -949,50 +951,12 @@ class ArchiveLimitTests(unittest.TestCase):
                     str(destination),
                     ("one", "two", "three"),
                     ("one",),
-                    limits=_limits_with(members=2),
+                    max_members=2,
                 )
             self.assertIn("2-member safety limit", str(raised.exception))
             self.assertFalse((destination / "one").exists())
 
-    def test_unix_tar_rejects_a_member_declared_over_the_limit(self):
-        with tempfile.TemporaryDirectory() as root:
-            archive = Path(root) / "member.tar.gz"
-            _write_tar_gz(archive, [("codebase-memory-mcp", b"x" * 65)])
-            destination = Path(root) / "extract"
-            destination.mkdir()
-            with tarfile.open(archive) as tf, self.assertRaises(SystemExit) as raised:
-                _cli._safe_extract_tar(
-                    tf,
-                    str(destination),
-                    ("codebase-memory-mcp",),
-                    ("codebase-memory-mcp",),
-                    limits=_limits_with(member_bytes=64),
-                )
-            self.assertIn(
-                "'codebase-memory-mcp' exceeds the 64-byte expanded safety limit",
-                str(raised.exception),
-            )
-            self.assertFalse((destination / "codebase-memory-mcp").exists())
-
-    def test_unix_tar_rejects_a_declared_aggregate_over_the_limit(self):
-        with tempfile.TemporaryDirectory() as root:
-            archive = Path(root) / "aggregate.tar.gz"
-            _write_tar_gz(archive, [("one", b"a" * 40), ("two", b"b" * 40)])
-            destination = Path(root) / "extract"
-            destination.mkdir()
-            with tarfile.open(archive) as tf, self.assertRaises(SystemExit) as raised:
-                _cli._safe_extract_tar(
-                    tf,
-                    str(destination),
-                    ("one", "two"),
-                    ("one",),
-                    limits=_limits_with(member_bytes=64, expanded_bytes=64),
-                )
-            self.assertIn(
-                "64-byte aggregate expanded safety limit", str(raised.exception)
-            )
-
-    def test_unix_tar_within_the_limits_extracts_only_the_executable(self):
+    def test_unix_tar_extracts_only_the_executable(self):
         with tempfile.TemporaryDirectory() as root:
             archive = Path(root) / "release.tar.gz"
             _write_tar_gz(archive, _release_entries(_cli._UNIX_ARCHIVE_NAMES))
@@ -1012,67 +976,29 @@ class ArchiveLimitTests(unittest.TestCase):
             )
             self.assertEqual(os.listdir(destination), ["codebase-memory-mcp"])
 
-    def test_archive_copy_stops_a_member_that_yields_more_than_the_limit(self):
-        source = io.BytesIO(b"x" * 100)
-        output = io.BytesIO()
-        with self.assertRaises(SystemExit) as raised:
-            _cli._copy_archive_member_within_limits(
-                source,
-                output,
-                "member",
-                100,
-                0,
-                _limits_with(member_bytes=64, expanded_bytes=1024),
-            )
-        self.assertIn(
-            "'member' exceeds the 64-byte actual expanded safety limit",
-            str(raised.exception),
+    def test_archive_copy_accepts_a_member_larger_than_the_former_cap(self):
+        size = _FORMER_MEMBER_CAP_BYTES + 1024 * 1024
+        sink = _CountingSink()
+        copied = _cli._copy_archive_member(
+            _ZeroSource(size), sink, "codebase-memory-mcp", size
         )
-        # Reading stopped one byte past the limit; nothing beyond it was kept.
-        self.assertEqual(source.tell(), 65)
-        self.assertLessEqual(len(output.getvalue()), 64)
+        self.assertEqual(copied, size)
+        self.assertEqual(sink.written, size)
 
     def test_archive_copy_rejects_a_member_that_yields_more_than_it_declares(self):
-        source = io.BytesIO(b"x" * 100)
         with self.assertRaises(SystemExit) as raised:
-            _cli._copy_archive_member_within_limits(
-                source,
-                io.BytesIO(),
-                "member",
-                10,
-                0,
-                _limits_with(member_bytes=1024, expanded_bytes=1024),
-            )
+            _cli._copy_archive_member(io.BytesIO(b"x" * 100), io.BytesIO(), "member", 10)
         self.assertIn(
             "'member' actual size 100 does not match declared size 10",
             str(raised.exception),
         )
 
-    def test_archive_copy_rejects_an_aggregate_over_the_actual_limit(self):
-        with self.assertRaises(SystemExit) as raised:
-            _cli._copy_archive_member_within_limits(
-                io.BytesIO(b"abcd"),
-                io.BytesIO(),
-                "member",
-                4,
-                3,
-                _limits_with(member_bytes=10, expanded_bytes=5),
-            )
-        self.assertIn(
-            "5-byte aggregate actual expanded safety limit", str(raised.exception)
-        )
-
     def test_archive_member_write_removes_the_partial_file_on_failure(self):
         with tempfile.TemporaryDirectory() as root:
             target = os.path.join(root, "codebase-memory-mcp")
             with self.assertRaises(SystemExit):
-                _cli._write_archive_member_within_limits(
-                    io.BytesIO(b"x" * 100),
-                    target,
-                    "codebase-memory-mcp",
-                    10,
-                    0,
-                    _limits_with(member_bytes=1024, expanded_bytes=1024),
+                _cli._write_archive_member(
+                    io.BytesIO(b"x" * 100), target, "codebase-memory-mcp", 10
                 )
             self.assertFalse(os.path.exists(target))
 
@@ -1088,28 +1014,11 @@ class ArchiveLimitTests(unittest.TestCase):
                     str(destination),
                     ("one", "two", "three"),
                     ("one",),
-                    limits=_limits_with(members=2),
+                    max_members=2,
                 )
             self.assertIn("2-member safety limit", str(raised.exception))
 
-    def test_windows_zip_rejects_a_member_declared_over_the_limit(self):
-        with tempfile.TemporaryDirectory() as root:
-            archive = Path(root) / "member.zip"
-            _write_zip(archive, [(_cli._WINDOWS_BINARY_NAME, b"x" * 65)])
-            destination = Path(root) / "extract"
-            destination.mkdir()
-            with zipfile.ZipFile(archive) as zf, self.assertRaises(SystemExit) as raised:
-                _cli._safe_extract_zip(
-                    zf,
-                    str(destination),
-                    (_cli._WINDOWS_BINARY_NAME,),
-                    (_cli._WINDOWS_BINARY_NAME,),
-                    limits=_limits_with(member_bytes=64),
-                )
-            self.assertIn("64-byte expanded safety limit", str(raised.exception))
-            self.assertFalse((destination / _cli._WINDOWS_BINARY_NAME).exists())
-
-    def test_windows_zip_within_the_limits_extracts_only_the_executable(self):
+    def test_windows_zip_extracts_only_the_executable(self):
         with tempfile.TemporaryDirectory() as root:
             archive = Path(root) / "release.zip"
             _write_zip(archive, _release_entries(_cli._WINDOWS_ARCHIVE_NAMES))
@@ -1129,3 +1038,161 @@ class ArchiveLimitTests(unittest.TestCase):
             )
             self.assertEqual(os.listdir(destination), [_cli._WINDOWS_BINARY_NAME])
 
+
+@contextlib.contextmanager
+def _loopback_server(routes):
+    """Serve `routes` ({path: bytes}) on 127.0.0.1; any other path redirects."""
+
+    class Handler(http.server.BaseHTTPRequestHandler):
+        def do_GET(self):
+            body = routes.get(self.path)
+            if body is None:
+                self.send_response(302)
+                self.send_header("Location", "https://example.invalid/elsewhere")
+                self.send_header("Content-Length", "0")
+                self.end_headers()
+                return
+            self.send_response(200)
+            self.send_header("Content-Length", str(len(body)))
+            self.end_headers()
+            self.wfile.write(body)
+
+        def log_message(self, *args):
+            pass
+
+    server = http.server.ThreadingHTTPServer(("127.0.0.1", 0), Handler)
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+    try:
+        yield f"http://127.0.0.1:{server.server_address[1]}"
+    finally:
+        server.shutdown()
+        server.server_close()
+        thread.join()
+
+
+class DownloadBaseTests(unittest.TestCase):
+    GITHUB_BASE = "https://github.com/DeusData/codebase-memory-mcp/releases/download/v1.2.3"
+
+    def test_unset_or_empty_uses_the_github_release_base(self):
+        self.assertEqual(_cli._download_base("1.2.3", {}), (self.GITHUB_BASE, False))
+        self.assertEqual(
+            _cli._download_base("1.2.3", {"CBM_DOWNLOAD_URL": ""}),
+            (self.GITHUB_BASE, False),
+        )
+
+    def test_https_override_is_accepted(self):
+        for base in (
+            "https://mirror.example/releases/v1",
+            "https://127.0.0.1:8443/fixture",
+        ):
+            with self.subTest(base=base):
+                self.assertEqual(
+                    _cli._download_base("1.2.3", {"CBM_DOWNLOAD_URL": base}),
+                    (base, False),
+                )
+
+    def test_exact_loopback_http_override_is_accepted(self):
+        for base in (
+            "http://localhost",
+            "http://localhost:8080/fixture",
+            "http://127.0.0.1:41234/standard",
+            "http://[::1]:9/x?y#z",
+        ):
+            with self.subTest(base=base):
+                self.assertEqual(
+                    _cli._download_base("1.2.3", {"CBM_DOWNLOAD_URL": base}),
+                    (base, True),
+                )
+
+    def test_non_loopback_http_and_other_schemes_are_refused(self):
+        for base in (
+            "http://example.com/releases",
+            "http://127.0.0.1.example.com/",
+            "http://localhost.example.com:8080/",
+            "http://user@localhost/",
+            "http://127.0.0.2/",
+            "HTTP://localhost/",
+            "file:///tmp/releases",
+            "ftp://localhost/releases",
+            "github.com/DeusData/codebase-memory-mcp",
+        ):
+            with self.subTest(base=base), self.assertRaises(SystemExit) as raised:
+                _cli._download_base("1.2.3", {"CBM_DOWNLOAD_URL": base})
+            self.assertIn(
+                "refusing non-HTTPS download URL (CBM_DOWNLOAD_URL)",
+                str(raised.exception),
+            )
+
+    def test_https_download_refuses_plain_http(self):
+        with tempfile.TemporaryDirectory() as root:
+            with self.assertRaises(SystemExit):
+                _cli._download_file(
+                    "http://127.0.0.1/release.tar.gz", os.path.join(root, "a")
+                )
+
+    def test_loopback_download_refuses_a_non_loopback_url(self):
+        with tempfile.TemporaryDirectory() as root:
+            with self.assertRaises(SystemExit) as raised:
+                _cli._download_file(
+                    "http://example.invalid/release.tar.gz",
+                    os.path.join(root, "a"),
+                    loopback=True,
+                )
+            self.assertIn("refusing non-loopback HTTP URL", str(raised.exception))
+
+    def test_loopback_download_bypasses_proxies_and_refuses_redirects(self):
+        routes = {"/fixture/archive": b"loopback payload"}
+        # A configured proxy that is not listening: using it would fail.
+        proxy_env = {"http_proxy": "http://127.0.0.1:9", "HTTP_PROXY": "http://127.0.0.1:9"}
+        with _loopback_server(routes) as origin, tempfile.TemporaryDirectory() as root, \
+                mock.patch.dict(os.environ, proxy_env):
+            archive = os.path.join(root, "archive")
+            _cli._download_file(f"{origin}/fixture/archive", archive, loopback=True)
+            with open(archive, "rb") as stored:
+                self.assertEqual(stored.read(), b"loopback payload")
+
+            redirected = os.path.join(root, "redirected")
+            with self.assertRaises(RuntimeError) as raised:
+                _cli._download_file(
+                    f"{origin}/fixture/checksums.txt", redirected, loopback=True
+                )
+            self.assertIn("refusing redirect from loopback download", str(raised.exception))
+            self.assertFalse(os.path.exists(redirected))
+
+    def test_download_fetches_archive_and_checksums_from_the_override(self):
+        os_name = _cli._os_name()
+        arch = _cli._arch()
+        if os_name == "windows":
+            ext, names = "zip", _cli._WINDOWS_ARCHIVE_NAMES
+        else:
+            ext, names = "tar.gz", _cli._UNIX_ARCHIVE_NAMES
+        portable = "-portable" if os_name == "linux" else ""
+        archive_name = f"codebase-memory-mcp-{os_name}-{arch}{portable}.{ext}"
+        with tempfile.TemporaryDirectory() as root:
+            fixture = Path(root) / archive_name
+            if ext == "zip":
+                _write_zip(fixture, _release_entries(names))
+            else:
+                _write_tar_gz(fixture, _release_entries(names))
+            archive_bytes = fixture.read_bytes()
+            digest = hashlib.sha256(archive_bytes).hexdigest()
+            routes = {
+                f"/fixture/{archive_name}": archive_bytes,
+                "/fixture/checksums.txt": f"{digest}  {archive_name}\n".encode(),
+            }
+            cache = Path(root) / "cache"
+            with _loopback_server(routes) as origin, mock.patch.dict(
+                os.environ, {"CBM_DOWNLOAD_URL": f"{origin}/fixture"}
+            ), mock.patch.object(_cli, "_cache_dir", return_value=cache), \
+                    mock.patch.object(_cli, "_verify_candidate"), \
+                    contextlib.redirect_stderr(io.StringIO()):
+                installed = _cli._download("9.9.9")
+            binary_name = (
+                _cli._WINDOWS_BINARY_NAME
+                if os_name == "windows"
+                else "codebase-memory-mcp"
+            )
+            self.assertEqual(
+                installed.read_bytes(), f"payload of {binary_name}".encode()
+            )