cdx-manager 0.12.4 → 0.14.0

package/src/config.py

@@ -7,6 +7,47 @@ PROVIDER_ANTIGRAVITY = "antigravity"
 PROVIDER_OLLAMA = "ollama"
 PROVIDERS = (PROVIDER_CODEX, PROVIDER_CLAUDE, PROVIDER_ANTIGRAVITY, PROVIDER_OLLAMA)
 
+# The values cdx accepts, defined once. Every validator, normalizer, and
+# `cdx schema --json` derives from these. They used to be restated in
+# cli_args, provider_runtime, and session_service — six copies for two
+# concepts — which let `cdx set` and `cdx run` disagree about the same
+# setting, and let `cdx schema --json` describe only one of them.
+# config.py owns them because it is the leaf: everything imports it and it
+# imports nothing of ours, so no ownership choice here can create a cycle.
+
+# Ordered weakest to strongest; the order is meaningful for comparisons such
+# as `--min-reasoning-effort`, so consumers must not re-sort it.
+REASONING_EFFORT_VALUES = ("minimal", "low", "medium", "high", "xhigh")
+
+# The canonical permissions, i.e. what cdx stores and what providers are
+# mapped from.
+PERMISSION_VALUES = ("review", "default", "auto", "full")
+
+# Provider-native spellings accepted as input and normalized to the
+# canonical value above, so a user can paste what their provider calls it.
+PERMISSION_ALIASES = {
+    "workspace-write": "default",
+    "read-only": "review",
+    "danger-full-access": "full",
+}
+
+# Everything accepted as input for a permission, canonical values first.
+PERMISSION_INPUT_VALUES = PERMISSION_VALUES + tuple(PERMISSION_ALIASES)
+
+
+def normalize_permission(value):
+    """Canonical form of a permission input, or None if it is not one.
+
+    Returning None rather than raising keeps the error message and error code
+    the caller's business: `cdx run` and `cdx set` word their failures
+    differently, but they must agree on what is valid.
+    """
+    if value is None:
+        return None
+    text = str(value).strip().lower()
+    text = PERMISSION_ALIASES.get(text, text)
+    return text if text in PERMISSION_VALUES else None
+
 
 def get_cdx_home(env=None):
     if env is None:

package/src/errors.py

@@ -2,3 +2,20 @@ class CdxError(Exception):
     def __init__(self, message, exit_code=1):
         super().__init__(message)
         self.exit_code = exit_code
+
+
+class CdxArgumentError(CdxError):
+    """A usage failure that names its own machine-readable code and arguments.
+
+    Programmatic callers used to get a single `invalid_request` code carrying the
+    whole human usage line, which made a missing `--cwd` indistinguishable from
+    passing a session name and `--provider` together. Raising this instead lets
+    the JSON payload report `code` plus the offending `arguments` as data, so a
+    caller never has to match on message text.
+    """
+
+    def __init__(self, message, *, code, arguments=(), allowed=None, exit_code=1):
+        super().__init__(message, exit_code)
+        self.code = code
+        self.arguments = tuple(arguments)
+        self.allowed = tuple(allowed) if allowed is not None else None

package/src/health.py

@@ -9,10 +9,23 @@ from datetime import datetime, timezone
 from urllib.parse import quote, unquote
 
 from .cli_render import _pad_table, _style
-from .config import PROVIDER_CODEX
-from .provider_runtime import codex_auth_diagnostic
+from .config import PROVIDER_ANTIGRAVITY, PROVIDER_CLAUDE, PROVIDER_CODEX, PROVIDER_OLLAMA
+from .provider_runtime import (
+    HEADLESS_CODEX_PERMISSION_ARGS,
+    LAUNCH_PERMISSION_ARGS,
+    codex_auth_diagnostic,
+)
 from .status_source import _extract_account_identity
 
+# The executable each provider is driven through, where it differs from the
+# provider name.
+PROVIDER_CLI_COMMANDS = {
+    PROVIDER_CODEX: "codex",
+    PROVIDER_CLAUDE: "claude",
+    PROVIDER_ANTIGRAVITY: "agy",
+    PROVIDER_OLLAMA: "ollama",
+}
+
 
 def _encode(name):
     return quote(name, safe="")
@@ -36,7 +49,14 @@ def _issue(status, code, message, detail=None, repairable=False):
     }
 
 
-def collect_health_report(service, base_dir, env=None, spawn_sync=None):
+def collect_health_report(service, base_dir, env=None, spawn_sync=None, check_provider_flags=False):
+    """Health report for the cdx home, sessions, and provider CLIs.
+
+    `check_provider_flags` is opt-in because it costs a provider CLI
+    invocation per configured provider. When it is off the report still says
+    so, rather than omitting the check silently — an absent check must not
+    read as a passing one.
+    """
     env = env or os.environ
     issues = []
 
@@ -96,6 +116,15 @@ def collect_health_report(service, base_dir, env=None, spawn_sync=None):
 
     issues.extend(_codex_shared_account_id_issues(codex_diagnostics))
     issues.extend(_collect_profile_issues(base_dir, session_names))
+    if check_provider_flags:
+        issues.extend(_provider_flag_issues(service, env, spawn_sync))
+    else:
+        issues.append(_issue(
+            "WARN",
+            "provider_permission_flags_unchecked",
+            "Provider permission flags were not verified; run cdx doctor --check-provider-flags",
+            {"reason": "opt_in", "cost": "one provider CLI invocation per configured provider"},
+        ))
     return {"base_dir": base_dir, "issues": issues, "summary": summarize_health(issues)}
 
 
@@ -143,6 +172,125 @@ def _extract_version(text):
     return match.group(1) if match else None
 
 
+def _mapped_provider_flags(provider):
+    """Every distinct flag cdx would pass to this provider, by permission.
+
+    Read off the same mappings the launch specs use, so a permission added
+    there is automatically covered here rather than quietly unverified.
+    Values (a sandbox name, a config expression) are not flags and are not
+    checked — only the options themselves.
+    """
+    mappings = {}
+    interactive = LAUNCH_PERMISSION_ARGS.get(provider)
+    if interactive is None:
+        # No entry at all means nobody declared this provider's mapping, which
+        # is different from declaring that it has none.
+        return {}
+    for permission, args in interactive.items():
+        mappings.setdefault(permission, set()).update(
+            arg for arg in args if arg.startswith("-")
+        )
+    if provider == PROVIDER_CODEX:
+        for permission, args in HEADLESS_CODEX_PERMISSION_ARGS.items():
+            mappings.setdefault(permission, set()).update(
+                arg for arg in args if arg.startswith("-")
+            )
+    return {permission: sorted(flags) for permission, flags in mappings.items() if flags}
+
+
+def _provider_help_text(command, env, spawn_sync=None):
+    """The provider CLI's own option list, or None if it cannot be obtained.
+
+    Help output is the cheapest authoritative answer to "does this CLI accept
+    this flag". Launching a real run would be authoritative too, and far more
+    expensive for a diagnostic.
+    """
+    try:
+        if spawn_sync:
+            result = spawn_sync(command, ["--help"], {"env": env, "timeout": 10})
+            if isinstance(result, dict):
+                text = f"{result.get('stdout') or ''}\n{result.get('stderr') or ''}"
+            else:
+                text = f"{getattr(result, 'stdout', '') or ''}\n{getattr(result, 'stderr', '') or ''}"
+        else:
+            completed = subprocess.run(
+                [command, "--help"], env=env, capture_output=True, text=True, timeout=10, check=False,
+            )
+            text = f"{completed.stdout or ''}\n{completed.stderr or ''}"
+    except (OSError, subprocess.TimeoutExpired):
+        return None
+    return text if text.strip() else None
+
+
+def _provider_flag_issues(service, env, spawn_sync=None):
+    """Verify the flags cdx maps for each permission exist in the provider CLI.
+
+    GitHub issue #8 was exactly this going unchecked: `--experimental-yolo` was
+    mapped for ollama, a flag that CLI never had, and nothing noticed until a
+    user ran `permission=full` on an ollama session.
+
+    An unverifiable mapping reports WARN, never OK: "we could not check" is the
+    state that bug lived in for months, and it must not read as a pass.
+    """
+    issues = []
+    providers = sorted({
+        session.get("provider") for session in service["list_sessions"]()
+        if session.get("provider")
+    })
+    for provider in providers:
+        command = PROVIDER_CLI_COMMANDS.get(provider, provider)
+        mappings = _mapped_provider_flags(provider)
+        if not mappings:
+            issues.append(_issue(
+                "OK",
+                f"{provider}_permission_flags",
+                f"{provider} maps no permission to CLI flags; nothing to verify",
+                {"provider": provider, "command": command, "mapped": {}},
+            ))
+            continue
+        if not shutil.which(command, path=env.get("PATH")):
+            issues.append(_issue(
+                "WARN",
+                f"{provider}_permission_flags",
+                f"{provider} CLI not installed; mapped permission flags could not be verified",
+                {"provider": provider, "command": command, "mapped": mappings},
+            ))
+            continue
+        help_text = _provider_help_text(command, env, spawn_sync)
+        if help_text is None:
+            issues.append(_issue(
+                "WARN",
+                f"{provider}_permission_flags",
+                f"{provider} CLI help could not be read; mapped permission flags could not be verified",
+                {"provider": provider, "command": command, "mapped": mappings},
+            ))
+            continue
+        missing = {
+            permission: [flag for flag in flags if flag not in help_text]
+            for permission, flags in mappings.items()
+        }
+        missing = {permission: flags for permission, flags in missing.items() if flags}
+        detail = {"provider": provider, "command": command, "mapped": mappings, "missing": missing}
+        if missing:
+            described = "; ".join(
+                f"{permission}: {', '.join(flags)}" for permission, flags in sorted(missing.items())
+            )
+            issues.append(_issue(
+                "FAIL",
+                f"{provider}_permission_flags",
+                f"{provider} CLI does not accept flags cdx maps ({described})",
+                detail,
+            ))
+        else:
+            issues.append(_issue(
+                "OK",
+                f"{provider}_permission_flags",
+                f"{provider} CLI accepts every flag cdx maps for its permissions",
+                detail,
+            ))
+    return issues
+
+
 def _provider_capability_hints(command):
     if command == "codex":
         return [

package/src/notify.py

@@ -7,11 +7,11 @@ import time
 from datetime import datetime, timedelta
 
 from .errors import CdxError
+from .session_ranking import rank_sessions
 from .status_view import (
     PRIORITY_EMPTY_AVAILABLE_THRESHOLD,
     _parse_reset_timestamp,
     _priority_reset_timestamp,
-    _recommend_priority_sessions,
 )
 
 NOTIFY_USAGE = "Usage: cdx notify <name> --at-reset [--poll seconds] [--once] [--schedule] [--refresh] | cdx notify --next-ready [--poll seconds] [--once] [--schedule] [--refresh]"
@@ -103,10 +103,16 @@ def resolve_notify_event(rows, parsed, now_ts=None):
     now_ts = time.time() if now_ts is None else now_ts
     if parsed["mode"] == "next-ready":
         active_rows = [row for row in rows if row.get("enabled", True) is not False]
-        priority = _recommend_priority_sessions([
-            row for row in active_rows
-            if not _is_usable_now(row) and _priority_reset_timestamp(row) is not None
-        ])
+        # Same ranking every other selector uses; the pre-filter is what makes
+        # this "next to come back" rather than "best right now".
+        priority, _decision = rank_sessions(
+            [
+                row for row in active_rows
+                if not _is_usable_now(row) and _priority_reset_timestamp(row) is not None
+            ],
+            now_ts,
+            _priority_reset_timestamp,
+        )
         if not priority:
             return _event(False, "cdx", "No upcoming session reset available", None)
         first = priority[0]

package/src/provider_runtime.py

@@ -12,7 +12,13 @@ from datetime import datetime, timezone
 
 from .claude_usage import _clean_oauth_token, _decode_jwt_claims
 from .codex_usage import codex_auth_lock
-from .config import PROVIDER_ANTIGRAVITY, PROVIDER_CLAUDE, PROVIDER_CODEX, PROVIDER_OLLAMA
+from .config import (
+    PROVIDER_ANTIGRAVITY,
+    PROVIDER_CLAUDE,
+    PROVIDER_CODEX,
+    PROVIDER_OLLAMA,
+    REASONING_EFFORT_VALUES,
+)
 from .errors import CdxError
 
 LOG_ROTATE_BYTES = 10 * 1024 * 1024  # 10 MB
@@ -21,7 +27,6 @@ CODEX_INTERACTIVE_AUTH_LOCK_TIMEOUT_SECONDS = 10
 AUTH_PROBE_AUTHENTICATED = "authenticated"
 AUTH_PROBE_LOGGED_OUT = "logged_out"
 AUTH_PROBE_DEGRADED = "degraded"
-REASONING_EFFORT_VALUES = {"minimal", "low", "medium", "high", "xhigh"}
 RTK_PROMPT = (
     "When running noisy shell commands, prefer RTK wrappers (`rtk <command>`) if `rtk` is available. "
     "Use raw commands when exact, unfiltered output is required."
@@ -47,6 +52,15 @@ LAUNCH_PERMISSION_ARGS = {
         "auto": ["-s", "workspace-write", "-a", "never"],
         "full": ["-s", "danger-full-access", "-a", "never"],
     },
+    PROVIDER_ANTIGRAVITY: {
+        "review": ["--sandbox"],
+        "full": ["--dangerously-skip-permissions"],
+    },
+    # ollama has no sandbox or permission concept, so it maps to nothing. The
+    # entry is present and deliberately empty: that is what tells the
+    # provider-flag health check there is nothing to verify here, as opposed to
+    # a provider whose mapping nobody ever declared.
+    PROVIDER_OLLAMA: {},
 }
 HEADLESS_CODEX_PERMISSION_ARGS = {
     "review": ["-s", "read-only"],
@@ -54,6 +68,30 @@ HEADLESS_CODEX_PERMISSION_ARGS = {
     "auto": ["-s", "workspace-write", "-c", 'approval_policy="never"'],
     "full": ["--dangerously-bypass-approvals-and-sandbox"],
 }
+
+
+def headless_permission_disables_network(provider, permission):
+    """True when this provider/permission pair silently costs the run network access.
+
+    Codex ties network access to its sandbox: every permission except `full`
+    maps to `-s <sandbox>` above, and inside that sandbox a tool like `gh`
+    cannot resolve DNS. The run still exits zero, so without a warning the
+    caller only finds out by reading the transcript.
+
+    Read off the same mapping the launch spec uses rather than a parallel list
+    of permissions, so adding a permission cannot leave this behind.
+
+    No permission at all is the common case, not an exemption: the launch spec
+    simply appends no sandbox flag, and `codex exec` then applies its own
+    sandboxed default. Only an explicit `full` actually buys network access.
+    """
+    if provider != PROVIDER_CODEX:
+        return False
+    if not permission:
+        return True
+    return "-s" in HEADLESS_CODEX_PERMISSION_ARGS.get(permission, [])
+
+
 REDACTED_PROMPT_ARG = "[prompt redacted]"
 CLAUDE_CLI_MODEL_ALIASES = {
     "claude-sonnet": "sonnet",
@@ -328,15 +366,12 @@ def _launch_config_args(session):
         if permission:
             args += LAUNCH_PERMISSION_ARGS[PROVIDER_CLAUDE].get(permission, [])
         return args
-    if provider == PROVIDER_ANTIGRAVITY:
-        if permission == "review":
-            args += ["--sandbox"]
-        if permission == "full":
-            args += ["--dangerously-skip-permissions"]
-        return args
-    if provider == PROVIDER_OLLAMA:
-        if permission == "full":
-            args += ["--experimental-yolo"]
+    if provider in (PROVIDER_ANTIGRAVITY, PROVIDER_OLLAMA):
+        # Both read their mapping from the shared table rather than inline
+        # branches, so the provider-flag health check can verify what they emit
+        # instead of a hand-copied restatement of it.
+        if permission:
+            args += LAUNCH_PERMISSION_ARGS[provider].get(permission, [])
         return args
     if power:
         args += ["-c", f'model_reasoning_effort="{power}"']

package/src/run_command.py

@@ -1,12 +1,27 @@
 import os
+import sys
 
-from .errors import CdxError
+from .cli_args import ARG_CODE_INVALID_VALUE
+from .errors import CdxArgumentError, CdxError
+from .provider_runtime import headless_permission_disables_network
 from .run_usage import empty_usage, extract_run_usage
 
+PROMPT_STDIN = "-"
 
-def read_run_prompt(parsed):
+
+def read_run_prompt(parsed, stdin=None):
     if parsed.get("prompt") is not None:
         return parsed["prompt"]
+    if parsed.get("prompt_file") == PROMPT_STDIN:
+        stream = stdin if stdin is not None else sys.stdin
+        if stream is None or getattr(stream, "isatty", lambda: False)():
+            raise CdxArgumentError(
+                "cdx run: --prompt-file - reads the prompt from standard input, but standard "
+                "input is a terminal. Pipe the prompt in, or pass a file path.",
+                code=ARG_CODE_INVALID_VALUE,
+                arguments=["--prompt-file"],
+            )
+        return stream.read()
     try:
         with open(parsed["prompt_file"], encoding="utf-8") as handle:
             return handle.read()
@@ -15,6 +30,9 @@ def read_run_prompt(parsed):
 
 
 def run_cdx_error_code(error):
+    code = getattr(error, "code", None)
+    if code:
+        return code
     message = str(error)
     if message.startswith("Usage:"):
         return "invalid_request"
@@ -73,8 +91,96 @@ def _provider_failure_message(error, run_info, error_code):
     return f"{base}: {detail}" if detail else base
 
 
+def run_error_arguments(error):
+    """The argument names a `CdxArgumentError` blames, as data.
+
+    Always a list so the error object keeps one shape: an empty list means the
+    failure is not about specific arguments, never that the caller should go
+    parse the message to find out.
+    """
+    return list(getattr(error, "arguments", ()) or [])
+
+
+def run_error_allowed_values(error):
+    allowed = getattr(error, "allowed", None)
+    return list(allowed) if allowed else None
+
+
+def run_effective_permission(parsed, session):
+    launch = (session.get("launch") or {}) if session else {}
+    return parsed.get("permission") or launch.get("permission")
+
+
+def run_warnings(parsed, session, selection_row=None):
+    """Known degradations that a zero exit code would otherwise hide.
+
+    Emitted on success as much as on failure: the whole point is that the run
+    looks fine and quietly did less than it was asked to.
+    """
+    warnings = []
+    if selection_row is not None and selection_row.get("available_pct") is None:
+        # Auto-selection ranked this session without ever having seen its
+        # status. That is not "low availability" — it is no information, and on
+        # a freshly imported or long-idle set of sessions it is the normal case.
+        warnings.append({
+            "code": "session_selected_without_status",
+            "message": (
+                f"Session {selection_row.get('session_name')!r} was auto-selected without any "
+                "recorded availability; the choice was made on missing status data. "
+                "Pass --refresh to fetch status before selecting."
+            ),
+            "session": selection_row.get("session_name"),
+        })
+    provider = session.get("provider") if session else parsed.get("provider")
+    permission = run_effective_permission(parsed, session)
+    if headless_permission_disables_network(provider, permission):
+        described = repr(permission) if permission else "its default (none set)"
+        warnings.append({
+            "code": "network_disabled_by_permission",
+            "message": (
+                f"{provider} runs at permission {described} inside a sandbox with no network "
+                "access, so tools needing the network (DNS, HTTPS) fail inside this run even "
+                "though it exits successfully. Use --permission full if the run needs network."
+            ),
+            "provider": provider,
+            "permission": permission,
+        })
+    return warnings
+
+
+def run_launch_payload(api_schema_version, parsed, session, artifacts, cwd=None,
+                       pid=None, launch_log_path=None, selection_row=None):
+    """Payload for a detached launch: identity and artifact paths, no outcome.
+
+    Deliberately shaped like `run_result_payload` minus the fields only a
+    finished run can fill (`exit_code`, `duration_seconds`, `usage`), so a
+    caller reads `run_id` from the same place either way.
+    """
+    return {
+        "schema_version": api_schema_version,
+        "ok": True,
+        "action": "run",
+        "launcher": "cdx",
+        "detached": True,
+        "session": session.get("name") if session else None,
+        "provider": session.get("provider") if session else parsed.get("provider"),
+        "model": parsed.get("model") or ((session.get("launch") or {}).get("model") if session else None),
+        "reasoning_effort": run_payload_reasoning_effort(parsed, session),
+        "power": parsed.get("power") or ((session.get("launch") or {}).get("power") if session else None),
+        "cwd": os.path.abspath(cwd or parsed.get("cwd") or os.getcwd()),
+        "run_id": artifacts.get("run_id"),
+        "pid": pid,
+        "transcript_path": artifacts.get("transcript_path"),
+        "stdout_path": artifacts.get("stdout_path"),
+        "stderr_path": artifacts.get("stderr_path"),
+        "launch_log_path": launch_log_path,
+        "warnings": run_warnings(parsed, session, selection_row),
+        "error": None,
+    }
+
+
 def run_result_payload(api_schema_version, ok, parsed, session, run_info=None,
-                       error=None, error_source=None, error_code=None):
+                       error=None, error_source=None, error_code=None, selection_row=None):
     run_info = run_info or {}
     usage = run_info.get("usage") if isinstance(run_info.get("usage"), dict) else (
         extract_run_usage(session.get("provider"), run_info.get("stdout_path"))
@@ -104,11 +210,13 @@ def run_result_payload(api_schema_version, ok, parsed, session, run_info=None,
         "stdout_path": run_info.get("stdout_path"),
         "stderr_path": run_info.get("stderr_path"),
         "usage": usage,
-        "warnings": [],
+        "warnings": run_warnings(parsed, session, selection_row),
         "error": None if ok else {
             "source": error_source or "cdx",
             "code": error_code or "cdx_error",
             "message": message,
+            "arguments": run_error_arguments(error),
+            "allowed_values": run_error_allowed_values(error),
             "provider_code": run_info.get("returncode") if error_source == "provider" else None,
         },
     }

package/src/run_registry.py

@@ -75,6 +75,26 @@ def _is_pid_alive(pid):
         return False
 
 
+def _completed_after(run, since):
+    """True when this run finished strictly after `since`.
+
+    `since` is timezone-aware (the CLI resolves it in local time); stored
+    timestamps are UTC with a `Z` suffix. A record with an unparseable or
+    missing `ended_at` is treated as not-yet-completed rather than matching, so
+    a corrupt row cannot be reported as freshly finished on every poll.
+    """
+    ended_at = run.get("ended_at")
+    if not ended_at:
+        return False
+    try:
+        ended = datetime.fromisoformat(str(ended_at).replace("Z", "+00:00"))
+    except ValueError:
+        return False
+    if ended.tzinfo is None:
+        ended = ended.replace(tzinfo=timezone.utc)
+    return ended > since
+
+
 def _refresh_stale_runs(data):
     now = utc_now_iso()
     changed = False
@@ -128,6 +148,24 @@ class RunRegistry:
             _write_registry(self.path, data)
         return record
 
+    def set_pid(self, run_id, pid):
+        """Point a registered run at the process actually doing the work.
+
+        `start()` records the caller's own pid, which is right when that caller
+        stays to supervise. A detached launch does not: it returns immediately,
+        so its pid dies within seconds and `_refresh_stale_runs` would find no
+        live process, mark the run `stale`, and stamp an `ended_at` — reporting
+        a run that is still going as finished, including to `list(since=...)`.
+        """
+        with _registry_lock(self.path):
+            data = _read_registry(self.path)
+            for run in data["runs"]:
+                if run.get("run_id") == run_id:
+                    run["pid"] = pid
+                    _write_registry(self.path, data)
+                    return run
+        return None
+
     def finish(self, run_id, *, status, final_payload=None, run_info=None, error=None, task_report=None):
         with _registry_lock(self.path):
             return self._finish_locked(run_id, status=status, final_payload=final_payload, run_info=run_info, error=error, task_report=task_report)
@@ -167,13 +205,26 @@ class RunRegistry:
             return run
         return None
 
-    def list(self, limit=20):
+    def list(self, limit=20, since=None):
+        """Recent runs, newest first.
+
+        `since` selects every run that *completed* strictly after that moment
+        and bypasses `limit` entirely. A cursor caller is asking "what finished
+        since I last looked"; capping that by row count would hand back a
+        truncated answer that looks complete, which is the silent miss the
+        cursor exists to remove. Runs still in flight have no completion time
+        and are excluded — they will be returned by a later call, once they
+        have actually completed.
+        """
         with _registry_lock(self.path):
             data = _read_registry(self.path)
             changed = _refresh_stale_runs(data)
             if changed:
                 _write_registry(self.path, data)
-        return data["runs"][: max(0, int(limit or 20))]
+        runs = data["runs"]
+        if since is not None:
+            return [run for run in runs if _completed_after(run, since)]
+        return runs[: max(0, int(limit or 20))]
 
     def get(self, run_id):
         with _registry_lock(self.path):