getcodexy 1.7.1__tar.gz → 1.7.2__tar.gz

{getcodexy-1.7.1 → getcodexy-1.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: getcodexy
-Version: 1.7.1
+Version: 1.7.2
 Summary: A Codex harness for coordinating agents through planning, implementation, verification, and review.
 Author: Eunsoo Lee
 License-Expression: MIT

{getcodexy-1.7.1 → getcodexy-1.7.2}/pyproject.toml

@@ -5,7 +5,7 @@ backend-path = ["."]
 
 [project]
 name = "getcodexy"
-version = "1.7.1"
+version = "1.7.2"
 description = "A Codex harness for coordinating agents through planning, implementation, verification, and review."
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.10"

{getcodexy-1.7.1 → getcodexy-1.7.2}/src/codexy_runtime_tools/_version_data/uv.lock

@@ -4,5 +4,5 @@ requires-python = ">=3.10"
 
 [[package]]
 name = "getcodexy"
-version = "1.7.1"
+version = "1.7.2"
 source = { editable = "." }

{getcodexy-1.7.1 → getcodexy-1.7.2}/src/codexy_runtime_tools/component-manifest.json

@@ -29,7 +29,7 @@
     {
       "id": "core",
       "plugin": "codexy",
-      "version": "1.7.1",
+      "version": "1.7.2",
       "dependencies": [],
       "asset": {
         "pluginId": "codexy@codexy",
@@ -38,6 +38,7 @@
           ".codex-plugin/plugin.json",
           "assets/codexy-icon.png",
           ".mcp.json",
+          "mcp/codexy_mcp_bootstrap.py",
           "mcp/codexy-mcp-watcher.sh",
           "mcp/codexy-mcp-watcher.cmd",
           "skills/dreaming/scripts/resumable-context-capsule.sh",
@@ -49,7 +50,7 @@
     {
       "id": "github",
       "plugin": "codexy-github",
-      "version": "1.7.1",
+      "version": "1.7.2",
       "dependencies": [
         "core"
       ],
@@ -65,7 +66,7 @@
     {
       "id": "devtools",
       "plugin": "codexy-devtools",
-      "version": "1.7.1",
+      "version": "1.7.2",
       "dependencies": [
         "core"
       ],
@@ -74,7 +75,8 @@
         "packageRoot": "plugins/codexy-devtools",
         "requiredPaths": [
           ".codex-plugin/plugin.json",
-          ".mcp.json"
+          ".mcp.json",
+          "mcp/codexy_mcp_bootstrap.py"
         ]
       }
     }
@@ -82,27 +84,27 @@
   "compatibleCombinations": [
     {
       "components": [],
-      "version": "1.7.1"
+      "version": "1.7.2"
     },
     {
       "components": [
         "core"
       ],
-      "version": "1.7.1"
+      "version": "1.7.2"
     },
     {
       "components": [
         "core",
         "github"
       ],
-      "version": "1.7.1"
+      "version": "1.7.2"
     },
     {
       "components": [
         "core",
         "devtools"
       ],
-      "version": "1.7.1"
+      "version": "1.7.2"
     },
     {
       "components": [
@@ -110,7 +112,7 @@
         "github",
         "devtools"
       ],
-      "version": "1.7.1"
+      "version": "1.7.2"
     }
   ]
 }

{getcodexy-1.7.1 → getcodexy-1.7.2}/src/codexy_runtime_tools/component_cli.py

@@ -138,6 +138,13 @@ def _human(command: str, receipt: dict[str, object]) -> str:
             )
             or "none",
         )
+    if command in {"install", "update", "remove", "bootstrap"} and receipt.get(
+        "outcome"
+    ) in {"completed", "pending-action"}:
+        return (
+            f"getcodexy {command}: {receipt['outcome']}; "
+            "start a fresh Codex task to refresh installed plugins and MCP tools"
+        )
     if command == "doctor":
         health = receipt.get("component_health", [])
         summary = (

{getcodexy-1.7.1 → getcodexy-1.7.2}/src/codexy_runtime_tools/component_health.py

@@ -10,11 +10,12 @@ from .component_capability_probe import (
 )
 from .component_capability_observation import component_observations
 from .component_hook_activation import ACTIVATION_STATES
+from .component_mcp_materialization import MCP_COMPONENTS, valid_component_mcp_cache
 from .component_health_support import (
     _authority_valid,
+    _health_plugin,
     _legacy_state,
     _observed,
-    _plugin_root,
     manifest_is_valid,
     record_version,
     version_relation,
@@ -31,6 +32,7 @@ def health(
     admission_error: str | None,
     host_error: bool,
     activation: dict[str, str] | None = None,
+    codex_home=None,
 ) -> list[dict[str, object]]:
     expected = set(recorded or ()) | set(actual)
     return [
@@ -42,6 +44,7 @@ def health(
             admission_error,
             host_error,
             activation,
+            codex_home,
         )
         for component in manifest.component_ids
         if component in expected
@@ -56,10 +59,11 @@ def _component_health(
     admission_error,
     host_error,
     activation,
+    codex_home,
 ):
     record = records.get(component)
     installed = component in actual
-    plugin = _plugin_root(record)
+    plugin = _health_plugin(manifest, component, record, codex_home)
     configured = bool(
         installed
         and plugin
@@ -67,11 +71,21 @@ def _component_health(
             plugin, manifest.component(component).plugin, record_version(record)
         )
         and valid_registration(plugin, component)
+        and (
+            component not in MCP_COMPONENTS
+            or valid_component_mcp_cache(codex_home, component, manifest.version)
+        )
     )
     result = dict(
         component=component,
         state=_legacy_state(
-            manifest, component, actual, records, admission_error, host_error
+            manifest,
+            component,
+            actual,
+            records,
+            admission_error,
+            host_error,
+            codex_home,
         ),
         installed=installed,
         configured=configured,

{getcodexy-1.7.1 → getcodexy-1.7.2}/src/codexy_runtime_tools/component_health_support.py

@@ -4,9 +4,13 @@ import json
 import os
 from pathlib import Path
 
+from .component_mcp_materialization import (
+    MCP_COMPONENTS,
+    component_cache_plugin,
+    mcp_spec,
+)
 from .component_manifest import ComponentManifest
 from .component_registration_health import valid_registration
-from .component_watcher_materialization import watcher_entrypoint
 from .component_resolver import ComponentResolutionError, compare_versions
 
 
@@ -15,17 +19,23 @@ SURFACE_PATHS = {
         "agents/catalog.toml",
         "hooks/hooks.json",
         "skills/wiki/SKILL.md",
-        ".mcp.json",
-        "mcp/codexy-mcp-watcher.sh",
-        "mcp/codexy-mcp-watcher.cmd",
+        *(path.as_posix() for path in mcp_spec("core").surface_paths),
     ),
     "github": ("agents/catalog.toml", "hooks/hooks.json"),
-    "devtools": ("mcp/codexy-mcp-devtools", ".mcp.json"),
+    "devtools": tuple(path.as_posix() for path in mcp_spec("devtools").surface_paths),
 }
 AUTHORITY_KEYS = ("authority", "artifact_authority", "artifactAuthority")
 
 
-def _legacy_state(manifest, component, actual, records, admission_error, host_error):
+def _legacy_state(
+    manifest,
+    component,
+    actual,
+    records,
+    admission_error,
+    host_error,
+    codex_home=None,
+):
     record = records.get(component)
     if admission_error or host_error:
         return "incompatible"
@@ -34,17 +44,13 @@ def _legacy_state(manifest, component, actual, records, admission_error, host_er
     relation = version_relation(manifest, record)
     if relation != 0:
         return "stale" if relation < 0 else "incompatible"
-    plugin = _plugin_root(record)
-    if plugin is None or not _required_files(manifest, component, plugin):
+    plugin = _health_plugin(manifest, component, record, codex_home)
+    if plugin is None or not _required_files(manifest, component, plugin, codex_home):
         return "stale"
     if not manifest_is_valid(
         plugin, manifest.component(component).plugin, record_version(record)
     ) or not valid_registration(plugin, component):
         return "incompatible"
-    if component == "devtools" and not os.access(
-        plugin / "mcp/codexy-mcp-devtools", os.X_OK
-    ):
-        return "stale"
     if component == "core" and any(
         os.path.lexists(plugin / path)
         for path in (".codex/lsp-client.json", "lsp", "runtime-release.json")
@@ -55,13 +61,23 @@ def _legacy_state(manifest, component, actual, records, admission_error, host_er
     return "healthy"
 
 
-def _required_files(manifest, component, plugin):
+def _required_files(manifest, component, plugin, codex_home=None):
     paths = (
         manifest.component(component).asset.required_paths + SURFACE_PATHS[component]
     )
     return all(
         (plugin / path).is_file() and not (plugin / path).is_symlink() for path in paths
-    ) and (component != "core" or watcher_entrypoint(plugin).is_file())
+    )
+
+
+def _health_plugin(manifest, component, record, codex_home=None):
+    plugin = _plugin_root(record)
+    if component not in MCP_COMPONENTS or codex_home is None:
+        return plugin
+    cache_root = codex_home / "plugins" / "cache"
+    if cache_root.is_symlink() or not cache_root.is_dir():
+        return plugin
+    return component_cache_plugin(codex_home, component, manifest.version)
 
 
 def _plugin_root(record):

{getcodexy-1.7.1 → getcodexy-1.7.2}/src/codexy_runtime_tools/component_inspection.py

@@ -6,12 +6,12 @@ from __future__ import annotations
 
 import os
 import subprocess
-from enum import Enum
 from pathlib import Path
 from typing import Callable
 
 from .component_hook_activation import HookLister, activation_for_inventory
 from .component_health import health as _health
+from .component_inspection_host import ProbeStage, host as _host
 from .component_inspection_types import InspectionReport
 from .component_inventory_classification import ComponentResolutionError
 from .component_inventory_classification import classify_installed_inventory
@@ -19,14 +19,13 @@ from .component_manifest import ComponentManifest, load_component_manifest
 from .component_observed_inventory import observe_installed_inventory
 from .component_resolver import admit_installed_inventory, canonical_components
 from .component_transaction_state import read_inventory
-from .github_pre_session import trusted_codex
 from .plugin_resolution import (
     MarketplaceBinding,
     marketplace_identity,
     named_marketplace,
     validate_local_marketplace,
 )
-from .pre_session import _find_codex, _json, _run
+from .pre_session import _json
 from .updater import _absolute, _validate_real_path
 
 
@@ -35,12 +34,6 @@ STATUS_SCHEMA = "getcodexy.status.v1"
 DOCTOR_SCHEMA = "getcodexy.doctor.v1"
 
 
-class ProbeStage(str, Enum):
-    EXECUTABLE = "codex-executable"
-    PLUGIN_LIST = "codex-plugin-list"
-    MARKETPLACE_LIST = "codex-marketplace-list"
-
-
 def status(
     codex_home: str | os.PathLike[str],
     *,
@@ -71,7 +64,8 @@ def doctor(
     hook_lister: HookLister | None = None,
 ) -> dict[str, object]:
     """Inspect canonical managed files and return actionable repairs."""
-    report = _inspect(codex_home, codex, runner, hook_lister)
+    home = _absolute(codex_home)
+    report = _inspect(home, codex, runner, hook_lister)
     missing_requirements: list[str] = (
         [report["host_error"]] if report["host_error"] else []
     )
@@ -97,6 +91,7 @@ def doctor(
             report["admission_error"],
             bool(report["host_error"]),
             report["activation"],
+            codex_home=home,
         ),
         "source_of_truth": "installed-component-inventory",
         "errors": report["errors"],
@@ -177,19 +172,6 @@ def _inspect(
     }
 
 
-def _host(
-    home: Path, codex: Path | None, runner: Runner | None
-) -> tuple[Path, Runner, None] | tuple[None, None, ProbeStage]:
-    try:
-        return (
-            trusted_codex(codex or _find_codex()),
-            runner or (lambda command: _run(command, home)),
-            None,
-        )
-    except (OSError, RuntimeError, ValueError):
-        return None, None, ProbeStage.EXECUTABLE
-
-
 def _recorded(
     home: Path,
 ) -> tuple[tuple[str, ...] | None, dict[str, object], str | None]:

getcodexy-1.7.2/src/codexy_runtime_tools/component_inspection_host.py

@@ -0,0 +1,33 @@
+"""Trusted host setup used by component inspection."""
+
+from __future__ import annotations
+
+import subprocess
+from enum import Enum
+from pathlib import Path
+from typing import Callable
+
+from .github_pre_session import trusted_codex
+from .pre_session import _find_codex, _run
+
+
+Runner = Callable[[list[str]], subprocess.CompletedProcess[str]]
+
+
+class ProbeStage(str, Enum):
+    EXECUTABLE = "codex-executable"
+    PLUGIN_LIST = "codex-plugin-list"
+    MARKETPLACE_LIST = "codex-marketplace-list"
+
+
+def host(
+    home: Path, codex: Path | None, runner: Runner | None
+) -> tuple[Path, Runner, None] | tuple[None, None, ProbeStage]:
+    try:
+        return (
+            trusted_codex(codex or _find_codex()),
+            runner or (lambda command: _run(command, home)),
+            None,
+        )
+    except (OSError, RuntimeError, ValueError):
+        return None, None, ProbeStage.EXECUTABLE

getcodexy-1.7.2/src/codexy_runtime_tools/component_lifecycle_mcp.py

@@ -0,0 +1,45 @@
+"""MCP source and cache materialization for component lifecycle operations."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from .component_manifest import ComponentManifest
+from .component_mcp_materialization import (
+    MCP_COMPONENTS,
+    materialize_component_mcp,
+    materialize_component_mcp_cache,
+)
+from .plugin_resolution import MarketplaceBinding, marketplace_path
+
+
+def materialize_mcp_sources(
+    root: MarketplaceBinding,
+    manifest: ComponentManifest,
+    components: tuple[str, ...],
+) -> None:
+    marketplace = marketplace_path(root)
+    for component in manifest.component_ids:
+        if component not in components or component not in MCP_COMPONENTS:
+            continue
+        plugin = marketplace / "plugins" / manifest.component(component).plugin
+        materialize_component_mcp(plugin, component, manifest.version)
+
+
+def materialize_mcp_caches(
+    home: Path,
+    root: MarketplaceBinding,
+    manifest: ComponentManifest,
+    components: tuple[str, ...],
+) -> None:
+    marketplace = marketplace_path(root)
+    for component in manifest.component_ids:
+        if component not in components or component not in MCP_COMPONENTS:
+            continue
+        source = marketplace / "plugins" / manifest.component(component).plugin
+        materialize_component_mcp_cache(
+            home,
+            component,
+            manifest.version,
+            source_plugin=source,
+        )

{getcodexy-1.7.1 → getcodexy-1.7.2}/src/codexy_runtime_tools/component_lifecycle_recovery.py

@@ -8,9 +8,9 @@ from typing import Callable
 
 from .component_hook_activation import HookLister
 from .component_lifecycle_finish import finish_committed
+from .component_lifecycle_mcp import materialize_mcp_caches, materialize_mcp_sources
 from .component_lifecycle_preflight import existing_marketplace
 from .component_manifest import ComponentManifest
-from .component_watcher_materialization import materialize_watcher
 from .component_resolver import (
     ComponentResolutionError,
     reconcile_installed_inventory,
@@ -28,7 +28,7 @@ from .component_transaction_state import (
 from .component_lifecycle_terminal import terminal
 from .marketplace_repin import reconcile_official_marketplace_root
 from .pre_session import _json, official_marketplace_root
-from .plugin_resolution import MarketplaceBinding, MarketplaceIdentity, marketplace_path
+from .plugin_resolution import MarketplaceBinding, MarketplaceIdentity
 
 
 Runner = Callable[[list[str]], subprocess.CompletedProcess[str]]
@@ -116,7 +116,7 @@ def rollback_or_raise(
 ) -> None:
     try:
         write_journal(home, journal.with_phase("rolling-back"))
-        restore_selection(executable, invoke, manifest, root, journal.before)
+        restore_selection(home, executable, invoke, manifest, root, journal.before)
         if (
             selection(manifest, list_installed(executable, invoke), root)
             != journal.before
@@ -161,6 +161,7 @@ def write_completed(
 
 
 def restore_selection(
+    home: Path,
     executable: Path,
     invoke: Runner,
     manifest: ComponentManifest,
@@ -168,12 +169,14 @@ def restore_selection(
     before: tuple[str, ...],
 ) -> None:
     current = selection(manifest, list_installed(executable, invoke), root)
+    materialize_mcp_sources(root, manifest, before)
     for component in before:
         if component not in current:
             mutate(executable, invoke, "add", manifest, component)
     for component in reversed(manifest.component_ids):
         if component in current and component not in before:
             mutate(executable, invoke, "remove", manifest, component)
+    materialize_mcp_caches(home, root, manifest, before)
 
 
 def apply_forward(
@@ -197,15 +200,14 @@ def apply_forward(
                 manifest.version,
                 home,
             )
-    if "core" in journal.target:
-        materialize_watcher(marketplace_path(root) / "plugins/codexy", home)
+    materialize_mcp_sources(root, manifest, journal.target)
     for component in adds:
         mutate(executable, invoke, "add", manifest, component)
     for component in removes:
         mutate(executable, invoke, "remove", manifest, component)
-    return verify_post_operation_inventory(
-        manifest, list_installed(executable, invoke), journal.target, root
-    )
+    installed = list_installed(executable, invoke)
+    materialize_mcp_caches(home, root, manifest, journal.target)
+    return verify_post_operation_inventory(manifest, installed, journal.target, root)
 
 
 def mutate(

getcodexy-1.7.2/src/codexy_runtime_tools/component_mcp_cache.py

@@ -0,0 +1,84 @@
+"""Safe synchronization helpers for component MCP cache surfaces."""
+
+from __future__ import annotations
+
+import os
+import stat
+import tempfile
+from pathlib import Path
+from typing import Iterable
+
+from .updater import _absolute, _validate_real_path
+
+
+def _needs_executable(path: Path) -> bool:
+    return path.name != "runtime-platform.sh" and path.suffix in {"", ".sh"}
+
+
+def _valid_surface_file(path: Path, *, executable: bool) -> bool:
+    try:
+        _validate_real_path(_absolute(path), require_exists=True)
+        metadata = path.lstat()
+    except (OSError, ValueError):
+        return False
+    if not stat.S_ISREG(metadata.st_mode) or stat.S_ISLNK(metadata.st_mode):
+        return False
+    return not executable or os.name == "nt" or os.access(path, os.X_OK)
+
+
+def _require_directory(path: Path, label: str) -> None:
+    _validate_real_path(_absolute(path), require_exists=True)
+    metadata = path.lstat()
+    if stat.S_ISLNK(metadata.st_mode) or not stat.S_ISDIR(metadata.st_mode):
+        raise RuntimeError(f"{label} is not a regular directory: {path}")
+
+
+def _sync_surface(source: Path, target: Path, paths: Iterable[Path]) -> None:
+    _require_directory(source, "MCP source plugin")
+    _require_directory(target, "MCP cache plugin")
+    for relative in paths:
+        source_path, target_path = source / relative, target / relative
+        if not _valid_surface_file(source_path, executable=_needs_executable(relative)):
+            raise RuntimeError(f"MCP source file is missing or invalid: {source_path}")
+        _validate_real_path(_absolute(target_path.parent), require_exists=False)
+        target_path.parent.mkdir(parents=True, exist_ok=True)
+        _validate_real_path(_absolute(target_path.parent), require_exists=True)
+        if _same_file(source_path, target_path):
+            continue
+        if os.path.lexists(target_path):
+            metadata = target_path.lstat()
+            if stat.S_ISLNK(metadata.st_mode) or not stat.S_ISREG(metadata.st_mode):
+                raise RuntimeError(
+                    f"MCP cache file is not a regular file: {target_path}"
+                )
+        _atomic_copy(source_path, target_path)
+
+
+def _same_file(source: Path, target: Path) -> bool:
+    try:
+        target_metadata = target.lstat()
+        return (
+            stat.S_ISREG(target_metadata.st_mode)
+            and not stat.S_ISLNK(target_metadata.st_mode)
+            and source.read_bytes() == target.read_bytes()
+            and stat.S_IMODE(source.stat().st_mode)
+            == stat.S_IMODE(target_metadata.st_mode)
+        )
+    except OSError:
+        return False
+
+
+def _atomic_copy(source: Path, target: Path) -> None:
+    descriptor, temporary_name = tempfile.mkstemp(
+        prefix=f".{target.name}.", suffix=".tmp", dir=target.parent
+    )
+    temporary = Path(temporary_name)
+    try:
+        with os.fdopen(descriptor, "wb") as output:
+            output.write(source.read_bytes())
+            output.flush()
+            os.fsync(output.fileno())
+        temporary.chmod(stat.S_IMODE(source.stat().st_mode))
+        os.replace(temporary, target)
+    finally:
+        temporary.unlink(missing_ok=True)