plugin-scanner 2.0.650__tar.gz → 2.0.652__tar.gz

{plugin_scanner-2.0.650 → plugin_scanner-2.0.652}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plugin-scanner
-Version: 2.0.650
+Version: 2.0.652
 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.650 → plugin_scanner-2.0.652}/dashboard/src/supply-chain-ux-consolidation.test.ts

@@ -31,6 +31,14 @@ assert(
   workspaceSource.includes("PackageWorkbenchPanel"),
   "workspace keeps single audit findings workbench",
 );
+assert(
+  workspaceSource.includes("supply-chain-workspace-hero-state"),
+  "workspace imports supply chain hero state helpers",
+);
+assert(
+  workspaceSource.includes("resolveSupplyChainWorkspaceHero"),
+  "workspace resolves hero state for status header",
+);
 assert(
   !controlsSource.includes("NextActionHero"),
   "firewall controls drop duplicate next-step hero",

{plugin_scanner-2.0.650 → plugin_scanner-2.0.652}/dashboard/src/supply-chain-workspace.tsx

@@ -32,6 +32,7 @@ import { SupplyChainCloudCapabilitiesPanel } from "./supply-chain-cloud-capabili
 import { PackageWorkbenchPanel } from "./package-workbench-panel";
 import { resolveSupplyChainIssues, type SupplyChainIssueAction } from "./supply-chain-issues";
 import { resolveSupplyChainAuditWorkspaceDir } from "./supply-chain-audit-workspace";
+import { resolveSupplyChainWorkspaceHero } from "./supply-chain-workspace-hero-state";
 import { SupplyChainStatusHeader } from "./supply-chain-status-header";
 import { SUPPLY_CHAIN_WORKSPACE_SHELL_CLASS } from "./supply-chain-workspace-layout";
 

{plugin_scanner-2.0.650 → plugin_scanner-2.0.652}/pyproject.toml

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

{plugin_scanner-2.0.650 → plugin_scanner-2.0.652}/pyproject.toml.bak

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hol-guard"
-version = "2.0.650"
+version = "2.0.652"
 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.650 → plugin_scanner-2.0.652}/src/codex_plugin_scanner/guard/aibom_trust_metadata.py

@@ -10,7 +10,7 @@ from typing import Literal
 from ..checks.skill_security import resolve_skill_security_context
 from ..models import ScanOptions
 from ..trust_instruction_scoring import build_instruction_domain
-from ..trust_mcp_scoring import build_mcp_domain
+from ..trust_mcp_scoring import build_mcp_domain, build_mcp_surface_domain
 from ..trust_models import TrustAdapterScore, TrustComponentScore, TrustDomainScore
 from ..trust_plugin_scoring import build_plugin_domain
 from ..trust_skill_scoring import build_skill_domain
@@ -137,7 +137,12 @@ def _local_trust_domain_for_artifact(
         context = resolve_skill_security_context(trust_root, _INVENTORY_TRUST_SCAN_OPTIONS)
         return build_skill_domain(trust_root, context)
     if item_kind == "mcp_server":
-        return build_mcp_domain(trust_root, ())
+        return build_mcp_domain(trust_root, ()) or build_mcp_surface_domain(
+            name=getattr(artifact, "name", None),
+            command=getattr(artifact, "command", None),
+            url=getattr(artifact, "url", None),
+            transport=getattr(artifact, "transport", None),
+        )
     if item_kind in {"overlay", "policy", "prompt_pack"}:
         role = metadata.get("instructionRole")
         normalized_role = role if isinstance(role, str) and role else "unknown_instruction"

{plugin_scanner-2.0.650 → plugin_scanner-2.0.652}/src/codex_plugin_scanner/guard/daemon/static/assets/chunks/supply-chain-workspace.js

@@ -2473,6 +2473,85 @@ function resolveSupplyChainIssues(snapshot) {
   }
   return issues;
 }
+function protectionTitle(status) {
+  if (status === "protected") {
+    return "Package installs are protected on this device";
+  }
+  if (status === "partial") {
+    return "Protection is only partly set up";
+  }
+  if (status === "staged") {
+    return "Finish setup in a new terminal";
+  }
+  if (status === "unprotected") {
+    return "Package installs are not protected yet";
+  }
+  return "Checking package protection on this device";
+}
+function protectionDetail(snapshot, status) {
+  const protection = snapshot.supply_chain?.package_manager_protection;
+  if (status === "protected" && protection) {
+    return `${protection.protected_managers.length} package tool${protection.protected_managers.length === 1 ? "" : "s"} active. Guard can block risky installs before they run.`;
+  }
+  if (status === "partial" && protection) {
+    return `${protection.unprotected_managers.length} tool${protection.unprotected_managers.length === 1 ? "" : "s"} still open: ${protection.unprotected_managers.join(", ")}.`;
+  }
+  if (status === "staged") {
+    return "Guard updated your shell profile. Open a new terminal, then run a protection test.";
+  }
+  if (status === "unprotected") {
+    return "Turn on protection for npm, pip, and other tools in the firewall panel below.";
+  }
+  return "Refresh status after installing package tools on this machine.";
+}
+function protectionTone(status) {
+  if (status === "protected") {
+    return "green";
+  }
+  if (status === "staged") {
+    return "blue";
+  }
+  if (status === "partial" || status === "unprotected") {
+    return "attention";
+  }
+  return "slate";
+}
+function cloudLabel(snapshot) {
+  const label = snapshot.cloud_state_label ?? "";
+  if (snapshot.cloud_state === "paired_active") {
+    return label.trim().length > 0 ? label : "Guard Cloud connected";
+  }
+  if (snapshot.cloud_state === "paired_waiting") {
+    return label.trim().length > 0 ? label : "Pairing in progress";
+  }
+  return label.trim().length > 0 ? label : "On this device only";
+}
+function resolveSupplyChainWorkspaceHero(snapshot, options) {
+  const protectionStatus = resolveHomeProtectionStatus(snapshot);
+  const stats = buildSupplyChainStats(snapshot);
+  const preventedLabel = stats.preventedInstalls > 0 ? `${stats.preventedInstalls} blocked install${stats.preventedInstalls === 1 ? "" : "s"}` : "No blocked installs yet";
+  const openIssueCount = options?.openIssueCount ?? 0;
+  if (openIssueCount > 0) {
+    return {
+      cloudMode: snapshot.cloud_state,
+      cloudLabel: cloudLabel(snapshot),
+      protectionStatus,
+      title: "Work through the steps below",
+      detail: `${openIssueCount} setup step${openIssueCount === 1 ? "" : "s"} need attention on this device.`,
+      tone: protectionTone(protectionStatus),
+      statLine: `${stats.protectedManagers} protected · ${stats.unprotectedManagers} open · ${preventedLabel}`
+    };
+  }
+  return {
+    cloudMode: snapshot.cloud_state,
+    cloudLabel: cloudLabel(snapshot),
+    protectionStatus,
+    title: protectionTitle(protectionStatus),
+    detail: protectionDetail(snapshot, protectionStatus),
+    tone: protectionTone(protectionStatus),
+    statLine: `${stats.protectedManagers} protected · ${stats.unprotectedManagers} open · ${preventedLabel}`
+  };
+}
 function supplyChainCloudTagTone(mode) {
   if (mode === "paired_active") {
     return "green";

plugin_scanner-2.0.652/src/codex_plugin_scanner/trust_mcp_scoring.py

@@ -0,0 +1,213 @@
+"""HCS-style MCP trust scoring."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from .models import CategoryResult
+from .trust_helpers import (
+    build_adapter_score,
+    build_domain_score,
+    category_checks,
+    check_percent,
+    is_https_url,
+    load_mcp_payload,
+    round_trust_score,
+)
+from .trust_models import TrustDomainScore
+from .trust_specs import MCP_TRUST_SPEC
+
+
+def build_mcp_domain(plugin_dir: Path, categories: tuple[CategoryResult, ...]) -> TrustDomainScore | None:
+    payload_state = load_mcp_payload(plugin_dir)
+    if payload_state is None:
+        return None
+
+    payload = payload_state.payload
+    security_checks = category_checks(categories, "Security")
+    remotes = payload.get("remotes")
+    servers = payload.get("mcpServers")
+    remote_entries = remotes if isinstance(remotes, list) else []
+    local_servers = servers if isinstance(servers, dict) else {}
+    has_named_surfaces = bool(remote_entries) or bool(local_servers)
+    secure_remote_urls = (
+        all(isinstance(entry, dict) and is_https_url(str(entry.get("url", ""))) for entry in remote_entries)
+        if remote_entries
+        else True
+    )
+    local_commands_valid = True
+    if local_servers:
+        for config in local_servers.values():
+            if not isinstance(config, dict):
+                local_commands_valid = False
+                break
+            args_value = config.get("args")
+            args_valid = args_value is None or (
+                isinstance(args_value, list) and all(isinstance(value, str) for value in args_value)
+            )
+            if not (isinstance(config.get("command"), str) and bool(config.get("command")) and args_valid):
+                local_commands_valid = False
+                break
+    config_shape = payload_state.parse_valid and (
+        (remotes is None or isinstance(remotes, list)) and (servers is None or isinstance(servers, dict))
+    )
+
+    spec_by_id = {adapter.adapter_id: adapter for adapter in MCP_TRUST_SPEC.adapters}
+    adapters = (
+        build_adapter_score(
+            spec_by_id["verification.config-integrity"],
+            component_scores={"score": 100.0} if payload_state.parse_valid else None,
+            rationales={
+                "score": (
+                    "The .mcp.json file parsed successfully."
+                    if payload_state.parse_valid
+                    else "The .mcp.json file did not parse, so config-integrity remains 0."
+                )
+            },
+        ),
+        build_adapter_score(
+            spec_by_id["verification.execution-safety"],
+            component_scores={"score": check_percent(security_checks, "No dangerous MCP commands")},
+            rationales={"score": "Execution safety follows the scanner's dangerous-command check."},
+        ),
+        build_adapter_score(
+            spec_by_id["verification.transport-security"],
+            component_scores={"score": check_percent(security_checks, "MCP remote transports are hardened")},
+            rationales={"score": "Transport security follows the scanner's hardened-remote check."},
+        ),
+        build_adapter_score(
+            spec_by_id["metadata.server-naming"],
+            component_scores={"score": 100.0} if has_named_surfaces else None,
+            rationales={
+                "score": (
+                    "At least one MCP surface is explicitly named."
+                    if has_named_surfaces
+                    else "No local or remote MCP surfaces are declared."
+                )
+            },
+        ),
+        build_adapter_score(
+            spec_by_id["metadata.command-or-endpoint"],
+            component_scores=(
+                {"score": 100.0} if has_named_surfaces and secure_remote_urls and local_commands_valid else None
+            ),
+            rationales={
+                "score": (
+                    "Every MCP surface declares a concrete command or HTTPS endpoint."
+                    if has_named_surfaces and secure_remote_urls and local_commands_valid
+                    else "At least one MCP surface is missing a valid command or secure endpoint."
+                )
+            },
+        ),
+        build_adapter_score(
+            spec_by_id["metadata.config-shape"],
+            component_scores={"score": 100.0} if config_shape else None,
+            rationales={
+                "score": (
+                    "The top-level MCP config containers match the expected shape."
+                    if config_shape
+                    else "The MCP config containers do not match the expected shape."
+                )
+            },
+        ),
+    )
+    return build_domain_score(domain="mcp", spec=MCP_TRUST_SPEC, adapters=adapters)
+
+
+def build_mcp_surface_domain(
+    *,
+    name: str | None,
+    command: str | None,
+    url: str | None,
+    transport: str | None,
+) -> TrustDomainScore | None:
+    normalized_name = name.strip() if isinstance(name, str) else ""
+    normalized_command = command.strip() if isinstance(command, str) else ""
+    normalized_url = url.strip() if isinstance(url, str) else ""
+    normalized_transport = transport.strip().lower() if isinstance(transport, str) else ""
+
+    has_command = bool(normalized_command)
+    has_endpoint = bool(normalized_url)
+    has_surface = bool(normalized_name) or has_command or has_endpoint
+    if not has_surface:
+        return None
+
+    secure_endpoint = is_https_url(normalized_url)
+    stdio_like = normalized_transport == "stdio"
+    transport_declared = bool(normalized_transport)
+
+    if stdio_like:
+        transport_score = 100.0
+    elif secure_endpoint:
+        transport_score = 85.0
+    elif has_endpoint:
+        transport_score = 25.0
+    else:
+        transport_score = 40.0 if transport_declared else 0.0
+
+    if transport_declared and (has_command or has_endpoint):
+        config_shape_score = 100.0
+    elif has_command or has_endpoint:
+        config_shape_score = 60.0
+    else:
+        config_shape_score = 0.0
+
+    spec_by_id = {adapter.adapter_id: adapter for adapter in MCP_TRUST_SPEC.adapters}
+    adapters = (
+        build_adapter_score(
+            spec_by_id["verification.config-integrity"],
+            component_scores=None,
+            rationales={
+                "score": (
+                    "Config-defined MCP fallback does not claim config-integrity without a parseable .mcp.json payload."
+                )
+            },
+        ),
+        build_adapter_score(
+            spec_by_id["verification.execution-safety"],
+            component_scores=None,
+            rationales={
+                "score": (
+                    "Config-defined MCP fallback does not infer execution-safety "
+                    "without scanner or payload-backed evidence."
+                )
+            },
+        ),
+        build_adapter_score(
+            spec_by_id["verification.transport-security"],
+            component_scores={"score": round_trust_score(transport_score)} if transport_score > 0 else None,
+            rationales={"score": "Transport security was inferred from the MCP transport and endpoint protocol."},
+        ),
+        build_adapter_score(
+            spec_by_id["metadata.server-naming"],
+            component_scores={"score": 100.0} if normalized_name else None,
+            rationales={
+                "score": (
+                    "The MCP server definition provides an explicit server name."
+                    if normalized_name
+                    else "No MCP server name was available from the agent configuration."
+                )
+            },
+        ),
+        build_adapter_score(
+            spec_by_id["metadata.command-or-endpoint"],
+            component_scores={"score": 100.0} if has_command or has_endpoint else None,
+            rationales={
+                "score": (
+                    "The MCP server definition includes a concrete command or endpoint."
+                    if has_command or has_endpoint
+                    else "The MCP server definition is missing both command and endpoint details."
+                )
+            },
+        ),
+        build_adapter_score(
+            spec_by_id["metadata.config-shape"],
+            component_scores={"score": round_trust_score(config_shape_score)} if config_shape_score > 0 else None,
+            rationales={
+                "score": (
+                    "The MCP server definition has enough structure to infer command, endpoint, and transport shape."
+                )
+            },
+        ),
+    )
+    return build_domain_score(domain="mcp", spec=MCP_TRUST_SPEC, adapters=adapters)

{plugin_scanner-2.0.650 → plugin_scanner-2.0.652}/src/codex_plugin_scanner/trust_skill_scoring.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 from pathlib import Path
+from typing import TypedDict
 
 from .checks.manifest import load_manifest
 from .checks.skill_security import SkillSecurityContext
@@ -21,24 +22,37 @@ from .trust_models import TrustDomainScore
 from .trust_specs import SKILL_TRUST_SPEC
 
 
+class NormalizedSkillMetadata(TypedDict):
+    descriptions: tuple[str, ...]
+    repository: str
+    homepage: str
+    commit: str
+    tags: tuple[str, ...]
+    languages: tuple[str, ...]
+
+
 def _skill_files(plugin_dir: Path, manifest: dict[str, object] | None) -> tuple[Path, ...]:
+    standalone_skill = plugin_dir / "SKILL.md"
     if manifest is None:
-        return ()
+        return (standalone_skill,) if standalone_skill.is_file() else ()
     skills_root = manifest.get("skills")
     if not isinstance(skills_root, str) or not skills_root.strip():
-        return ()
+        return (standalone_skill,) if standalone_skill.is_file() else ()
     if not is_safe_relative_path(plugin_dir, skills_root):
-        return ()
+        return (standalone_skill,) if standalone_skill.is_file() else ()
     skills_dir = plugin_dir / skills_root
     if not skills_dir.is_dir():
-        return ()
-    return iter_safe_matching_files(plugin_dir, skills_dir, "**/SKILL.md")
+        return (standalone_skill,) if standalone_skill.is_file() else ()
+    skill_files = tuple(iter_safe_matching_files(plugin_dir, skills_dir, "**/SKILL.md"))
+    if skill_files:
+        return skill_files
+    return (standalone_skill,) if standalone_skill.is_file() else ()
 
 
 def _normalized_skill_metadata(
     manifest: dict[str, object] | None,
     frontmatters: tuple[dict[str, object], ...],
-) -> dict[str, object]:
+) -> NormalizedSkillMetadata:
     descriptions = [
         str(payload.get("description", "")).strip() for payload in frontmatters if payload.get("description")
     ]
@@ -124,6 +138,12 @@ def build_skill_domain(
 
     frontmatters = tuple(payload for payload in (parse_skill_frontmatter(path) for path in skill_files) if payload)
     normalized = _normalized_skill_metadata(manifest, frontmatters)
+    descriptions = normalized["descriptions"]
+    tags = normalized["tags"]
+    languages = normalized["languages"]
+    repository = normalized["repository"]
+    homepage = normalized["homepage"]
+    commit = normalized["commit"]
     has_author = (
         isinstance(manifest, dict)
         and isinstance(manifest.get("author"), dict)
@@ -133,15 +153,13 @@ def build_skill_domain(
     all_frontmatter_valid = len(frontmatters) == len(skill_files) and all(
         has_required_skill_frontmatter(payload) for payload in frontmatters
     )
-    repo_host = url_host(str(normalized["repository"]) or None)
-    home_host = url_host(str(normalized["homepage"]) or None)
+    repo_host = url_host(repository or None)
+    home_host = url_host(homepage or None)
     description_length = (
-        sum(len(description) for description in normalized["descriptions"]) / len(normalized["descriptions"])
-        if normalized["descriptions"]
-        else 0
+        sum(len(description) for description in descriptions) / len(descriptions) if descriptions else 0
     )
-    tag_count = len(normalized["tags"])
-    language_count = len(normalized["languages"])
+    tag_count = len(tags)
+    language_count = len(languages)
 
     adapter_inputs: dict[str, tuple[dict[str, float] | None, dict[str, str], bool]] = {
         "verification.review-status": (
@@ -170,11 +188,11 @@ def build_skill_domain(
             True,
         ),
         "verification.repo-commit-integrity": (
-            {"score": 100.0} if normalized["repository"] and normalized["commit"] else None,
+            {"score": 100.0} if repository and commit else None,
             {
                 "score": (
                     "The bundled skill metadata declares both a repository URL and an immutable commit reference."
-                    if normalized["repository"] and normalized["commit"]
+                    if repository and commit
                     else (
                         "Repo-commit integrity requires both a repository URL and "
                         "a commit reference in local bundled-skill metadata."

{plugin_scanner-2.0.650 → plugin_scanner-2.0.652}/src/codex_plugin_scanner/version.py

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