vmware-storage 2.4.0__tar.gz → 2.4.1__tar.gz

{vmware_storage-2.4.0 → vmware_storage-2.4.1}/.claude-plugin/plugin.json

@@ -2,7 +2,7 @@
   "$schema": "https://anthropic.com/claude-code/plugin.schema.json",
   "name": "vmware-storage",
   "displayName": "VMware Storage",
-  "version": "2.4.0",
+  "version": "2.4.1",
   "description": "VMware vSphere storage with 15 MCP tools: datastores, iSCSI, vSAN, FC multipath.",
   "author": {
     "name": "Wei Zhou",

{vmware_storage-2.4.0 → vmware_storage-2.4.1}/.mcp.json

@@ -5,7 +5,7 @@
       "command": "uvx",
       "args": [
         "--from",
-        "vmware-storage==2.4.0",
+        "vmware-storage==2.4.1",
         "vmware-storage-mcp"
       ]
     }

{vmware_storage-2.4.0 → vmware_storage-2.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: vmware-storage
-Version: 2.4.0
+Version: 2.4.1
 Summary: VMware vSphere storage management: datastores, iSCSI, vSAN. Domain-focused MCP skill.
 Project-URL: Homepage, https://github.com/vmware-skills/VMware-Storage
 Project-URL: Repository, https://github.com/vmware-skills/VMware-Storage

{vmware_storage-2.4.0 → vmware_storage-2.4.1}/RELEASE_NOTES.md

@@ -1,3 +1,15 @@
+## v2.4.1 — fixes from real-hardware testing (2026-10-17)
+
+* **`list_cached_images` returns what was scanned.** Nothing ever wrote the cache it reads, so it was always empty.
+  `scan_datastore_images` now replaces that target's entries for the scanned datastore folder; entries carry
+  `target`, so `datastore1` on two hosts stays apart. The cache file is written atomically under a lock; a cache that
+  cannot be read or written is reported in `cache_note` and does not fail the scan.
+* **`browse_datastore` / `scan_datastore_images` return well-formed `ds_path`s** for both ESXi and vCenter folder
+  paths (an ESXi browse produced `[datastore1] backupX.iso`). A leading `/` is still refused; the error now names the
+  corrected path, and vmware-aiops follows the same rule.
+* Error hints: `doctor` is suggested for connection and credential problems, not for an invalid path or an unknown
+  target; the unknown-target error names `target=` with the CLI flag in brackets.
+
 ## v2.4.0 — roles for network callers (HLD §18)
 
 * Declares the role metadata vmware-policy ≥ 1.24.0 needs to apply **roles** to this server over HTTPS

{vmware_storage-2.4.0 → vmware_storage-2.4.1}/openclaw.plugin.json

@@ -11,7 +11,7 @@
       "command": "uvx",
       "args": [
         "--from",
-        "vmware-storage==2.4.0",
+        "vmware-storage==2.4.1",
         "vmware-storage-mcp"
       ]
     }

{vmware_storage-2.4.0 → vmware_storage-2.4.1}/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zw008/vmware-storage",
-  "version": "2.4.0",
+  "version": "2.4.1",
   "description": "VMware vSphere storage with 15 MCP tools: datastores, iSCSI, vSAN, FC multipath.",
   "private": true,
   "license": "MIT",

{vmware_storage-2.4.0 → vmware_storage-2.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "vmware-storage"
-version = "2.4.0"
+version = "2.4.1"
 description = "VMware vSphere storage management: datastores, iSCSI, vSAN. Domain-focused MCP skill."
 readme = "README.md"
 license = "MIT"

{vmware_storage-2.4.0 → vmware_storage-2.4.1}/server.json

@@ -7,12 +7,12 @@
     "url": "https://github.com/vmware-skills/VMware-Storage",
     "source": "github"
   },
-  "version": "2.4.0",
+  "version": "2.4.1",
   "packages": [
     {
       "registryType": "pypi",
       "identifier": "vmware-storage",
-      "version": "2.4.0",
+      "version": "2.4.1",
       "runtimeHint": "uvx",
       "packageArguments": [
         {

{vmware_storage-2.4.0 → vmware_storage-2.4.1}/skills/vmware-storage/SKILL.md

@@ -40,7 +40,7 @@ VMware vSphere storage management — 15 MCP tools for datastores, iSCSI, vSAN,
 ## Quick Install
 
 ```bash
-uv tool install vmware-storage==2.4.0
+uv tool install vmware-storage==2.4.1
 vmware-storage init      # guided setup: writes config + .env (chmod 600, password grep-safe), then verifies
 vmware-storage doctor
 ```
@@ -271,7 +271,7 @@ Corporate TLS proxies inject certificates that uv's bundled CA store doesn't tru
 ## Setup
 
 ```bash
-uv tool install vmware-storage==2.4.0
+uv tool install vmware-storage==2.4.1
 mkdir -p ~/.vmware-storage
 cp config.example.yaml ~/.vmware-storage/config.yaml
 # Edit config.yaml with your vCenter/ESXi targets

{vmware_storage-2.4.0 → vmware_storage-2.4.1}/skills/vmware-storage/references/setup-guide.md

@@ -13,19 +13,19 @@ Complete setup and security guide for `vmware-storage`.
 ### Via uv (recommended)
 
 ```bash
-uv tool install vmware-storage==2.4.0
+uv tool install vmware-storage==2.4.1
 ```
 
 ### Via pip
 
 ```bash
-pip install vmware-storage==2.4.0
+pip install vmware-storage==2.4.1
 ```
 
 ### From source
 
 ```bash
-git clone --branch v2.4.0 https://github.com/vmware-skills/VMware-Storage.git
+git clone --branch v2.4.1 https://github.com/vmware-skills/VMware-Storage.git
 cd VMware-Storage
 pip install -e .
 ```

vmware_storage-2.4.1/tests/eval/regression/test_browse_ds_path_join.py

@@ -0,0 +1,79 @@
+"""browse_datastore must return a ds_path that deploy/attach tools can use.
+
+Regression source: real ESXi 8 host (home-esxi, 2026-10-17). The browse task
+reports each folder's ``folderPath`` with no trailing separator —
+``"[datastore1]"`` for the root, ``"[datastore1] backup"`` for a folder —
+and the old code glued the file name straight on, producing
+``"[datastore1] backupVMware-VCSA.iso"`` and ``"[datastore1]Hermers - TT"``.
+Agents pass that string into deploy_vm_from_ova / attach_iso_to_vm, so a
+malformed path breaks the very flow the browse exists for. The earlier tests
+mocked ``"[ds1] images/"`` (trailing slash), the one shape that hid the bug.
+"""
+from __future__ import annotations
+
+from types import SimpleNamespace
+
+import pytest
+from pyVmomi import vim
+
+from vmware_storage.ops import datastore_browser as dsb
+
+
+@pytest.mark.unit
+@pytest.mark.parametrize(
+    ("folder", "name", "expected"),
+    [
+        # Root, as ESXi reports it: no space after the bracket.
+        ("[datastore1]", "Hermers - TT", "[datastore1] Hermers - TT"),
+        ("[datastore1]", "x.iso", "[datastore1] x.iso"),
+        # Root, as vCenter reports it: trailing space.
+        ("[datastore1] ", "x.iso", "[datastore1] x.iso"),
+        # Folder without a trailing slash (ESXi).
+        ("[datastore1] backup", "x.iso", "[datastore1] backup/x.iso"),
+        (
+            "[datastore1] Hermers - TT",
+            "Hermers - TT.vmdk",
+            "[datastore1] Hermers - TT/Hermers - TT.vmdk",
+        ),
+        ("[datastore1] a/b", "x.iso", "[datastore1] a/b/x.iso"),
+        # Folder with a trailing slash (vCenter) — must not double it.
+        ("[datastore1] backup/", "x.iso", "[datastore1] backup/x.iso"),
+    ],
+)
+def test_join_ds_path(folder, name, expected):
+    assert dsb._join_ds_path(folder, name) == expected
+
+
+@pytest.mark.unit
+def test_browse_root_returns_well_formed_paths_for_every_folder(monkeypatch):
+    """Root browse is recursive: subfolder rows come back too, each well formed."""
+    def _file(path):
+        return SimpleNamespace(path=path, fileSize=1024 * 1024, modification="2026-10-17")
+
+    results = [
+        SimpleNamespace(folderPath="[datastore1]", file=[_file("backup")]),
+        SimpleNamespace(folderPath="[datastore1] backup", file=[_file("x.iso")]),
+    ]
+    seen = {}
+
+    def fake_search(datastorePath, searchSpec):  # noqa: N803 — pyVmomi API names
+        seen["path"] = datastorePath
+        return SimpleNamespace(
+            info=SimpleNamespace(state=vim.TaskInfo.State.success, result=results, error=None)
+        )
+
+    monkeypatch.setattr(
+        dsb,
+        "find_datastore_by_name",
+        lambda si, name: SimpleNamespace(
+            browser=SimpleNamespace(SearchDatastoreSubFolders_Task=fake_search)
+        ),
+    )
+
+    rows = dsb.browse_datastore(object(), "datastore1")["items"]
+
+    assert seen["path"] == "[datastore1]"
+    assert {r["name"]: r["ds_path"] for r in rows} == {
+        "backup": "[datastore1] backup",
+        "x.iso": "[datastore1] backup/x.iso",
+    }

vmware_storage-2.4.1/tests/eval/regression/test_browse_sees_every_file.py

@@ -0,0 +1,70 @@
+"""browse_datastore must see every file, and treat a leading '/' one way.
+
+Real hardware, 2026-10-17: vmware-aiops' search spec listed only IsoImageQuery,
+VmDiskQuery and FolderQuery under a comment saying "include all file types".
+A DatastoreBrowser query is a filter, not a hint -- with those three, .ova /
+.ovf / .vmx / .log files are never returned. On the lab vCenter it found 0 of
+the 2 OVAs on 'datastore1 (1)' that vmware-storage (which also passes the
+generic Query) found, so scan_all_datastore_images could not do the one job its
+description gives it: finding an OVA for deploy_vm_from_ova.
+
+The twin also drifted on a leading slash: vmware-aiops passed '/vcsa8' through,
+vmware-storage refused it as "absolute" (its 1.5.35 hardening). Both now refuse
+it, and the error names the corrected path.
+"""
+from __future__ import annotations
+
+from types import SimpleNamespace
+
+import pytest
+from pyVmomi import vim
+
+from vmware_storage.ops import datastore_browser as dsb
+
+
+def _browse(monkeypatch, path=""):
+    seen: dict = {}
+
+    def fake_search(datastorePath, searchSpec):  # noqa: N803 -- pyVmomi API names
+        seen["path"] = datastorePath
+        seen["spec"] = searchSpec
+        return SimpleNamespace(
+            info=SimpleNamespace(state=vim.TaskInfo.State.success, result=[], error=None)
+        )
+
+    monkeypatch.setattr(
+        dsb,
+        "find_datastore_by_name",
+        lambda si, name: SimpleNamespace(
+            browser=SimpleNamespace(SearchDatastoreSubFolders_Task=fake_search)
+        ),
+    )
+    dsb.browse_datastore(object(), "datastore1", path=path, pattern="*.ova")
+    return seen
+
+
+@pytest.mark.unit
+def test_search_spec_includes_the_generic_file_query(monkeypatch) -> None:
+    spec = _browse(monkeypatch)["spec"]
+    # Exact type: every specific query subclasses Query, so isinstance would pass
+    # for the three that hid the OVAs.
+    assert any(type(q) is vim.host.DatastoreBrowser.Query for q in spec.query)
+
+
+@pytest.mark.unit
+def test_relative_path_is_joined_under_the_datastore(monkeypatch) -> None:
+    assert _browse(monkeypatch, "vcsa8")["path"] == "[datastore1] vcsa8"
+
+
+@pytest.mark.unit
+@pytest.mark.parametrize("path", ["/vcsa8", "//vcsa8"])
+def test_leading_slash_is_refused_with_the_fix(monkeypatch, path) -> None:
+    with pytest.raises(ValueError, match="path='vcsa8'"):
+        _browse(monkeypatch, path)
+
+
+@pytest.mark.unit
+@pytest.mark.parametrize("path", ["../other", "a/../../b", "x\x00y", "\\\\server\\share", "/"])
+def test_traversal_and_odd_paths_are_refused(monkeypatch, path) -> None:
+    with pytest.raises(ValueError, match="datastore-relative"):
+        _browse(monkeypatch, path)

vmware_storage-2.4.1/tests/eval/regression/test_error_hints_fit_the_surface.py

@@ -0,0 +1,60 @@
+"""Error hints must fit the error, and the surface that shows them.
+
+Real hardware, 2026-10-17: every MCP error carried "Run 'vmware-storage doctor'
+to verify connectivity." -- also for an invalid path or a datastore name that
+does not resolve, where the message already says what to change. And the
+unknown-target error said "Pass --target", a CLI flag; the MCP name is the
+``target`` parameter.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from vmware_storage.config import AppConfig
+from vmware_storage.mcp_server import server
+
+
+def _unknown_target():
+    from vmware_storage.config import UnknownTargetError
+
+    return UnknownTargetError("Target 'x' not found.")
+
+
+@pytest.mark.unit
+@pytest.mark.parametrize("exc", [ValueError("bad"), _unknown_target()])
+def test_an_authored_request_error_does_not_send_the_agent_to_doctor(exc) -> None:
+    assert "doctor" not in server._hint_for(exc)
+
+
+@pytest.mark.unit
+@pytest.mark.parametrize("exc", [ConnectionError("x"), TimeoutError("x"), RuntimeError("x")])
+def test_connectivity_and_unplanned_errors_keep_the_doctor_hint(exc) -> None:
+    assert server._hint_for(exc) == server._DOCTOR_HINT
+
+
+@pytest.mark.unit
+def test_unknown_target_names_the_mcp_parameter() -> None:
+    with pytest.raises(KeyError) as info:
+        AppConfig(targets=()).get_target("nope")
+    assert "target=" in str(info.value)
+
+
+
+@pytest.mark.unit
+@pytest.mark.parametrize("exc", [
+    __import__("json").JSONDecodeError("Expecting value", "<html>", 0),
+    KeyError("summary.capacity"),
+    UnicodeDecodeError("utf-8", b"\xff", 0, 1, "invalid start byte"),
+])
+def test_parse_errors_and_bare_key_errors_keep_the_doctor_hint(exc) -> None:
+    """Independent review 2026-10-17: a reverse proxy answering HTML raises
+    JSONDecodeError (a ValueError), and a programming slip raises a bare KeyError;
+    neither message says what to change, so they must not be told it does."""
+    assert server._hint_for(exc) == server._DOCTOR_HINT
+
+
+@pytest.mark.unit
+def test_an_unknown_target_is_still_a_key_error() -> None:
+    """Callers catch KeyError from get_target; the subclass must not break them."""
+    assert issubclass(type(_unknown_target()), KeyError)

vmware_storage-2.4.1/tests/eval/regression/test_scan_populates_image_cache.py

@@ -0,0 +1,184 @@
+"""scan_datastore_images must fill the cache that list_cached_images reads.
+
+Real hardware, 2026-10-17: list_cached_images was always empty. Its description
+says the registry is "populated by prior datastore scans", but the only writer,
+``update_registry()``, had no caller anywhere -- no MCP tool, no CLI command --
+so the tool could never return anything, and SKILL.md told agents to prefer it
+over re-scanning.
+"""
+
+from __future__ import annotations
+
+import json
+
+import pytest
+
+from vmware_storage.ops import datastore_browser as dsb
+
+
+def _img(ds: str, rel: str) -> dict:
+    return {
+        "name": rel.rsplit("/", 1)[-1],
+        "size_mb": 1.0,
+        "type": "File",
+        "modified": "",
+        "ds_path": f"[{ds}] {rel}",
+    }
+
+
+@pytest.fixture
+def registry(tmp_path, monkeypatch):
+    path = tmp_path / "image_registry.json"
+    monkeypatch.setattr(dsb, "IMAGE_REGISTRY_FILE", path)
+    monkeypatch.setattr(dsb, "CONFIG_DIR", tmp_path)
+    return path
+
+
+def _scan_returns(monkeypatch, rows_by_pattern: dict[str, list[dict]]) -> None:
+    def fake_browse(si, ds_name, path="", pattern="*"):
+        rows = rows_by_pattern.get(pattern, [])
+        return {"items": rows, "total": len(rows)}
+
+    monkeypatch.setattr(dsb, "browse_datastore", fake_browse)
+
+
+@pytest.mark.unit
+def test_scan_then_list_cached_returns_what_was_scanned(registry, monkeypatch) -> None:
+    _scan_returns(monkeypatch, {"*.ova": [_img("ds1", "ec-wrkr.ova")]})
+
+    dsb.scan_images(object(), "ds1")
+    cached = dsb.list_images(image_type="ova")
+
+    assert [i["ds_path"] for i in cached["items"]] == ["[ds1] ec-wrkr.ova"]
+    assert cached["items"][0]["datastore"] == "ds1"
+    assert json.loads(registry.read_text(encoding="utf-8"))["last_scan"]
+
+
+@pytest.mark.unit
+def test_rescan_replaces_that_datastore_and_keeps_the_others(registry, monkeypatch) -> None:
+    _scan_returns(monkeypatch, {"*.ova": [_img("ds1", "old.ova")]})
+    dsb.scan_images(object(), "ds1")
+    _scan_returns(monkeypatch, {"*.iso": [_img("ds2", "x.iso")]})
+    dsb.scan_images(object(), "ds2")
+    _scan_returns(monkeypatch, {"*.ova": [_img("ds1", "new.ova")]})
+    dsb.scan_images(object(), "ds1")
+
+    paths = sorted(i["ds_path"] for i in dsb.list_images()["items"])
+    assert paths == ["[ds1] new.ova", "[ds2] x.iso"]
+
+
+@pytest.mark.unit
+def test_subfolder_scan_only_replaces_that_subfolder(registry, monkeypatch) -> None:
+    _scan_returns(monkeypatch, {"*.ova": [_img("ds1", "a/one.ova"), _img("ds1", "b/two.ova")]})
+    dsb.scan_images(object(), "ds1")
+    _scan_returns(monkeypatch, {"*.ova": [_img("ds1", "a/three.ova")]})
+    dsb.scan_images(object(), "ds1", path="a")
+
+    paths = sorted(i["ds_path"] for i in dsb.list_images()["items"])
+    assert paths == ["[ds1] a/three.ova", "[ds1] b/two.ova"]
+
+
+@pytest.mark.unit
+def test_an_unwritable_cache_does_not_fail_the_scan(registry, monkeypatch) -> None:
+    _scan_returns(monkeypatch, {"*.ova": [_img("ds1", "x.ova")]})
+
+    def boom(_registry):
+        raise OSError("read-only file system")
+
+    monkeypatch.setattr(dsb, "_save_registry", boom)
+    result = dsb.scan_images(object(), "ds1")
+
+    assert result["total"] == 1
+    assert "cache_note" in result
+
+
+# ── independent review, 2026-10-17 ───────────────────────────────────────────
+
+
+@pytest.mark.unit
+def test_a_corrupt_cache_does_not_fail_the_scan(registry, monkeypatch) -> None:
+    registry.write_text("{not json", encoding="utf-8")
+    _scan_returns(monkeypatch, {"*.ova": [_img("ds1", "x.ova")]})
+
+    result = dsb.scan_images(object(), "ds1")
+
+    assert result["total"] == 1 and "cache_note" in result
+
+
+@pytest.mark.unit
+def test_a_corrupt_cache_tells_the_reader_how_to_recover(registry) -> None:
+    registry.write_text("[1, 2]", encoding="utf-8")
+    with pytest.raises(dsb.DatastoreBrowseError, match="scan_datastore_images"):
+        dsb.list_images()
+
+
+@pytest.mark.unit
+def test_the_same_datastore_name_on_two_targets_is_kept_apart(registry, monkeypatch) -> None:
+    """'datastore1' exists on every ESXi host; one target's scan must not erase another's."""
+    _scan_returns(monkeypatch, {"*.iso": [_img("ds1", "a.iso")]})
+    dsb.scan_images(object(), "ds1", target="vc-a")
+    _scan_returns(monkeypatch, {"*.iso": [_img("ds1", "b.iso")]})
+    dsb.scan_images(object(), "ds1", target="esx-b")
+
+    items = dsb.list_images()["items"]
+    assert sorted((i["target"], i["ds_path"]) for i in items) == [
+        ("esx-b", "[ds1] b.iso"), ("vc-a", "[ds1] a.iso")]
+
+
+@pytest.mark.unit
+def test_a_dot_slash_path_replaces_that_folder(registry, monkeypatch) -> None:
+    _scan_returns(monkeypatch, {"*.iso": [_img("ds1", "a/old.iso")]})
+    dsb.scan_images(object(), "ds1")
+    _scan_returns(monkeypatch, {"*.iso": [_img("ds1", "a/new.iso")]})
+    dsb.scan_images(object(), "ds1", path="./a")
+
+    assert [i["ds_path"] for i in dsb.list_images()["items"]] == ["[ds1] a/new.iso"]
+
+
+@pytest.mark.unit
+def test_concurrent_scans_lose_no_entries(registry, monkeypatch) -> None:
+    """With the HTTPS session pool, scans run side by side."""
+    import threading
+
+    def fake_browse(si, ds_name, path="", pattern="*"):
+        rows = [_img(ds_name, "x.iso")] if pattern == "*.iso" else []
+        return {"items": rows, "total": len(rows)}
+
+    monkeypatch.setattr(dsb, "browse_datastore", fake_browse)
+    threads = [threading.Thread(target=dsb.scan_images, args=(object(), f"ds{i}"))
+               for i in range(20)]
+    for t in threads:
+        t.start()
+    for t in threads:
+        t.join()
+
+    assert dsb.list_images()["total"] == 20
+
+
+@pytest.mark.unit
+def test_the_registry_is_replaced_atomically(registry, monkeypatch) -> None:
+    """A write that dies half-way must leave the previous file, not a truncated one."""
+    _scan_returns(monkeypatch, {"*.iso": [_img("ds1", "keep.iso")]})
+    dsb.scan_images(object(), "ds1")
+    before = registry.read_text(encoding="utf-8")
+
+    def boom(*_a, **_k):
+        raise OSError("disk full")
+
+    monkeypatch.setattr(dsb.json, "dump", boom)
+    monkeypatch.setattr(dsb.json, "dumps", boom)
+    _scan_returns(monkeypatch, {"*.iso": [_img("ds2", "y.iso")]})
+    dsb.scan_images(object(), "ds2")
+
+    assert registry.read_text(encoding="utf-8") == before
+
+
+@pytest.mark.unit
+def test_a_row_from_before_targets_is_replaced_not_duplicated(registry, monkeypatch) -> None:
+    registry.write_text('{"images": [{"datastore": "ds1", "name": "x.iso", '
+                        '"ds_path": "[ds1] x.iso"}], "last_scan": null}', encoding="utf-8")
+    _scan_returns(monkeypatch, {"*.iso": [_img("ds1", "x.iso")]})
+    dsb.scan_images(object(), "ds1", target="vc")
+    dsb.scan_images(object(), "ds1", target="vc")
+
+    assert dsb.list_images(datastore="ds1")["total"] == 1

{vmware_storage-2.4.0 → vmware_storage-2.4.1}/uv.lock

@@ -453,7 +453,7 @@ wheels = [
 
 [[package]]
 name = "mcp"
-version = "1.28.1"
+version = "1.30.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "anyio" },
@@ -471,9 +471,9 @@ dependencies = [
     { name = "typing-inspection" },
     { name = "uvicorn", marker = "sys_platform != 'emscripten'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/6e/77/9450b8f251a13affb6281997d0523c4615f8a8b35d0b21ff30db3a5aac9d/mcp-1.28.1.tar.gz", hash = "sha256:d51e36a5f5644faea4f85ea649bfffa6bc6c26770d42798ad6a3de3d2ba69683", size = 638501, upload-time = "2026-06-26T12:57:29.093Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/ba/93/0142dc84a666daf8ad51a34268f34c12fd6fda4f3810c4be2504eecc8212/mcp-1.30.0.tar.gz", hash = "sha256:445414625fce5c295faa505bb11bacece661ab6f4028d57c935db57820b7a3e4", size = 680511, upload-time = "2026-09-07T14:34:15.845Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e2/5e/d118fce19f87a2e7d8101c35c8ae0ec289098a4df0ff244cec23e415aca0/mcp-1.28.1-py3-none-any.whl", hash = "sha256:2726bca5e7193f61c5dde8b12500a6de2d9acf6d1a1c0be9e8c2e706437991df", size = 222620, upload-time = "2026-06-26T12:57:27.218Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/f4/e58bc33317c92a0203664daaf00bf6f41166cc0149e5d6870a03f7cd004a/mcp-1.30.0-py3-none-any.whl", hash = "sha256:666edb5009503e1047c9d60346a756f94b261f05cc2625f23d41c728ffc484d0", size = 234581, upload-time = "2026-09-07T14:34:14.266Z" },
 ]
 
 [package.optional-dependencies]
@@ -1176,7 +1176,7 @@ wheels = [
 
 [[package]]
 name = "vmware-storage"
-version = "2.4.0"
+version = "2.4.1"
 source = { editable = "." }
 dependencies = [
     { name = "mcp", extra = ["cli"] },

{vmware_storage-2.4.0 → vmware_storage-2.4.1}/vmware_storage/__init__.py

@@ -1,3 +1,3 @@
 """VMware Storage — vSphere datastore, iSCSI, and vSAN management."""
 
-__version__ = "2.4.0"
+__version__ = "2.4.1"

{vmware_storage-2.4.0 → vmware_storage-2.4.1}/vmware_storage/cli.py

@@ -268,8 +268,10 @@ def ds_scan_images(
     """Scan a datastore for deployable images (OVA/ISO/OVF/VMDK)."""
     from vmware_storage.ops.datastore_browser import scan_images
 
-    si = _get_connection(target, config)
-    result = scan_images(si, ds_name)["items"]
+    conn_mgr = ConnectionManager(load_config(Path(config) if config else None))
+    name = conn_mgr.resolve_target_name(target)
+    si = conn_mgr.connect(name)
+    result = scan_images(si, ds_name, target=name)["items"]
     _audit.log_query(target=target or "default", resource=ds_name, query_type="scan_images")
     _print_json(result)
 

{vmware_storage-2.4.0 → vmware_storage-2.4.1}/vmware_storage/config.py

@@ -128,6 +128,11 @@ def _check_env_permissions() -> None:
 _check_env_permissions()
 
 
+
+class UnknownTargetError(KeyError):
+    """A target name that is not in config.yaml. A KeyError, as callers expect,
+    but its own type so the MCP hint can tell it from a programming slip."""
+
 class ConfigError(OSError):
     """A configuration problem the operator can fix, safe to show an agent.
 
@@ -224,9 +229,9 @@ class AppConfig:
             if t.name == name:
                 return t
         available = ", ".join(t.name for t in self.targets) or "(none configured)"
-        raise KeyError(
-            f"Target '{name}' not found in config.yaml. Pass --target with one of "
-            f"the names below, or add a targets: entry to config.yaml (see "
+        raise UnknownTargetError(
+            f"Target '{name}' not found in config.yaml. Pass target=<one of the "
+            f"names below> (CLI: --target), or add a targets: entry to config.yaml (see "
             f"config.example.yaml) and re-run 'vmware-storage doctor'. "
             f"Available: {available}"
         )