plugin-scanner 2.0.954__tar.gz → 2.0.956__tar.gz

{plugin_scanner-2.0.954 → plugin_scanner-2.0.956}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plugin-scanner
-Version: 2.0.954
+Version: 2.0.956
 Summary: Protect local AI harnesses with HOL Guard and run scanner checks for Codex, Claude, Cursor, Gemini, OpenCode, and Pi.
 Project-URL: Homepage, https://github.com/hashgraph-online/hol-guard
 Project-URL: Repository, https://github.com/hashgraph-online/hol-guard

{plugin_scanner-2.0.954 → plugin_scanner-2.0.956}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "plugin-scanner"
-version = "2.0.954"
+version = "2.0.956"
 description = "Protect local AI harnesses with HOL Guard and run scanner checks for Codex, Claude, Cursor, Gemini, OpenCode, and Pi."
 readme = "README.md"
 license = "Apache-2.0"

{plugin_scanner-2.0.954 → plugin_scanner-2.0.956}/pyproject.toml.bak

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hol-guard"
-version = "2.0.954"
+version = "2.0.956"
 description = "Protect local AI harnesses with HOL Guard and run scanner checks for Codex, Claude, Cursor, Gemini, OpenCode, and Pi."
 readme = "README.md"
 license = "Apache-2.0"

{plugin_scanner-2.0.954 → plugin_scanner-2.0.956}/src/codex_plugin_scanner/guard/aibom_trust_metadata.py

@@ -281,7 +281,10 @@ def _local_mcp_security_for_artifact(
 ) -> dict[str, object] | None:
     from .inventory_contract import _normalize_inventory_datetime
 
-    if item_kind != "mcp_server" or getattr(artifact, "artifact_type", None) != "mcp_server":
+    if item_kind not in {"mcp_server", "mcp_tool"} or getattr(artifact, "artifact_type", None) not in {
+        "mcp_server",
+        "mcp_tool",
+    }:
         return None
 
     trust_root = _trust_root_for_artifact(artifact, item_kind=item_kind, workspace_dir=workspace_dir)
@@ -342,7 +345,7 @@ def _local_mcp_security_for_artifact(
     metadata_payload["evidenceHash"] = guard_evidence_hash(
         {
             "capturedAt": normalized_captured_at,
-            "entityType": "mcp_server",
+            "entityType": item_kind,
             "findings": findings,
             "provider": "cisco-mcp-scanner",
             "safety": safety,
@@ -352,7 +355,7 @@ def _local_mcp_security_for_artifact(
     )
 
     return {
-        "entityType": "mcp_server",
+        "entityType": item_kind,
         "source": "local_indexed",
         "provider": "cisco-mcp-scanner",
         "status": status,

{plugin_scanner-2.0.954 → plugin_scanner-2.0.956}/src/codex_plugin_scanner/guard/inventory_contract.py

@@ -803,6 +803,12 @@ def _mcp_tool_items_from_artifact(
                 "annotations": safe_annotations,
             }
         )
+        tool_layers = metadata.get("trustLayers")
+        tool_layer_dicts = (
+            [layer for layer in tool_layers if isinstance(layer, dict)] if isinstance(tool_layers, list) else []
+        )
+        if tool_layer_dicts:
+            metadata["trustLayers"] = tool_layer_dicts
         metadata = _apply_tool_trust_attestation_metadata(
             metadata,
             harness=harness,
@@ -810,32 +816,13 @@ def _mcp_tool_items_from_artifact(
             content_hash=semantic_hash,
             trust_attestation_context=trust_attestation_context,
         )
-        tool_layers = metadata.get("trustLayers")
-        signed_tool_layers = list(tool_layers) if isinstance(tool_layers, list) else []
-        normalized_tool_layers: list[dict[str, object]] = []
-        for layer in signed_tool_layers:
-            if isinstance(layer, dict) and layer.get("layerType") == "cisco_mcp_scanner":
-                raw_layer_metadata = layer.get("metadata")
-                layer_metadata = dict(raw_layer_metadata) if isinstance(raw_layer_metadata, dict) else {}
-                normalized_tool_layers.append(
-                    {
-                        **layer,
-                        "metadata": {
-                            **{
-                                key: value
-                                for key, value in layer_metadata.items()
-                                if key not in {"attestation", "attestationBindings"}
-                            },
-                            "attestationStatus": "unsigned",
-                        },
-                    }
-                )
-            elif isinstance(layer, dict):
-                normalized_tool_layers.append(layer)
-        signed_tool_layers = normalized_tool_layers
-        if signed_tool_layers:
-            metadata["trustLayers"] = signed_tool_layers
-        has_tool_cisco_layer = any(layer.get("layerType") == "cisco_mcp_scanner" for layer in signed_tool_layers)
+        signed_tool_layers = metadata.get("trustLayers")
+        tool_layer_dicts = (
+            [layer for layer in signed_tool_layers if isinstance(layer, dict)]
+            if isinstance(signed_tool_layers, list)
+            else []
+        )
+        has_tool_cisco_layer = any(layer.get("layerType") == "cisco_mcp_scanner" for layer in tool_layer_dicts)
         if inherited_layers and not has_tool_cisco_layer:
             inherited_tool_layers: list[dict[str, object]] = []
             for layer in inherited_layers:
@@ -848,14 +835,21 @@ def _mcp_tool_items_from_artifact(
                             **{
                                 key: value
                                 for key, value in layer_metadata.items()
-                                if key not in {"attestation", "attestationBindings"}
+                                if key
+                                not in {
+                                    "attestation",
+                                    "attestationBindings",
+                                    "attestationRef",
+                                    "attestationStatus",
+                                    "attestationVerification",
+                                }
                             },
                             "attestationStatus": "unsigned",
                             "inheritedFromServerItemId": server_item.item_id,
                         },
                     }
                 )
-            metadata["trustLayers"] = [*signed_tool_layers, *inherited_tool_layers]
+            metadata["trustLayers"] = [*tool_layer_dicts, *inherited_tool_layers]
         tool_description = _inventory_item_description_module().resolve_inventory_item_description(
             harness=harness,
             item_kind="mcp_tool",

{plugin_scanner-2.0.954 → plugin_scanner-2.0.956}/src/codex_plugin_scanner/guard/local_supply_chain.py

@@ -2298,15 +2298,24 @@ def _run_cloud_workspace_audit(
         }
     else:
         request_url = _normalized_supply_chain_batch_url(str(resolved_auth_context["sync_url"]), workspace_id)
-        request_headers = runner._guard_sync_headers(resolved_auth_context, request_url=request_url, method="POST")
     aggregated_packages: list[dict[str, object]] = []
+    aggregated_processed_count = 0
     aggregated_reasons: list[dict[str, object]] = []
+    aggregated_total_packages = 0
     cursor: str | None = None
     last_response: dict[str, object] | None = None
     for _ in range(_CLOUD_AUDIT_MAX_PAGES):
         page_payload = dict(request_payload)
         if cursor is not None:
             page_payload["cursor"] = cursor
+        request_headers = (
+            {
+                "Authorization": f"Bearer {token}",
+                "Content-Type": "application/json",
+            }
+            if resolved_auth_context is None
+            else runner._guard_sync_headers(resolved_auth_context, request_url=request_url, method="POST")
+        )
         request = urllib.request.Request(
             request_url,
             data=json.dumps(page_payload).encode("utf-8"),
@@ -2342,6 +2351,14 @@ def _run_cloud_workspace_audit(
             )
         last_response = response_payload
         response_packages = response_payload.get("packages")
+        page_processed_count = _int_value(response_payload.get("processedCount"))
+        page_total_packages = _int_value(response_payload.get("totalPackages"))
+        if page_total_packages is not None:
+            aggregated_total_packages = max(aggregated_total_packages, page_total_packages)
+        if page_processed_count is not None:
+            aggregated_processed_count += page_processed_count
+        elif isinstance(response_packages, list):
+            aggregated_processed_count += len(response_packages)
         if isinstance(response_packages, list):
             aggregated_packages.extend(item for item in response_packages if isinstance(item, dict))
         response_reasons = response_payload.get("reasons")
@@ -2363,6 +2380,8 @@ def _run_cloud_workspace_audit(
         return (None, None)
     merged_response = dict(last_response)
     merged_response["packages"] = aggregated_packages
+    merged_response["processedCount"] = aggregated_processed_count
+    merged_response["totalPackages"] = max(aggregated_total_packages, len(aggregated_packages))
     merged_response["reasons"] = aggregated_reasons
     return (merged_response, None)
 

{plugin_scanner-2.0.954 → plugin_scanner-2.0.956}/src/codex_plugin_scanner/integrations/cisco_mcp_scanner.py

@@ -18,7 +18,7 @@ from types import ModuleType
 from typing import Protocol, TypeGuard, TypeVar
 
 from ..models import Finding, Severity, severity_from_value
-from .cisco_skill_scanner import CiscoIntegrationStatus, cisco_runtime_unavailable_message
+from .cisco_skill_scanner import CiscoIntegrationStatus
 
 _EXCLUDED_DIRS = {
     ".codex-plugin",
@@ -67,6 +67,10 @@ class CiscoMcpScanSummary:
     scan_mode: str = "static"
 
 
+def cisco_runtime_unavailable_message() -> str | None:
+    return None
+
+
 @dataclass(frozen=True, slots=True)
 class _StaticScanTarget:
     read_path: Path

{plugin_scanner-2.0.954 → plugin_scanner-2.0.956}/src/codex_plugin_scanner/version.py

@@ -1,3 +1,3 @@
 """Single source of truth for tool version."""
 
-__version__ = "2.0.954"
+__version__ = "2.0.956"

{plugin_scanner-2.0.954 → plugin_scanner-2.0.956}/tests/test_guard_aibom_trust_metadata.py

@@ -870,6 +870,14 @@ def test_inventory_snapshot_attaches_mcp_tool_trust_resolution(monkeypatch, tmp_
     search_tool = next(item for item in snapshot.items if item.item_id.endswith(":tool:search_docs"))
     delete_tool = next(item for item in snapshot.items if item.item_id.endswith(":tool:delete_docs"))
 
+    search_local_security = search_tool.metadata.get("localSecurity")
+    assert isinstance(search_local_security, dict)
+    assert search_local_security.get("entityType") == "mcp_tool"
+    assert search_local_security.get("provider") == "cisco-mcp-scanner"
+    search_safety = search_local_security.get("safety")
+    assert isinstance(search_safety, dict)
+    assert search_safety.get("score") == 90
+
     search_trust, search_metadata = _assert_local_trust(search_tool.metadata, trust_domain="mcp")
     _delete_trust, delete_metadata = _assert_local_trust(delete_tool.metadata, trust_domain="mcp")
     assert search_metadata.get("evidenceHash") != delete_metadata.get("evidenceHash")
@@ -909,8 +917,28 @@ def test_inventory_snapshot_attaches_mcp_tool_trust_resolution(monkeypatch, tmp_
     )
     cisco_layer_metadata = cisco_layer.get("metadata")
     assert isinstance(cisco_layer_metadata, dict)
-    assert cisco_layer_metadata.get("attestationStatus") == "unsigned"
-    assert cisco_layer_metadata.get("attestation") is None
+    assert cisco_layer_metadata.get("attestationStatus") == "signed"
+    cisco_attestation = cisco_layer_metadata.get("attestation")
+    assert isinstance(cisco_attestation, dict)
+    cisco_layer_id = cisco_layer.get("layerId")
+    assert isinstance(cisco_layer_id, str)
+    cisco_layer_type = cisco_layer.get("layerType")
+    assert isinstance(cisco_layer_type, str)
+    verify_trust_attestation(
+        payload=build_trust_attestation_payload(
+            agent_id=snapshot.agent_id,
+            item_id=search_tool.item_id,
+            item_kind=search_tool.item_kind,
+            content_hash=search_tool.content_hash,
+            captured_at=str(cisco_layer.get("capturedAt")),
+            evidence_hash=str(cisco_layer_metadata.get("evidenceHash")),
+            scope="trust_layer",
+            layer_id=cisco_layer_id,
+            layer_type=cisco_layer_type,
+        ),
+        envelope=cisco_attestation,
+        trusted_keys=(verification_key,),
+    )
     assert search_trust.get("trustScore") is not None
 
 

{plugin_scanner-2.0.954 → plugin_scanner-2.0.956}/tests/test_guard_cisco_evidence.py

@@ -149,6 +149,8 @@ def test_guard_store_invalidates_scanner_cache_when_hash_or_version_changes(tmp_
 
 
 def test_skill_scanner_reports_timeout_without_marking_scan_failed(monkeypatch, tmp_path: Path) -> None:
+    monkeypatch.setattr(cisco_skill_scanner.sys, "version_info", (3, 13, 0))
+
     class SlowScanner:
         def __init__(self, policy: object) -> None:
             self.policy = policy

{plugin_scanner-2.0.954 → plugin_scanner-2.0.956}/tests/test_guard_cisco_runtime_cli.py

@@ -166,7 +166,7 @@ def test_default_detector_registry_includes_cisco_sources() -> None:
     assert "cisco.mcp" in detector_ids
 
 
-def test_cisco_scanners_warn_and_skip_on_python_314(
+def test_skill_scanner_warns_on_python_314_but_mcp_scanner_checks_dependency(
     tmp_path: Path,
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
@@ -180,7 +180,7 @@ def test_cisco_scanners_warn_and_skip_on_python_314(
     assert mcp_summary.status is CiscoIntegrationStatus.UNAVAILABLE
     assert "Python 3.14+" in skill_summary.message
     assert "Python 3.10 through 3.13" in skill_summary.message
-    assert "Python 3.14+" in mcp_summary.message
+    assert "Cisco MCP scanner is required but not installed" in mcp_summary.message
 
 
 def test_guard_scan_skills_deep_uses_cisco_skill_scanner(

{plugin_scanner-2.0.954 → plugin_scanner-2.0.956}/tests/test_guard_local_supply_chain_audit_phase16.py

@@ -57,6 +57,96 @@ def test_normalized_supply_chain_batch_url_preserves_sync_prefix() -> None:
     ) == f"https://guard.example/registry/api/v1/guard/supply-chain/evaluate/batch?workspaceId={WORKSPACE_ID}"
 
 
+def test_cloud_workspace_audit_renews_dpop_proof_for_each_page(monkeypatch: pytest.MonkeyPatch) -> None:
+    runner = local_supply_chain_module._runtime_runner_module()
+    signed_proofs: list[str] = []
+    request_bodies: list[dict[str, object]] = []
+
+    def _fake_guard_sync_headers(
+        auth_context: dict[str, object],
+        *,
+        request_url: str,
+        method: str,
+    ) -> dict[str, str]:
+        del auth_context, request_url, method
+        proof = f"proof-{len(signed_proofs) + 1}"
+        signed_proofs.append(proof)
+        return {
+            "Authorization": "Bearer token",
+            "Content-Type": "application/json",
+            "DPoP": proof,
+        }
+
+    class _JsonResponse(io.StringIO):
+        def __enter__(self) -> _JsonResponse:
+            return self
+
+        def __exit__(self, *args: object) -> None:
+            self.close()
+
+    def _fake_urlopen(request: object, timeout: int) -> _JsonResponse:
+        del timeout
+        assert isinstance(request, local_supply_chain_module.urllib.request.Request)
+        dpop_header = dict(request.header_items()).get("Dpop")
+        assert dpop_header == f"proof-{len(request_bodies) + 1}"
+        body = request.data
+        assert isinstance(body, bytes)
+        request_bodies.append(json.loads(body.decode("utf-8")))
+        if len(request_bodies) == 1:
+            return _JsonResponse(
+                json.dumps(
+                    {
+                        "decision": "monitor",
+                        "packages": [{"ecosystem": "npm", "name": "react"}],
+                        "reasons": [],
+                        "nextCursor": "cursor-1",
+                        "processedCount": 2,
+                        "totalPackages": 3,
+                    }
+                )
+            )
+        return _JsonResponse(
+            json.dumps(
+                {
+                    "decision": "monitor",
+                    "packages": [{"ecosystem": "npm", "name": "scheduler"}],
+                    "processedCount": 1,
+                    "reasons": [],
+                    "totalPackages": 2,
+                }
+            )
+        )
+
+    monkeypatch.setattr(runner, "_guard_sync_headers", _fake_guard_sync_headers)
+    monkeypatch.setattr(local_supply_chain_module.urllib.request, "urlopen", _fake_urlopen)
+
+    response, fallback = local_supply_chain_module._run_cloud_workspace_audit(
+        auth_context={
+            "access_token": "token",
+            "sync_url": "https://guard.example/api/guard/receipts/sync",
+        },
+        request_payload={
+            "mode": "paged",
+            "packages": [
+                {"ecosystem": "npm", "name": "react"},
+                {"ecosystem": "npm", "name": "scheduler"},
+            ],
+            "pageSize": 1,
+            "workspaceFingerprint": "fingerprint-1",
+        },
+        workspace_id=WORKSPACE_ID,
+    )
+
+    assert fallback is None
+    assert response is not None
+    assert [item["name"] for item in response["packages"]] == ["react", "scheduler"]
+    assert response["processedCount"] == 3
+    assert response["totalPackages"] == 3
+    assert signed_proofs == ["proof-1", "proof-2"]
+    assert request_bodies[0].get("cursor") is None
+    assert request_bodies[1]["cursor"] == "cursor-1"
+
+
 def _write_text(path: Path, text: str) -> None:
     path.parent.mkdir(parents=True, exist_ok=True)
     path.write_text(text, encoding="utf-8")

{plugin_scanner-2.0.954 → plugin_scanner-2.0.956}/uv.lock

@@ -1162,7 +1162,7 @@ wheels = [
 
 [[package]]
 name = "hol-guard"
-version = "2.0.954"
+version = "2.0.956"
 source = { editable = "." }
 dependencies = [
     { name = "cisco-ai-skill-scanner", marker = "python_full_version < '3.14'" },