getcodexy 1.2.2__tar.gz → 1.4.0__tar.gz

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

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

getcodexy-1.4.0/build_backend.py

@@ -0,0 +1,51 @@
+"""Materialize getcodexy's canonical lockfile as uv_build package data."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import uv_build
+
+
+_ROOT = Path(__file__).resolve().parent
+_CANONICAL_LOCK = _ROOT / "uv.lock"
+_PACKAGED_LOCK = _ROOT / "src/codexy_runtime_tools/_version_data/uv.lock"
+
+
+def _materialize_version_lock() -> None:
+    contents = _CANONICAL_LOCK.read_bytes()
+    if not contents:
+        raise ValueError("packages/getcodexy/uv.lock must not be empty")
+    _PACKAGED_LOCK.parent.mkdir(parents=True, exist_ok=True)
+    _PACKAGED_LOCK.write_bytes(contents)
+
+
+def build_sdist(sdist_directory: str, config_settings: Any = None) -> str:
+    _materialize_version_lock()
+    return uv_build.build_sdist(sdist_directory, config_settings)
+
+
+def build_wheel(
+    wheel_directory: str,
+    config_settings: Any = None,
+    metadata_directory: str | None = None,
+) -> str:
+    _materialize_version_lock()
+    return uv_build.build_wheel(wheel_directory, config_settings, metadata_directory)
+
+
+def build_editable(
+    wheel_directory: str,
+    config_settings: Any = None,
+    metadata_directory: str | None = None,
+) -> str:
+    _materialize_version_lock()
+    return uv_build.build_editable(wheel_directory, config_settings, metadata_directory)
+
+
+get_requires_for_build_sdist = uv_build.get_requires_for_build_sdist
+get_requires_for_build_wheel = uv_build.get_requires_for_build_wheel
+get_requires_for_build_editable = uv_build.get_requires_for_build_editable
+prepare_metadata_for_build_wheel = uv_build.prepare_metadata_for_build_wheel
+prepare_metadata_for_build_editable = uv_build.prepare_metadata_for_build_editable

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

@@ -1,10 +1,11 @@
 [build-system]
 requires = ["uv_build==0.9.26"]
-build-backend = "uv_build"
+build-backend = "build_backend"
+backend-path = ["."]
 
 [project]
 name = "getcodexy"
-version = "1.2.2"
+version = "1.4.0"
 description = "Version-pinned MCP runtime bootstrap tools for Codexy"
 requires-python = ">=3.10"
 license = "MIT"
@@ -14,8 +15,12 @@ authors = [{ name = "Eunsoo Lee" }]
 Repository = "https://github.com/eunsoogi/codexy"
 
 [project.scripts]
+getcodexy = "codexy_runtime_tools.component_cli:main"
 codexy-mcp-runtime = "codexy_runtime_tools.runtime:main"
+codexy-github-install = "codexy_runtime_tools.github_pre_session:main"
+codexy-github-check = "codexy_runtime_tools.github_checks:main"
 
 [tool.uv.build-backend]
 module-name = "codexy_runtime_tools"
 module-root = "src"
+source-include = ["build_backend.py", "uv.lock"]

getcodexy-1.4.0/src/codexy_runtime_tools/_version_data/uv.lock

@@ -0,0 +1,8 @@
+version = 1
+revision = 3
+requires-python = ">=3.10"
+
+[[package]]
+name = "getcodexy"
+version = "1.4.0"
+source = { editable = "." }

getcodexy-1.4.0/src/codexy_runtime_tools/activation_transaction.py

@@ -0,0 +1,189 @@
+"""Narrow, no-follow rollback snapshot for public component activation."""
+
+from __future__ import annotations
+
+import os
+import stat
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(frozen=True)
+class Entry:
+    relative: Path
+    data: bytes | None
+    mode: int
+
+
+@dataclass(frozen=True)
+class ActivationSnapshot:
+    home: Path
+    entries: tuple[Entry, ...]
+
+    @classmethod
+    def capture(cls, home: Path) -> "ActivationSnapshot":
+        if not home.exists():
+            return cls(home, ())
+        files: list[Entry] = []
+        for root in (
+            Path("config.toml"),
+            Path("agents/codexy"),
+            Path("agents/codexy-github"),
+        ):
+            files.extend(_capture(home, root))
+        for backup in home.glob("config.toml.codexy-backup-*"):
+            files.extend(_capture(home, backup.relative_to(home)))
+        return cls(home, tuple(files))
+
+    def restore(self) -> None:
+        for root in (
+            Path("agents/codexy-github"),
+            Path("agents/codexy"),
+            Path("config.toml"),
+        ):
+            _remove_tree(self.home / root)
+        if self.home.exists():
+            for backup in self.home.glob("config.toml.codexy-backup-*"):
+                _remove_tree(backup)
+        if self.entries:
+            self.home.mkdir(parents=True, exist_ok=True)
+        for entry in sorted(self.entries, key=lambda item: len(item.relative.parts)):
+            path = self.home / entry.relative
+            if entry.data is None:
+                path.mkdir(mode=entry.mode, exist_ok=True)
+            else:
+                path.parent.mkdir(parents=True, exist_ok=True)
+                descriptor = os.open(
+                    path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, entry.mode
+                )
+                with os.fdopen(descriptor, "wb") as output:
+                    output.write(entry.data)
+        _remove_if_empty(self.home / "agents")
+        _remove_if_empty(self.home)
+
+
+def _capture(home: Path, relative: Path) -> list[Entry]:
+    path = home / relative
+    if not os.path.lexists(path):
+        return []
+    metadata = path.lstat()
+    _require_safe(metadata, path)
+    if stat.S_ISREG(metadata.st_mode):
+        return [
+            Entry(relative, _read_file(path, metadata), stat.S_IMODE(metadata.st_mode))
+        ]
+    descriptor = _open_directory(path, metadata)
+    try:
+        return _capture_directory(relative, descriptor)
+    finally:
+        os.close(descriptor)
+
+
+def _capture_directory(relative: Path, descriptor: int) -> list[Entry]:
+    metadata = os.fstat(descriptor)
+    _require_safe(metadata, relative)
+    entries = [Entry(relative, None, stat.S_IMODE(metadata.st_mode))]
+    for name in sorted(os.listdir(descriptor)):
+        child = os.stat(name, dir_fd=descriptor, follow_symlinks=False)
+        child_relative = relative / name
+        _require_safe(child, child_relative)
+        if stat.S_ISREG(child.st_mode):
+            entries.append(
+                Entry(
+                    child_relative,
+                    _read_child(descriptor, name, child),
+                    stat.S_IMODE(child.st_mode),
+                )
+            )
+            continue
+        child_descriptor = os.open(
+            name,
+            os.O_RDONLY | os.O_DIRECTORY | getattr(os, "O_NOFOLLOW", 0),
+            dir_fd=descriptor,
+        )
+        try:
+            opened = os.fstat(child_descriptor)
+            if (opened.st_dev, opened.st_ino) != (child.st_dev, child.st_ino):
+                raise ValueError(
+                    f"activation state changed while reading: {child_relative}"
+                )
+            entries.extend(_capture_directory(child_relative, child_descriptor))
+        finally:
+            os.close(child_descriptor)
+    return entries
+
+
+def _remove_tree(path: Path) -> None:
+    if not os.path.lexists(path):
+        return
+    metadata = path.lstat()
+    _require_safe(metadata, path)
+    if stat.S_ISREG(metadata.st_mode):
+        path.unlink()
+        return
+    for child in sorted(path.iterdir()):
+        _remove_tree(child)
+    path.rmdir()
+
+
+def _remove_if_empty(path: Path) -> None:
+    try:
+        path.rmdir()
+    except FileNotFoundError:
+        pass
+    except OSError:
+        pass
+
+
+def _read_file(path: Path, expected: os.stat_result) -> bytes:
+    descriptor = os.open(path, os.O_RDONLY | getattr(os, "O_NOFOLLOW", 0))
+    try:
+        return _read_descriptor(descriptor, expected, path)
+    finally:
+        os.close(descriptor)
+
+
+def _read_child(directory: int, name: str, expected: os.stat_result) -> bytes:
+    descriptor = os.open(
+        name, os.O_RDONLY | getattr(os, "O_NOFOLLOW", 0), dir_fd=directory
+    )
+    try:
+        return _read_descriptor(descriptor, expected, Path(name))
+    finally:
+        os.close(descriptor)
+
+
+def _read_descriptor(descriptor: int, expected: os.stat_result, path: Path) -> bytes:
+    opened = os.fstat(descriptor)
+    _require_safe(opened, path)
+    if (opened.st_dev, opened.st_ino) != (expected.st_dev, expected.st_ino):
+        raise ValueError(f"activation state changed while reading: {path}")
+    with os.fdopen(descriptor, "rb", closefd=False) as source:
+        return source.read()
+
+
+def _open_directory(path: Path, expected: os.stat_result) -> int:
+    descriptor = os.open(
+        path, os.O_RDONLY | os.O_DIRECTORY | getattr(os, "O_NOFOLLOW", 0)
+    )
+    opened = os.fstat(descriptor)
+    if (opened.st_dev, opened.st_ino) != (expected.st_dev, expected.st_ino):
+        os.close(descriptor)
+        raise ValueError(f"activation state changed while reading: {path}")
+    return descriptor
+
+
+def _require_safe(metadata: os.stat_result, path: Path) -> None:
+    reparse = getattr(stat, "FILE_ATTRIBUTE_REPARSE_POINT", 0x400)
+    if (
+        stat.S_ISLNK(metadata.st_mode)
+        or getattr(metadata, "st_file_attributes", 0) & reparse
+    ):
+        raise ValueError(f"activation state refuses link: {path}")
+    if stat.S_ISREG(metadata.st_mode) and metadata.st_nlink == 1:
+        return
+    if stat.S_ISDIR(metadata.st_mode):
+        return
+    raise ValueError(
+        f"activation state requires real directories and regular files: {path}"
+    )

{getcodexy-1.2.2 → getcodexy-1.4.0}/src/codexy_runtime_tools/cache.py

@@ -26,21 +26,36 @@ def plugin_release(manifest_path: Path, package_override: bool = False) -> str:
     return release
 
 
-def releases_match(expected_manifest: Path, observed_manifest: Path) -> tuple[bool, str]:
+def releases_match(
+    expected_manifest: Path, observed_manifest: Path
+) -> tuple[bool, str]:
     try:
         expected = plugin_release(expected_manifest)
     except (OSError, ValueError, json.JSONDecodeError):
-        return False, "runtime package release mismatch: expected valid plugin release, observed missing or invalid"
+        return (
+            False,
+            "runtime package release mismatch: expected valid plugin release, observed missing or invalid",
+        )
     try:
         observed = plugin_release(observed_manifest)
     except (OSError, ValueError, json.JSONDecodeError):
-        return False, f"runtime package release mismatch: expected {expected}, observed missing or invalid"
+        return (
+            False,
+            f"runtime package release mismatch: expected {expected}, observed missing or invalid",
+        )
     if expected != observed:
-        return False, f"runtime package release mismatch: expected {expected}, observed {observed}"
+        return (
+            False,
+            f"runtime package release mismatch: expected {expected}, observed {observed}",
+        )
     return True, ""
 
 
-def runtime_cache_key(*, manifest: Path, package_override: bool, identity: list[str]) -> str:
+def runtime_cache_key(
+    *, manifest: Path, package_override: bool, identity: list[str]
+) -> str:
     release = plugin_release(manifest, package_override)
-    digest_input = "\0".join(("codexy.runtime-cache/v2", *identity[:-1], release, identity[-1]))
+    digest_input = "\0".join(
+        ("codexy.runtime-cache/v2", *identity[:-1], release, identity[-1])
+    )
     return f"v2-{hashlib.sha256(digest_input.encode()).hexdigest()}"

getcodexy-1.4.0/src/codexy_runtime_tools/component-manifest.json

@@ -0,0 +1,106 @@
+{
+  "schema": "getcodexy.component-manifest.v1",
+  "marketplace": {
+    "name": "codexy",
+    "source": "https://github.com/eunsoogi/codexy.git"
+  },
+  "domainErrors": {
+    "component-version-mismatch": "Installed versions must match the post-operation manifest target.",
+    "components-not-accepted": "The command does not accept component arguments.",
+    "conflicting-component-request": "A component request contains a duplicate or conflicting operand.",
+    "conflicting-installed-state": "An installed record does not match its official marketplace asset.",
+    "dependency-protected-removal": "A retained component still requires a requested removal.",
+    "incompatible-component-selection": "A component selection is not in the manifest compatibility set.",
+    "inconsistent-installed-state": "The installed inventory violates component dependencies.",
+    "installed-state-mismatch": "The fresh installed inventory differs from the expected selection.",
+    "invalid-installed-inventory": "The host plugin inventory has an invalid shape.",
+    "missing-removal-target": "remove requires one or more component arguments.",
+    "mixed-version-state": "Installed components do not share one lockstep version.",
+    "no-recorded-selection": "update requires a recorded installed component inventory.",
+    "operation-failed": "A mutation did not complete and its pre-operation selection was restored.",
+    "unknown-component": "A named component is not core, github, or devtools.",
+    "unknown-installed-component": "The official Codexy marketplace inventory contains an unrecognized product."
+  },
+  "components": [
+    {
+      "id": "core",
+      "plugin": "codexy",
+      "version": "1.4.0",
+      "dependencies": [],
+      "asset": {
+        "pluginId": "codexy@codexy",
+        "packageRoot": "plugins/codexy",
+        "requiredPaths": [
+          ".codex-plugin/plugin.json",
+          "assets/codexy-icon.png"
+        ]
+      }
+    },
+    {
+      "id": "github",
+      "plugin": "codexy-github",
+      "version": "1.4.0",
+      "dependencies": [
+        "core"
+      ],
+      "asset": {
+        "pluginId": "codexy-github@codexy",
+        "packageRoot": "plugins/codexy-github",
+        "requiredPaths": [
+          ".codex-plugin/plugin.json",
+          "skills/git-workflow/SKILL.md"
+        ]
+      }
+    },
+    {
+      "id": "devtools",
+      "plugin": "codexy-devtools",
+      "version": "1.4.0",
+      "dependencies": [
+        "core"
+      ],
+      "asset": {
+        "pluginId": "codexy-devtools@codexy",
+        "packageRoot": "plugins/codexy-devtools",
+        "requiredPaths": [
+          ".codex-plugin/plugin.json",
+          ".mcp.json"
+        ]
+      }
+    }
+  ],
+  "compatibleCombinations": [
+    {
+      "components": [],
+      "version": "1.4.0"
+    },
+    {
+      "components": [
+        "core"
+      ],
+      "version": "1.4.0"
+    },
+    {
+      "components": [
+        "core",
+        "github"
+      ],
+      "version": "1.4.0"
+    },
+    {
+      "components": [
+        "core",
+        "devtools"
+      ],
+      "version": "1.4.0"
+    },
+    {
+      "components": [
+        "core",
+        "github",
+        "devtools"
+      ],
+      "version": "1.4.0"
+    }
+  ]
+}

getcodexy-1.4.0/src/codexy_runtime_tools/component_cli.py

@@ -0,0 +1,151 @@
+"""Public command line for transactional component lifecycle operations."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from pathlib import Path
+
+from .component_inspection import doctor, status
+from .component_lifecycle import PreAdmissionError, run_operation
+from .component_transaction_identity import operation_id
+from .component_transition_model import OperationReceipt
+from .component_transition_rejections import Rejection, RejectionStage, StateFailure
+from .monolith_migration import migrate
+from .version_lock import default_package_version
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(prog="getcodexy", allow_abbrev=False)
+    parser.add_argument(
+        "--codex",
+        type=Path,
+        help="optional absolute path supplied by the trusted Codex host",
+    )
+    parser.add_argument(
+        "--codex-home",
+        type=Path,
+        default=Path(os.environ.get("CODEX_HOME", Path.home() / ".codex")),
+    )
+    commands = parser.add_subparsers(dest="command", required=True)
+    for command in ("install", "update", "remove", "migrate"):
+        child = commands.add_parser(command, allow_abbrev=False)
+        child.add_argument("components", nargs="*")
+        child.add_argument("--json", action="store_true", dest="json_output")
+    for command in ("status", "doctor"):
+        child = commands.add_parser(command, allow_abbrev=False)
+        child.add_argument("--json", action="store_true", dest="json_output")
+    bootstrap = commands.add_parser("bootstrap", allow_abbrev=False)
+    bootstrap.add_argument("components", nargs="*")
+    bootstrap.add_argument("--json", action="store_true", dest="json_output")
+    arguments = parser.parse_args(argv)
+    try:
+        if arguments.command == "status":
+            receipt = status(arguments.codex_home, codex=arguments.codex)
+        elif arguments.command == "doctor":
+            receipt = doctor(arguments.codex_home, codex=arguments.codex)
+        elif arguments.command == "migrate":
+            if arguments.codex is None:
+                raise PreAdmissionError("migrate requires a trusted Codex executable")
+            receipt = migrate(
+                arguments.codex_home,
+                arguments.codex,
+                lambda command: _run_migration(command, arguments.codex_home),
+                tuple(arguments.components),
+            )
+        else:
+            receipt = run_operation(
+                arguments.command,
+                tuple(getattr(arguments, "components", ())),
+                arguments.codex_home,
+                arguments.codex,
+            )
+    except PreAdmissionError as error:
+        if arguments.command == "bootstrap" and arguments.json_output:
+            print(json.dumps(_bootstrap_host_failure(), sort_keys=True))
+            return 2
+        if arguments.command == "migrate" and arguments.json_output:
+            print(json.dumps(_migration_host_failure(), sort_keys=True))
+            return 2
+        print(f"getcodexy {arguments.command}: {error}", file=sys.stderr)
+        return 1
+    except Exception as error:
+        print(f"getcodexy {arguments.command}: {error}", file=sys.stderr)
+        return 1
+    if arguments.json_output:
+        print(json.dumps(receipt, sort_keys=True))
+    else:
+        print(_human(arguments.command, receipt))
+    unhealthy = arguments.command in {"status", "doctor"} and bool(
+        receipt.get("errors")
+    )
+    return 0 if receipt["outcome"] == "completed" and not unhealthy else 2
+
+
+def _run_migration(command: list[str], home: Path):
+    from .pre_session import _run
+
+    return _run(command, home)
+
+
+def _human(command: str, receipt: dict[str, object]) -> str:
+    if command == "status":
+        return "getcodexy status: installed={installed}; inventory={inventory}; consistency={consistency}; errors={errors}".format(
+            installed=",".join(receipt.get("installed_components", [])) or "none",
+            inventory=receipt.get("inventory", {}).get("state", "unknown")
+            if isinstance(receipt.get("inventory"), dict)
+            else "unknown",
+            consistency=receipt.get("inventory_consistency", "unknown"),
+            errors=",".join(
+                error.get("code", "unknown")
+                for error in receipt.get("errors", [])
+                if isinstance(error, dict)
+            )
+            or "none",
+        )
+    if command == "doctor":
+        health = receipt.get("component_health", [])
+        summary = (
+            ",".join(
+                f"{entry.get('component')}={entry.get('state')}:{entry.get('repair', 'none')}"
+                for entry in health
+                if isinstance(entry, dict)
+            )
+            or "none"
+        )
+        readiness = receipt.get("host_readiness", {})
+        missing = (
+            ",".join(readiness.get("missing_requirements", []))
+            if isinstance(readiness, dict)
+            else "unknown"
+        )
+        return f"getcodexy doctor: health={summary}; missing={missing or 'none'}; errors={','.join(error.get('code', 'unknown') for error in receipt.get('errors', []) if isinstance(error, dict)) or 'none'}"
+    return f"getcodexy {command}: {receipt['outcome']}"
+
+
+def _bootstrap_host_failure() -> dict[str, object]:
+    rejection = Rejection.from_failure(
+        RejectionStage.HOST, StateFailure.INCONSISTENT_INSTALLED_STATE
+    )
+    return OperationReceipt.rejected(
+        operation_id(None), "bootstrap", (), (), rejection
+    ).encode()
+
+
+def _migration_host_failure() -> dict[str, object]:
+    return {
+        "schema": "getcodexy.monolith-migration-receipt.v1",
+        "command": "migrate",
+        "outcome": "rejected",
+        "source_version": None,
+        "target_version": default_package_version(),
+        "selection_after": [],
+        "errors": [{"code": "trusted-codex-required"}],
+        "recovery": "rerun from the trusted Codex host",
+    }
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())