plugin-scanner 2.0.621__tar.gz → 2.0.623__tar.gz

{plugin_scanner-2.0.621 → plugin_scanner-2.0.623}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plugin-scanner
-Version: 2.0.621
+Version: 2.0.623
 Summary: Lint, verify, and gate plugin ecosystems for maintainers, CI, and publish workflows.
 Project-URL: Homepage, https://github.com/hashgraph-online/hol-guard
 Project-URL: Repository, https://github.com/hashgraph-online/hol-guard

{plugin_scanner-2.0.621 → plugin_scanner-2.0.623}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "plugin-scanner"
-version = "2.0.621"
+version = "2.0.623"
 description = "Lint, verify, and gate plugin ecosystems for maintainers, CI, and publish workflows."
 readme = "README.md"
 license = "Apache-2.0"

{plugin_scanner-2.0.621 → plugin_scanner-2.0.623}/pyproject.toml.bak

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

{plugin_scanner-2.0.621 → plugin_scanner-2.0.623}/src/codex_plugin_scanner/guard/adapters/claude_code.py

@@ -450,7 +450,7 @@ class ClaudeCodeHarnessAdapter(HarnessAdapter):
                         harness=self.harness,
                         artifact_type="instruction",
                         artifact_id_prefix="instruction",
-                        name_for_path=lambda artifact_path, _base_dir: artifact_path.stem,
+                        name_for_path=lambda artifact_path, _base_dir: f"rules-{artifact_path.stem}",
                     )
                 )
         resolved_executable = self.resolved_executable(context)

{plugin_scanner-2.0.621 → plugin_scanner-2.0.623}/src/codex_plugin_scanner/guard/aibom_detection.py

@@ -472,6 +472,19 @@ def extend_codex_runtime_inventory(
     )
 
 
+def _is_workspace_root_claude_md(artifact: GuardArtifact, workspace_dir: Path) -> bool:
+    metadata = artifact.metadata if isinstance(artifact.metadata, dict) else {}
+    if metadata.get("instructionRole") != "claude_md":
+        return False
+    config_path = getattr(artifact, "config_path", None)
+    if not isinstance(config_path, str):
+        return False
+    try:
+        return Path(config_path).resolve() == (workspace_dir / "CLAUDE.md").resolve()
+    except OSError:
+        return False
+
+
 def extend_detection_with_workspace_aibom(
     detection: HarnessDetection,
     *,
@@ -489,12 +502,19 @@ def extend_detection_with_workspace_aibom(
         return detection
     existing_ids = {artifact.artifact_id for artifact in detection.artifacts}
     merged = list(detection.artifacts)
+    artifact_index_by_id = {artifact.artifact_id: index for index, artifact in enumerate(merged)}
     found_paths = list(detection.config_paths)
     for artifact in extra:
         if artifact.artifact_id in existing_ids:
+            if _is_workspace_root_claude_md(artifact, workspace_dir):
+                merged[artifact_index_by_id[artifact.artifact_id]] = artifact
+                config_path = getattr(artifact, "config_path", None)
+                if isinstance(config_path, str):
+                    found_paths.append(config_path)
             continue
         merged.append(artifact)
         existing_ids.add(artifact.artifact_id)
+        artifact_index_by_id[artifact.artifact_id] = len(merged) - 1
         config_path = getattr(artifact, "config_path", None)
         if isinstance(config_path, str):
             found_paths.append(config_path)

{plugin_scanner-2.0.621 → plugin_scanner-2.0.623}/src/codex_plugin_scanner/guard/approvals.py

@@ -9,7 +9,7 @@ from collections.abc import Mapping, Sequence
 from dataclasses import replace
 from datetime import datetime, timedelta, timezone
 from pathlib import Path
-from urllib.parse import parse_qsl, urlencode, urlparse, urlunparse
+from urllib.parse import ParseResult, parse_qsl, urlencode, urlparse, urlunparse
 
 from .adapters import get_adapter
 from .adapters.base import HarnessContext
@@ -151,7 +151,10 @@ def primary_approval_url(
         return None
     approval_url = request.get("approval_url")
     if isinstance(approval_url, str) and approval_url.strip():
-        return approval_url.strip().replace("/approvals/", "/requests/")
+        return _canonical_local_approval_url(
+            approval_url.strip().replace("/approvals/", "/requests/"),
+            approval_center_url=approval_center_url,
+        )
     request_id = request.get("request_id")
     if isinstance(request_id, str) and request_id.strip() and isinstance(approval_center_url, str):
         center = approval_center_url.strip()
@@ -160,6 +163,40 @@ def primary_approval_url(
     return None
 
 
+def _canonical_local_approval_url(approval_url: str, *, approval_center_url: str | None) -> str:
+    if not isinstance(approval_center_url, str) or not approval_center_url.strip():
+        return approval_url
+    try:
+        parsed_approval = urlparse(approval_url)
+        parsed_center = urlparse(approval_center_url.strip())
+    except ValueError:
+        return approval_url
+    loopback_hosts = {"127.0.0.1", "::1", "localhost"}
+    approval_host = _parsed_url_host(parsed_approval)
+    center_host = _parsed_url_host(parsed_center)
+    if parsed_approval.scheme not in {"http", "https"} or approval_host not in loopback_hosts:
+        return approval_url
+    if parsed_center.scheme not in {"http", "https"} or center_host not in loopback_hosts:
+        return approval_url
+    return urlunparse(
+        parsed_approval._replace(
+            scheme=parsed_center.scheme,
+            netloc=parsed_center.netloc,
+        )
+    )
+
+
+def _parsed_url_host(parsed: ParseResult) -> str:
+    host_port = parsed.netloc.rsplit("@", 1)[-1]
+    if host_port.startswith("["):
+        host, _separator, _rest = host_port[1:].partition("]")
+        return host
+    if host_port.count(":") == 1:
+        host, _port = host_port.rsplit(":", 1)
+        return host
+    return host_port
+
+
 def queue_blocked_approvals(
     *,
     detection: HarnessDetection,

{plugin_scanner-2.0.621 → plugin_scanner-2.0.623}/src/codex_plugin_scanner/version.py

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

{plugin_scanner-2.0.621 → plugin_scanner-2.0.623}/tests/test_guard_aibom_detection.py

@@ -4,6 +4,7 @@ import json
 from pathlib import Path
 
 from codex_plugin_scanner.guard.adapters.base import HarnessContext
+from codex_plugin_scanner.guard.adapters.claude_code import ClaudeCodeHarnessAdapter
 from codex_plugin_scanner.guard.adapters.cursor import CursorHarnessAdapter
 from codex_plugin_scanner.guard.adapters.hermes import HermesHarnessAdapter
 from codex_plugin_scanner.guard.adapters.openclaw import OpenClawHarnessAdapter
@@ -312,6 +313,23 @@ def test_marketplace_escape_path_does_not_read_outside_workspace(tmp_path: Path)
     assert "content_hash" not in evil_plugins[0].metadata
 
 
+def test_extend_detection_prefers_workspace_root_claude_md_on_legacy_id_collision(tmp_path: Path) -> None:
+    workspace = tmp_path / "repo"
+    workspace.mkdir()
+    root_claude_md = workspace / "CLAUDE.md"
+    root_claude_md.write_text("# root instructions\n", encoding="utf-8")
+    colliding_rule = workspace / ".claude" / "rules" / "claude-md.md"
+    colliding_rule.parent.mkdir(parents=True)
+    colliding_rule.write_text("# colliding rule\n", encoding="utf-8")
+
+    context = HarnessContext(home_dir=tmp_path, workspace_dir=workspace, guard_home=tmp_path / ".hol-guard")
+    detection = ClaudeCodeHarnessAdapter().detect(context)
+    artifacts = {artifact.artifact_id: artifact for artifact in detection.artifacts}
+
+    assert artifacts["claude-code:project:instruction:claude-md"].config_path == str(root_claude_md)
+    assert artifacts["claude-code:project:instruction:rules-claude-md"].config_path == str(colliding_rule)
+
+
 def test_extend_detection_does_not_mark_harness_installed_from_workspace_files(tmp_path: Path) -> None:
     workspace = tmp_path / "repo"
     workspace.mkdir()

{plugin_scanner-2.0.621 → plugin_scanner-2.0.623}/tests/test_guard_approval_copy_commands.py

@@ -124,6 +124,82 @@ def test_first_approval_url_ignores_malformed_queue_items() -> None:
     )
 
 
+def test_first_approval_url_repairs_stale_local_port() -> None:
+    queued = [
+        {
+            "approval_url": "http://127.0.0.1:5713/requests/req-stale-port",
+            "harness": "package-firewall",
+            "request_id": "req-stale-port",
+        }
+    ]
+
+    assert (
+        first_approval_url(
+            queued,
+            harness="package-firewall",
+            approval_center_url="http://127.0.0.1:5474",
+        )
+        == "http://127.0.0.1:5474/requests/req-stale-port"
+    )
+
+
+@pytest.mark.parametrize(
+    ("stale_url", "active_center", "expected_url"),
+    [
+        (
+            "http://localhost:5713/requests/req-localhost",
+            "http://127.0.0.1:5474",
+            "http://127.0.0.1:5474/requests/req-localhost",
+        ),
+        (
+            "http://" + "[" + ":".join(["", "", "1"]) + "]:5713/requests/req-ipv6",
+            "http://" + "[" + ":".join(["", "", "1"]) + "]:5474",
+            "http://" + "[" + ":".join(["", "", "1"]) + "]:5474/requests/req-ipv6",
+        ),
+    ],
+)
+def test_first_approval_url_repairs_loopback_variants(
+    stale_url: str,
+    active_center: str,
+    expected_url: str,
+) -> None:
+    queued = [
+        {
+            "approval_url": stale_url,
+            "harness": "package-firewall",
+            "request_id": "req-loopback",
+        }
+    ]
+
+    assert (
+        first_approval_url(
+            queued,
+            harness="package-firewall",
+            approval_center_url=active_center,
+        )
+        == expected_url
+    )
+
+
+def test_first_approval_url_does_not_rewrite_external_url() -> None:
+    queued = [
+        {
+            "approval_url": "https://guard.example/requests/req-cloud",
+            "harness": "package-firewall",
+            "request_id": "req-cloud",
+        }
+    ]
+
+    assert (
+        first_approval_url(
+            queued,
+            harness="package-firewall",
+            approval_center_url="http://127.0.0.1:5474",
+        )
+        == "https://guard.example/requests/req-cloud"
+    )
+
+
 def test_primary_approval_request_prefers_matching_harness() -> None:
     queued = [
         {

{plugin_scanner-2.0.621 → plugin_scanner-2.0.623}/tests/test_guard_claude_adapter.py

@@ -640,12 +640,31 @@ def test_claude_detect_discovers_nested_hooks_skills_commands_and_rules(tmp_path
     assert "claude-code:project:userpromptsubmit:0:0" in artifacts
     assert "claude-code:project:skill:review" in artifacts
     assert "claude-code:project:command:deploy" in artifacts
-    assert "claude-code:project:instruction:secrets" in artifacts
+    assert "claude-code:project:instruction:rules-secrets" in artifacts
     claude_instruction = artifacts.get("claude-code:project:instruction:claude-md")
     assert claude_instruction is not None
     assert claude_instruction.metadata.get("instructionRole") == "claude_md"
 
 
+def test_claude_detect_keeps_root_claude_md_when_rules_stem_collides(tmp_path):
+    context = _build_context(tmp_path)
+    adapter = ClaudeCodeHarnessAdapter()
+    colliding_rule = context.workspace_dir / ".claude" / "rules" / "claude-md.md"
+    colliding_rule.parent.mkdir(parents=True, exist_ok=True)
+    colliding_rule.write_text("# benign rule\n", encoding="utf-8")
+    root_claude_md = context.workspace_dir / "CLAUDE.md"
+    root_claude_md.write_text("# malicious workspace instructions\n", encoding="utf-8")
+
+    detection = adapter.detect(context)
+    artifacts = {artifact.artifact_id: artifact for artifact in detection.artifacts}
+
+    assert "claude-code:project:instruction:rules-claude-md" in artifacts
+    root_instruction = artifacts.get("claude-code:project:instruction:claude-md")
+    assert root_instruction is not None
+    assert root_instruction.config_path == str(root_claude_md)
+    assert root_instruction.metadata.get("instructionRole") == "claude_md"
+
+
 def test_claude_detect_tolerates_unreadable_markdown_artifacts(monkeypatch, tmp_path):
     context = _build_context(tmp_path)
     adapter = ClaudeCodeHarnessAdapter()