py-wlcli 0.8.0__tar.gz → 0.8.1__tar.gz

{py_wlcli-0.8.0 → py_wlcli-0.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: py_wlcli
-Version: 0.8.0
+Version: 0.8.1
 Summary: wl_cli - Python项目
 Project-URL: Homepage, https://gitlab.gewinnrobo.com/Humuyuan/wl-cli
 Project-URL: Issues, https://gitlab.gewinnrobo.com/Humuyuan/wl-cli/-/issues

py_wlcli-0.8.1/VERSION

@@ -0,0 +1 @@
+0.8.1

{py_wlcli-0.8.0 → py_wlcli-0.8.1}/src/wl_cli/capabilities.py

@@ -46,6 +46,7 @@ CAPABILITY_SINCE: dict[str, str] = {
     "env.repair": "0.8.0",
     "mcp.gitlab": "0.8.0",
     "mcp.k8s": "0.8.0",
+    "mcp.serve": "0.8.1",
     "test.clean_cache": "0.7.0",
 }
 

{py_wlcli-0.8.0 → py_wlcli-0.8.1}/src/wl_cli/cc/checks.py

@@ -15,7 +15,7 @@ the ticket cannot drift from the implementation:
 section      wlcc source
 ===========  ============================================================
 plugins      §1 required plugins + §7 context-mode (optional plugin)
-mcp          §3 plugin root, version stamp and interpreter visibility
+mcp          §3 registered wl command, version stamp, interpreter visibility
 settings     §5 gstack + §6 claude-mem (host-side configuration)
 stamps       §8 stamp registry (report only -- never delete)
 hooks        §9 dangling hook commands (read-only plan)
@@ -98,6 +98,20 @@ RETIRED_STAMPS = frozenset({"gemini-key.enc", "mcp-visionary-pending"})
 #: MCP servers check.sh §3 registers.
 MCP_SERVERS: tuple[str, ...] = ("gitlab", "k8s-diagnose")
 
+#: Registered server name -> ``wl mcp serve`` subcommand (#228). The server
+#: names are the stable interface (tool schema and existing user config); only
+#: the execution path moved from the plugin's ``mcp-tools/server.py`` to the
+#: wl CLI. ``k8s-diagnose`` keeps its name but serves ``wl mcp serve k8s``.
+MCP_SERVE_ARGS: dict[str, str] = {
+    "gitlab": "gitlab",
+    "k8s-diagnose": "k8s",
+}
+
+#: Capability the ``wl`` on ``PATH`` must advertise before a registration argv
+#: counts as verifiable (#228). Consumers (wlcc) use the same bit to decide
+#: that registration goes through ``wl mcp serve``.
+MCP_SERVE_CAPABILITY = "mcp.serve"
+
 #: Literal absolute path anchor from wlcc ``hooks-drift.py``: the dangling rule
 #: is exactly ``*/.claude/*``. Kept with the trailing slash on purpose.
 CLAUDE_SEG = "/.claude/"
@@ -475,7 +489,10 @@ def _interpreter_state(path: str, version: str, returncode: int) -> dict[str, An
 
 
 def _probe_python() -> dict[str, Any]:
-    """Resolve the interpreter MCP servers will run under (check.sh §3).
+    """Report the interpreter check.sh §3 used to run the MCP servers under.
+
+    Since #228 the servers run under ``wl mcp serve`` and no interpreter is
+    part of the registered argv, so the result is informational only.
 
     ``uv --no-cache python find 3.12`` resolves a local installation without
     downloading and keeps its cache in a temporary directory for the duration
@@ -518,8 +535,88 @@ def _probe_python() -> dict[str, Any]:
     return _interpreter_state(path, probe.stdout.strip(), probe.returncode)
 
 
+def _probe_wl_serve() -> dict[str, Any]:
+    """Probe the ``wl`` on ``PATH`` for the ``mcp.serve`` capability (#228).
+
+    The registration argv is ``<wl> mcp serve <sub>``, so the executable that
+    will be registered has to exist *and* advertise the capability. Asking it
+    for ``wl env check --json`` reads the same capability registry wlcc keys
+    off, instead of trusting the wl that happens to be running ``cc check``.
+    Every failure is a state value, never an exception.
+
+    Returns:
+        Fields ``path`` / ``state`` / ``version`` / ``capability``. ``state``
+        is ``ok:<version>`` when the capability is advertised, ``fail:absent``
+        when no ``wl`` is on ``PATH``, and ``fail:unusable`` /
+        ``fail:missing_capability`` (with a readable ``reason``) otherwise.
+    """
+    fields: dict[str, Any] = {
+        "path": None,
+        "state": "fail:absent",
+        "version": None,
+        "capability": MCP_SERVE_CAPABILITY,
+    }
+    wl = shutil.which("wl")
+    if wl is None:
+        return fields
+    fields["path"] = wl
+    try:
+        probe = subprocess.run(
+            [wl, "env", "check", "--json"],
+            capture_output=True,
+            text=True,
+            check=False,
+            timeout=30,
+        )
+    except (OSError, subprocess.SubprocessError) as exc:
+        fields.update(state="fail:unusable", reason=str(exc))
+        return fields
+    # ``env check`` exits 1 when the platform matrix says ``unverifiable`` but
+    # still emits the payload; parse first so a supported capability is not
+    # rejected because of an unrelated platform warning.
+    try:
+        payload = json.loads(probe.stdout)
+    except ValueError:
+        payload = None
+    if not isinstance(payload, dict):
+        fields.update(
+            state="fail:unusable",
+            reason=f"wl env check exited {probe.returncode} without a JSON payload",
+        )
+        return fields
+    version = payload.get("version")
+    fields["version"] = version if isinstance(version, str) else None
+    capabilities = payload.get("capabilities")
+    if isinstance(capabilities, list) and MCP_SERVE_CAPABILITY in capabilities:
+        fields["state"] = f"ok:{fields['version'] or 'unknown'}"
+        return fields
+    fields.update(
+        state="fail:missing_capability",
+        reason=f"{wl} does not advertise {MCP_SERVE_CAPABILITY}",
+    )
+    return fields
+
+
+def _wl_reason(fields: dict[str, Any]) -> str:
+    """Return a readable reason for a ``wl`` probe that is not ``ok``."""
+    state = str(fields.get("state", ""))
+    if state == "fail:absent":
+        return "the wl CLI is not on PATH"
+    reason = fields.get("reason")
+    if isinstance(reason, str) and reason:
+        return reason
+    return f"the wl CLI on PATH is not usable ({state or 'unknown state'})"
+
+
 def probe_mcp(host: HostContext) -> dict[str, Any]:
-    """§3: plugin-root trust, version stamp and interpreter visibility."""
+    """§3: the registration target, version stamp and interpreter visibility.
+
+    Since #228 the registered argv is ``<wl> mcp serve <sub>``: the probe
+    verifies that the ``wl`` on ``PATH`` exists and advertises ``mcp.serve``
+    instead of looking for a plugin-root ``mcp-tools/server.py``. The
+    interpreter probe stays a report field but can no longer gate the section
+    -- ``python`` is not part of the registered command any more.
+    """
     cache = _wlcc_cache(host)
     fields: dict[str, Any] = {
         "cache_root": str(cache),
@@ -528,6 +625,7 @@ def probe_mcp(host: HostContext) -> dict[str, Any]:
         "plugin_root": None,
         "rejected": False,
         "servers": list(MCP_SERVERS),
+        "wl": _probe_wl_serve(),
         "python": _probe_python(),
     }
     try:
@@ -552,17 +650,10 @@ def probe_mcp(host: HostContext) -> dict[str, Any]:
         fields["rejected"] = True
         return _result("unverifiable", root_error, **fields)
     fields["plugin_root"] = str(root)
-    server = root / ".claude" / "mcp-tools" / "server.py"
-    if server.is_symlink():
-        fields["rejected"] = True
-        return _result(
-            "unverifiable", f"MCP server script is a symlink: {server}", **fields
-        )
-    if not server.is_file():
-        fields["rejected"] = True
-        return _result(
-            "unverifiable", f"MCP server script is missing: {server}", **fields
-        )
+
+    wl_state = str(fields["wl"].get("state", ""))
+    if not wl_state.startswith("ok:"):
+        return _result("unverifiable", _wl_reason(fields["wl"]), **fields)
 
     if registered != version:
         return _result(
@@ -571,11 +662,6 @@ def probe_mcp(host: HostContext) -> dict[str, Any]:
             "wl cc repair will re-register",
             **fields,
         )
-    python_state = str(fields["python"].get("state", ""))
-    if not python_state.startswith(("supplied:", "ok:")):
-        return _result(
-            "dangling", f"MCP interpreter is not usable: {python_state}", **fields
-        )
     return _result("ok", None, **fields)
 
 

{py_wlcli-0.8.0 → py_wlcli-0.8.1}/src/wl_cli/cc/cli.py

@@ -278,7 +278,7 @@ def mcp_ensure(as_json: bool) -> None:
 @mcp_group.command(name="list")
 @click.option("--json", "as_json", is_flag=True, help=_JSON_HELP)
 def mcp_list(as_json: bool) -> None:
-    """Report the plugin root, interpreter, stamp and servers without writing."""
+    """Report the wl target, plugin root, interpreter, stamp and servers."""
     _run_single("cc mcp list", lambda: mutate.probe_section("mcp"), as_json)
 
 

{py_wlcli-0.8.0 → py_wlcli-0.8.1}/src/wl_cli/cc/mutate.py

@@ -488,22 +488,15 @@ def ensure_plugins() -> dict[str, Any]:
 # --------------------------------------------------------------------------- #
 
 
-def _mcp_script(plugin_root: Path, name: str) -> Path:
-    """Return the registered server script for *name* under the plugin root."""
-    tools = plugin_root / ".claude" / "mcp-tools"
-    if name == "gitlab":
-        return tools / "server.py"
-    return tools / name / "server.py"
-
-
 def ensure_mcp() -> dict[str, Any]:
-    """Re-register both MCP servers and write the version stamp only on success.
-
-    A rejected plugin root or an unusable interpreter is reported as
-    ``unverifiable`` and never registered -- the same closed set of states
-    ``check.sh`` §3 uses. The stamp is the idempotency latch, so it is written
-    only after *both* ``claude mcp add`` calls returned 0; one failure leaves
-    the old stamp in place and the next run retries.
+    """Re-register both MCP servers as ``wl mcp serve`` and stamp on success.
+
+    Since #228 the registered argv is ``<wl> mcp serve <sub>`` -- the plugin
+    tree's ``mcp-tools/server.py`` is neither required nor kept as a fallback.
+    A rejected plugin root or a missing/unusable ``wl`` is reported as
+    ``unverifiable`` and never registered. The stamp is the idempotency latch,
+    so it is written only after *both* ``claude mcp add`` calls returned 0; one
+    failure leaves the old stamp in place and the next run retries.
     """
     before = checks.probe_mcp(checks.load_host_context())
     fields = _section_fields(before)
@@ -521,15 +514,12 @@ def ensure_mcp() -> dict[str, Any]:
             changed,
             **fields,
         )
-    python = before.get("python")
-    python_path = python.get("path") if isinstance(python, dict) else None
-    python_state = python.get("state") if isinstance(python, dict) else None
-    if not isinstance(python_path, str) or not str(python_state).startswith(
-        ("supplied:", "ok:")
-    ):
+    wl_probe = before.get("wl")
+    wl = wl_probe.get("path") if isinstance(wl_probe, dict) else None
+    if not isinstance(wl, str) or not wl:
         return _result(
             "unverifiable",
-            f"MCP interpreter is not usable: {python_state}",
+            before.get("reason") or "the wl CLI is not on PATH",
             changed,
             **fields,
         )
@@ -541,9 +531,8 @@ def ensure_mcp() -> dict[str, Any]:
         )
 
     failures: list[str] = []
-    root = Path(plugin_root)
     for name in checks.MCP_SERVERS:
-        script = str(_mcp_script(root, name))
+        subcommand = checks.MCP_SERVE_ARGS[name]
         try:
             _run([claude, "mcp", "remove", name])
             proc = _run(
@@ -556,15 +545,17 @@ def ensure_mcp() -> dict[str, Any]:
                     "-s",
                     "user",
                     "--",
-                    python_path,
-                    script,
+                    wl,
+                    "mcp",
+                    "serve",
+                    subcommand,
                 ]
             )
         except (OSError, subprocess.SubprocessError) as exc:
             failures.append(f"{name}: {exc}")
             continue
         if proc.returncode == 0:
-            changed.append(f"mcp: registered {name} -> {script}")
+            changed.append(f"mcp: registered {name} -> {wl} mcp serve {subcommand}")
         else:
             failures.append(f"{name}: {_failure(proc)}")
 

py_wlcli-0.8.0/VERSION

@@ -1 +0,0 @@
-0.8.0