getcodexy 1.2.2__tar.gz → 1.3.0__tar.gz

{getcodexy-1.2.2 → getcodexy-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: getcodexy
-Version: 1.2.2
+Version: 1.3.0
 Summary: Version-pinned MCP runtime bootstrap tools for Codexy
 Author: Eunsoo Lee
 License-Expression: MIT

{getcodexy-1.2.2 → getcodexy-1.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "getcodexy"
-version = "1.2.2"
+version = "1.3.0"
 description = "Version-pinned MCP runtime bootstrap tools for Codexy"
 requires-python = ">=3.10"
 license = "MIT"

getcodexy-1.3.0/src/codexy_runtime_tools/contract.py

@@ -0,0 +1,149 @@
+"""Immutable, standalone runtime-release contract validation."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+import tarfile
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from .identity import Compatibility, compatibility, digest, document, object, platforms, string
+
+
+REPOSITORY = "https://github.com/eunsoogi/codexy"
+RELEASE_SCHEMA = "codexy-runtime-release/v1"
+CANDIDATE_SCHEMA = "codexy-runtime-candidate/v1"
+_COMMIT = re.compile(r"[0-9a-f]{40}\Z")
+
+
+@dataclass(frozen=True)
+class Source:
+    repository: str
+    commit: str
+
+
+@dataclass(frozen=True)
+class Artifact:
+    tag: str
+    url: str
+    sha256: str
+    payload_manifest_sha256: str
+
+
+@dataclass(frozen=True)
+class RuntimeRelease:
+    state: str
+    source: Source
+    artifact: Artifact
+    compatibility: Compatibility
+    platforms: dict[str, dict[str, dict[str, str]]]
+
+    def advertises(self, *, platform: str) -> bool:
+        return platform in self.platforms
+
+    def supports(self, *, server: str, platform: str, bootstrap_api: int,
+                 plugin_runtime_api: int, transport: str, mcp_protocol: str) -> bool:
+        return (
+            server in self.platforms.get(platform, {})
+            and self.compatibility == Compatibility(
+                bootstrap_api, plugin_runtime_api, transport, mcp_protocol
+            )
+        )
+
+    def cache_key(self, *, platform: str, server: str) -> str:
+        return "v3-" + hashlib.sha256(_encoded(self.identity(platform=platform, server=server))).hexdigest()
+
+    def identity(self, *, platform: str, server: str) -> dict[str, Any]:
+        binary = self.platforms.get(platform, {}).get(server)
+        if binary is None:
+            raise ValueError("runtime release does not advertise the selected binary")
+        return {"schema": RELEASE_SCHEMA, "state": self.state, "source": self.source.__dict__,
+                "artifact": self.artifact.__dict__, "compatibility": self.compatibility.__dict__,
+                "platform": platform, "server": server, "binarySha256": binary["sha256"]}
+
+    def marker(self, *, platform: str, server: str, binary_sha256: str) -> dict[str, Any]:
+        return {"schema": "codexy-runtime-marker/v1", "identity": self.identity(platform=platform, server=server),
+                "installedBinarySha256": binary_sha256}
+
+    def valid_marker(self, marker: Any, *, platform: str, server: str, binary: bytes) -> bool:
+        return marker == self.marker(platform=platform, server=server,
+            binary_sha256=hashlib.sha256(binary).hexdigest())
+
+    def verify_archive(self, archive: Path, *, platform: str) -> bool:
+        if self.state == "legacy-public":
+            return True
+        try:
+            with tarfile.open(archive, "r:gz") as package:
+                names = [member.name for member in package.getmembers()]
+                if len({name.casefold() for name in names}) != len(names):
+                    raise ValueError("runtime archive has duplicate or casefold paths")
+                package.getmember("plugins/codexy/.codex-plugin/plugin.json")
+                candidate = document(package.extractfile("plugins/codexy/runtime-candidate.json").read())
+                if _canonical(candidate) != self.artifact.payload_manifest_sha256:
+                    raise ValueError("runtime candidate digest does not match release")
+                _validate_candidate(candidate, self, package, platform)
+        except (AttributeError, KeyError, OSError, tarfile.TarError, TypeError, json.JSONDecodeError) as error:
+            raise ValueError(f"invalid runtime candidate: {error}") from error
+        return True
+
+
+def _canonical(value: Any) -> str:
+    return hashlib.sha256(_encoded(value)).hexdigest()
+
+
+def _encoded(value: Any) -> bytes:
+    return json.dumps(value, sort_keys=True, separators=(",", ":")).encode()
+
+
+def load(plugin_root: Path) -> RuntimeRelease:
+    path = plugin_root / "runtime-release.json"
+    try:
+        value = document(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as error:
+        raise ValueError(f"runtime release is missing or invalid: {error}") from error
+    value = object(value, "document")
+    if set(value) != {"schema", "state", "source", "artifact", "compatibility", "platforms"}:
+        raise ValueError("runtime release has unknown or missing fields")
+    if value.get("schema") != RELEASE_SCHEMA:
+        raise ValueError("runtime release schema must be codexy-runtime-release/v1")
+    state = value.get("state")
+    if state not in {"legacy-public", "candidate-proven"}:
+        raise ValueError("runtime release state must be legacy-public or candidate-proven")
+    source = object(value.get("source"), "source")
+    if set(source) != {"repository", "commit"}:
+        raise ValueError("runtime release source has unknown or missing fields")
+    commit = string(source.get("commit"), "source.commit")
+    if source.get("repository") != REPOSITORY or not _COMMIT.fullmatch(commit):
+        raise ValueError("runtime release source must use the canonical repository and lowercase commit")
+    artifact = object(value.get("artifact"), "artifact")
+    if set(artifact) != {"tag", "url", "sha256", "payloadManifestSha256"}:
+        raise ValueError("runtime release artifact has unknown or missing fields")
+    tag = string(artifact.get("tag"), "artifact.tag")
+    url = string(artifact.get("url"), "artifact.url")
+    if url != f"{REPOSITORY}/releases/download/{tag}/codexy-marketplace-plugin.tar.gz":
+        raise ValueError("runtime release artifact URL is not canonical")
+    return RuntimeRelease(state, Source(REPOSITORY, commit), Artifact(tag, url,
+        digest(artifact.get("sha256"), "artifact.sha256"),
+        digest(artifact.get("payloadManifestSha256"), "artifact.payloadManifestSha256")),
+        compatibility(value.get("compatibility")),
+        platforms(value.get("platforms"), require_path=state == "candidate-proven"))
+
+
+def _validate_candidate(candidate: Any, release: RuntimeRelease, package: tarfile.TarFile, platform: str) -> None:
+    candidate = object(candidate, "candidate")
+    if release.state != "candidate-proven":
+        raise ValueError("legacy runtime release has no candidate payload")
+    if set(candidate) != {"schema", "source", "artifact", "compatibility", "platforms"} or candidate.get("schema") != CANDIDATE_SCHEMA or candidate.get("source") != {"repository": release.source.repository, "commit": release.source.commit}:
+        raise ValueError("runtime candidate identity does not match release")
+    if candidate.get("artifact") != {"tag": release.artifact.tag} or compatibility(candidate.get("compatibility")) != release.compatibility:
+        raise ValueError("runtime candidate metadata does not match release")
+    inventory = platforms(candidate.get("platforms"), require_path=True)
+    if inventory != release.platforms or platform not in inventory:
+        raise ValueError("runtime candidate inventory does not match release")
+    for binary in inventory[platform].values():
+        member = package.extractfile(f"plugins/codexy/{binary['path']}")
+        if member is None or hashlib.sha256(member.read()).hexdigest() != binary["sha256"]:
+            raise ValueError("runtime candidate binary digest does not match")

getcodexy-1.3.0/src/codexy_runtime_tools/identity.py

@@ -0,0 +1,89 @@
+"""Strict JSON and normalized runtime inventory primitives."""
+
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass
+from typing import Any
+
+
+_DIGEST = re.compile(r"[0-9a-f]{64}\Z")
+PLATFORMS = {"darwin-arm64", "linux-x86_64"}
+SERVERS = {"lsp", "codegraph"}
+
+
+@dataclass(frozen=True)
+class Compatibility:
+    bootstrap_api: int
+    plugin_runtime_api: int
+    transport: str
+    mcp_protocol: str
+
+
+def document(text: str) -> Any:
+    def pairs(items: list[tuple[str, Any]]) -> dict[str, Any]:
+        value: dict[str, Any] = {}
+        for key, item in items:
+            if key in value:
+                raise ValueError(f"runtime release has duplicate JSON key: {key}")
+            value[key] = item
+        return value
+    return json.loads(text, object_pairs_hook=pairs)
+
+
+def object(value: Any, name: str) -> dict[str, Any]:
+    if not isinstance(value, dict):
+        raise ValueError(f"runtime release {name} must be an object")
+    return value
+
+
+def string(value: Any, name: str) -> str:
+    if not isinstance(value, str) or not value:
+        raise ValueError(f"runtime release {name} must be a non-empty string")
+    return value
+
+
+def digest(value: Any, name: str) -> str:
+    value = string(value, name)
+    if not _DIGEST.fullmatch(value):
+        raise ValueError(f"runtime release {name} must be a lowercase SHA-256")
+    return value
+
+
+def compatibility(value: Any) -> Compatibility:
+    value = object(value, "compatibility")
+    if set(value) != {"bootstrapApi", "pluginRuntimeApi", "transport", "mcpProtocol"}:
+        raise ValueError("runtime release compatibility has unknown or missing fields")
+    if value.get("bootstrapApi") != 1 or value.get("pluginRuntimeApi") != 1:
+        raise ValueError("runtime release compatibility APIs must be 1")
+    if value.get("transport") != "stdio-newline-v1" or value.get("mcpProtocol") != "2024-11-05":
+        raise ValueError("runtime release compatibility transport or MCP protocol is unsupported")
+    return Compatibility(1, 1, "stdio-newline-v1", "2024-11-05")
+
+
+def platforms(value: Any, *, require_path: bool) -> dict[str, dict[str, dict[str, str]]]:
+    value = object(value, "platforms")
+    if set(value) != PLATFORMS:
+        raise ValueError("runtime release has unknown or missing platform")
+    result: dict[str, dict[str, dict[str, str]]] = {}
+    for platform, inventory in value.items():
+        inventory = object(inventory, f"platforms.{platform}")
+        if set(inventory) != SERVERS:
+            raise ValueError("runtime release has unknown or missing server")
+        binaries: dict[str, dict[str, str]] = {}
+        for server, item in inventory.items():
+            item = object(item, "binary")
+            fields = {"path", "sha256"} if require_path else {"sha256"}
+            if set(item) != fields:
+                raise ValueError("runtime release binary has unknown or missing fields")
+            binary = {"sha256": digest(item.get("sha256"), "binary.sha256")}
+            if require_path:
+                path = string(item.get("path"), "binary.path")
+                expected = f"runtime/codexy-mcp-{server}-{platform}.bin"
+                if path != expected or path.casefold() != path:
+                    raise ValueError("runtime release binary path is not canonical")
+                binary["path"] = path
+            binaries[server] = binary
+        result[platform] = binaries
+    return result

getcodexy-1.3.0/src/codexy_runtime_tools/installer.py

@@ -0,0 +1,140 @@
+from __future__ import annotations
+
+import os
+import re
+import shutil
+import stat
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import NoReturn, Protocol
+
+from .cache import releases_match
+from .package import acquire_package, unpack_runtime
+
+
+class InstallConfig(Protocol):
+    server: str
+    manifest: Path
+    runtime_name: str
+    package_path: str
+    package_url: str
+    artifacts_api: str
+    package_override: bool
+    package_sha256: str
+    git_repository: str
+    git_ref: str
+    source_identity: object
+
+
+def executable(path: Path) -> bool:
+    try:
+        metadata = os.lstat(path)
+    except FileNotFoundError:
+        return False
+    reparse = getattr(stat, "FILE_ATTRIBUTE_REPARSE_POINT", 0)
+    return (
+        stat.S_ISREG(metadata.st_mode)
+        and not stat.S_ISLNK(metadata.st_mode)
+        and not bool(getattr(metadata, "st_file_attributes", 0) & reparse)
+        and os.access(path, os.X_OK)
+    )
+
+
+def _publish_executable(
+    source: Path, destination: Path, *, require_staged_executable: bool = True
+) -> None:
+    if require_staged_executable and not executable(source):
+        raise RuntimeError(f"staged runtime is not executable: {source}")
+    destination.parent.mkdir(parents=True, exist_ok=True)
+    temporary = destination.with_name(f".{destination.name}.{os.getpid()}.tmp")
+    try:
+        shutil.copyfile(source, temporary)
+        mode = (
+            stat.S_IMODE(source.stat().st_mode) & 0o777
+            if require_staged_executable
+            else 0o755
+        )
+        temporary.chmod(mode)
+        if not executable(temporary):
+            raise RuntimeError(f"copied runtime is not executable: {temporary}")
+        os.replace(temporary, destination)
+    finally:
+        temporary.unlink(missing_ok=True)
+
+
+def execute(
+    path: Path | str, arguments: list[str], environment: dict[str, str] | None = None
+) -> NoReturn:
+    command = str(path)
+    runtime_environment = os.environ.copy()
+    runtime_environment.update(environment or {})
+    os.execvpe(command, [command, *arguments], runtime_environment)
+    raise AssertionError("exec returned unexpectedly")
+
+
+def install_package(config: InstallConfig, install_root: Path, installed: Path) -> None:
+    install_root.mkdir(parents=True, exist_ok=True)
+    with tempfile.TemporaryDirectory(prefix="package-", dir=install_root) as temporary:
+        work = Path(temporary)
+        archive = acquire_package(
+            path=config.package_path,
+            url=config.package_url,
+            artifacts_api=config.artifacts_api,
+            expected_sha256=config.package_sha256,
+            work=work,
+        )
+        source_identity = getattr(config, "source_identity", None)
+        release_contract = getattr(config, "release_contract", None)
+        if source_identity is not None:
+            source_identity.verify_archive(archive, platform=config.platform)
+        elif release_contract is not None:
+            release_contract.verify_archive(archive, platform=config.platform)
+        packaged_runtime, package_manifest = unpack_runtime(
+            archive=archive, work=work, runtime_name=config.runtime_name
+        )
+        if not config.package_override and release_contract is None:
+            matches, message = releases_match(config.manifest, package_manifest)
+            if not matches:
+                raise RuntimeError(message)
+        _publish_executable(
+            packaged_runtime, installed, require_staged_executable=False
+        )
+        if not config.package_override:
+            shutil.copyfile(package_manifest, install_root / "plugin.json")
+
+
+def install_git(config: InstallConfig, install_root: Path, installed: Path) -> None:
+    cargo = shutil.which("cargo")
+    if not cargo:
+        raise RuntimeError("cargo is unavailable for the configured Git runtime source")
+    if config.git_repository != "https://github.com/eunsoogi/codexy" or not re.fullmatch(r"[0-9a-f]{40}", config.git_ref):
+        raise RuntimeError("Git fallback requires the canonical repository and lowercase 40-hex commit")
+    install_root.mkdir(parents=True, exist_ok=True)
+    with tempfile.TemporaryDirectory(prefix="git-", dir=install_root) as temporary:
+        staged_root = Path(temporary) / "root"
+        staged_runtime = staged_root / "bin" / f"codexy-mcp-{config.server}"
+        command = [
+            cargo,
+            "install",
+            "--force",
+            "--locked",
+            "--git",
+            config.git_repository,
+            "--rev",
+            config.git_ref,
+            "--root",
+            str(staged_root),
+            "--bin",
+            f"codexy-mcp-{config.server}",
+        ]
+        environment = {key: value for key, value in os.environ.items() if key not in {"GH_TOKEN", "GITHUB_TOKEN"}}
+        completed = subprocess.run(command, check=False, env=environment)
+        if completed.returncode:
+            raise RuntimeError(f"cargo install exited with status {completed.returncode}")
+        try:
+            _publish_executable(staged_runtime, installed)
+        except RuntimeError as error:
+            raise RuntimeError(
+                f"cargo install exited with status {completed.returncode}: {error}"
+            ) from error

{getcodexy-1.2.2 → getcodexy-1.3.0}/src/codexy_runtime_tools/package.py

@@ -68,16 +68,17 @@ def _extract_tar(archive: Path, destination: Path) -> None:
             raise ValueError("runtime package contains too many members")
         if sum(member.size for member in members) > MAX_UNPACKED_BYTES:
             raise ValueError("runtime package exceeds the unpacked size limit")
-        destinations: set[Path] = set()
+        destinations: set[str] = set()
         for member in members:
             if not (member.isdir() or member.isfile()):
                 raise ValueError(f"runtime package contains unsafe link or device: {member.name}")
             member_path = (destination / member.name).resolve()
             if destination_resolved not in member_path.parents and member_path != destination_resolved:
                 raise ValueError(f"runtime package contains unsafe path: {member.name}")
-            if member_path in destinations:
+            identity = str(member_path).casefold()
+            if identity in destinations:
                 raise ValueError(f"runtime package contains duplicate path: {member.name}")
-            destinations.add(member_path)
+            destinations.add(identity)
         package.extractall(destination)
 
 
@@ -96,7 +97,7 @@ def _extract_zip(archive: Path, destination: Path) -> None:
             raise ValueError("artifact archive contains too many members")
         if sum(member.file_size for member in members) > MAX_UNPACKED_BYTES:
             raise ValueError("artifact archive exceeds the unpacked size limit")
-        destinations: set[Path] = set()
+        destinations: set[str] = set()
         for member in members:
             member_path = (destination / member.filename).resolve()
             unix_mode = member.external_attr >> 16
@@ -104,9 +105,10 @@ def _extract_zip(archive: Path, destination: Path) -> None:
                 raise ValueError(f"artifact archive contains unsafe link: {member.filename}")
             if destination_resolved not in member_path.parents and member_path != destination_resolved:
                 raise ValueError(f"artifact archive contains unsafe path: {member.filename}")
-            if member_path in destinations:
+            identity = str(member_path).casefold()
+            if identity in destinations:
                 raise ValueError(f"artifact archive contains duplicate path: {member.filename}")
-            destinations.add(member_path)
+            destinations.add(identity)
         zipped.extractall(destination)
 
 

getcodexy-1.3.0/src/codexy_runtime_tools/plugin_resolution.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from .updater import _absolute, _validate_real_path
+
+OFFICIAL = "https://github.com/eunsoogi/codexy.git"
+PLUGIN_REPOSITORY = "https://github.com/eunsoogi/codexy"
+
+
+def named_marketplace(payload: object) -> bool:
+    return any(
+        isinstance(item, dict) and item.get("name") == "codexy"
+        for item in _items(payload, "marketplaces")
+    )
+
+
+def official_marketplace(payload: object) -> Path:
+    named = [
+        item
+        for item in _items(payload, "marketplaces")
+        if isinstance(item, dict) and item.get("name") == "codexy"
+    ]
+    if len(named) != 1 or named[0].get("marketplaceSource") != {
+        "sourceType": "git",
+        "source": OFFICIAL,
+    }:
+        raise ValueError("expected exactly one official Codexy marketplace")
+    root_value = named[0].get("root")
+    if not isinstance(root_value, str):
+        raise ValueError("official Codexy marketplace root is missing")
+    if not Path(root_value).is_absolute():
+        raise ValueError("official Codexy marketplace root must be absolute")
+    root = _absolute(root_value)
+    _validate_real_path(root, require_exists=True)
+    return root
+
+
+def preflight_install(payload: object, marketplace_root: Path) -> None:
+    marketplace_root = _absolute(marketplace_root)
+    _validate_real_path(marketplace_root, require_exists=True)
+    entries = _codexy_enabled(payload)
+    if len(entries) > 1:
+        raise ValueError("expected zero or one enabled official Codexy install")
+    if entries:
+        _require_official(entries[0])
+        _source_root(entries[0], marketplace_root)
+
+
+def official_install(
+    payload: object,
+    marketplace_root: Path,
+    distribution_version: str,
+) -> tuple[Path, str]:
+    marketplace_root = _absolute(marketplace_root)
+    _validate_real_path(marketplace_root, require_exists=True)
+    entries = _codexy_enabled(payload)
+    if len(entries) != 1:
+        raise ValueError("expected exactly one enabled official Codexy install")
+    item = entries[0]
+    _require_official(item)
+    root = _source_root(item, marketplace_root)
+    version = item.get("version")
+    if not isinstance(version, str):
+        raise ValueError("official Codexy install has invalid metadata")
+    if version != distribution_version:
+        raise ValueError("Codexy plugin version must match the getcodexy distribution")
+
+    manifest = root / ".codex-plugin" / "plugin.json"
+    _validate_real_path(manifest, require_exists=True)
+    data = json.loads(manifest.read_text(encoding="utf-8"))
+    if not isinstance(data, dict) or (
+        data.get("name"),
+        data.get("repository"),
+        data.get("version"),
+    ) != ("codexy", PLUGIN_REPOSITORY, version):
+        raise ValueError("official Codexy install identity does not match its manifest")
+    return root, version
+
+
+def _items(payload: object, key: str) -> list[object]:
+    if not isinstance(payload, dict):
+        return []
+    value = payload.get(key)
+    return value if isinstance(value, list) else []
+
+
+def _codexy_enabled(payload: object) -> list[dict[str, object]]:
+    return [
+        item
+        for item in _items(payload, "installed")
+        if isinstance(item, dict)
+        and item.get("enabled") is True
+        and (
+            item.get("pluginId") == "codexy@codexy"
+            or item.get("name") == "codexy"
+            or item.get("marketplaceName") == "codexy"
+        )
+    ]
+
+
+def _require_official(item: dict[str, object]) -> None:
+    source = item.get("source")
+    if not (
+        item.get("pluginId") == "codexy@codexy"
+        and item.get("name") == "codexy"
+        and item.get("marketplaceName") == "codexy"
+        and item.get("installed") is True
+        and item.get("enabled") is True
+        and isinstance(source, dict)
+        and source.get("source") == "local"
+        and item.get("marketplaceSource")
+        == {"sourceType": "git", "source": OFFICIAL}
+    ):
+        raise ValueError("expected zero or one enabled official Codexy install")
+
+
+def _source_root(item: dict[str, object], marketplace_root: Path) -> Path:
+    source = item.get("source")
+    path_value = source.get("path") if isinstance(source, dict) else None
+    if not isinstance(path_value, str):
+        raise ValueError("official Codexy install has invalid metadata")
+    if not Path(path_value).is_absolute():
+        raise ValueError("official Codexy install path must be absolute")
+    root = _absolute(path_value)
+    expected = marketplace_root / "plugins" / "codexy"
+    if root != expected:
+        raise ValueError("official Codexy install must be inside its marketplace root")
+    _validate_real_path(root, require_exists=True)
+    return root