plugin-scanner 2.0.1111__tar.gz → 2.0.1113__tar.gz

{plugin_scanner-2.0.1111 → plugin_scanner-2.0.1113}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plugin-scanner
-Version: 2.0.1111
+Version: 2.0.1113
 Summary: Lint, verify, and gate plugin ecosystems for maintainers, CI, and publish workflows.
 Project-URL: Homepage, https://hol.org/guard
 Project-URL: Documentation, https://github.com/hashgraph-online/hol-guard/tree/main/docs/guard
@@ -27,7 +27,7 @@ Requires-Python: >=3.10
 Requires-Dist: cisco-ai-skill-scanner~=2.0.11; python_version < '3.14'
 Requires-Dist: cryptography>=49.0.0
 Requires-Dist: keyring>=25.0
-Requires-Dist: mcp<2,>=1.27.0; python_version >= '3.10'
+Requires-Dist: mcp<2,>=1.28.1; python_version >= '3.10'
 Requires-Dist: packaging>=24.0
 Requires-Dist: requests<3,>=2.32
 Requires-Dist: rich<15,>=14.0

{plugin_scanner-2.0.1111 → plugin_scanner-2.0.1113}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "plugin-scanner"
-version = "2.0.1111"
+version = "2.0.1113"
 description = "Lint, verify, and gate plugin ecosystems for maintainers, CI, and publish workflows."
 readme = "README.md"
 license = "Apache-2.0"
@@ -51,7 +51,7 @@ dependencies = [
     "requests>=2.32,<3",
     "tomli>=2.0; python_version < '3.11'",
     "cisco-ai-skill-scanner~=2.0.11; python_version < '3.14'",
-    "mcp>=1.27.0,<2; python_version >= '3.10'",
+    "mcp>=1.28.1,<2; python_version >= '3.10'",
 ]
 
 [project.optional-dependencies]

{plugin_scanner-2.0.1111 → plugin_scanner-2.0.1113}/pyproject.toml.bak

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hol-guard"
-version = "2.0.1111"
+version = "2.0.1113"
 description = "Open-source antivirus and runtime protection for AI agents, tools, MCP servers, plugins, skills, and package installs."
 readme = "README.md"
 license = "Apache-2.0"
@@ -51,7 +51,7 @@ dependencies = [
     "requests>=2.32,<3",
     "tomli>=2.0; python_version < '3.11'",
     "cisco-ai-skill-scanner~=2.0.11; python_version < '3.14'",
-    "mcp>=1.27.0,<2; python_version >= '3.10'",
+    "mcp>=1.28.1,<2; python_version >= '3.10'",
 ]
 
 [project.optional-dependencies]

plugin_scanner-2.0.1111/release-metadata/plugin-scanner-v2.0.1111.toolchain.cdx.json → plugin_scanner-2.0.1113/release-metadata/plugin-scanner-v2.0.1113.toolchain.cdx.json

@@ -27,7 +27,7 @@
     "component": {
       "name": "hol-guard-release-toolchain",
       "type": "application",
-      "version": "2.0.1111"
+      "version": "2.0.1113"
     }
   },
   "specVersion": "1.6",

{plugin_scanner-2.0.1111 → plugin_scanner-2.0.1113}/src/codex_plugin_scanner/guard/cli/commands_dispatch_local.py

@@ -162,6 +162,18 @@ def _run_guard_update_command(
         now=_now(),
         wheel=getattr(args, "wheel", None),
     )
+    if not dry_run and exit_code == 0 and context is not None:
+        from .update_commands import refresh_guard_daemon_after_update
+
+        daemon_refresh, daemon_refresh_note = refresh_guard_daemon_after_update(context)
+        if daemon_refresh is not None:
+            payload["daemon_refresh"] = daemon_refresh
+        if daemon_refresh_note is not None:
+            notes_value = payload.get("notes")
+            note_items = notes_value if isinstance(notes_value, list) else []
+            notes = [str(item) for item in note_items if isinstance(item, str)]
+            notes.append(daemon_refresh_note)
+            payload["notes"] = notes
     if update_store_error is not None:
         notes_value = payload.get("notes")
         notes = [str(item) for item in (notes_value if isinstance(notes_value, list) else []) if isinstance(item, str)]

{plugin_scanner-2.0.1111 → plugin_scanner-2.0.1113}/src/codex_plugin_scanner/guard/cli/update_commands.py

@@ -78,6 +78,38 @@ if before.get("installed_managers"):
 after = package_shim_status(context)
 print(json.dumps({"before": before, "repair": repair, "after": after}))
 """.strip()
+_DAEMON_REFRESH_TIMEOUT_SECONDS = 35.0
+_DAEMON_REFRESH_SCRIPT = """
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+from codex_plugin_scanner.guard.daemon.manager import (
+    clear_guard_daemon_state,
+    ensure_guard_daemon_after_update,
+    repair_approval_center_locator,
+    retire_all_guard_daemons_for_home,
+)
+
+payload = json.loads(sys.stdin.read())
+guard_home = Path(payload["guard_home"]).expanduser().resolve()
+state_path = guard_home / "daemon-state.json"
+if not state_path.is_file():
+    print(json.dumps({"status": "not_running"}))
+    raise SystemExit(0)
+try:
+    state = json.loads(state_path.read_text(encoding="utf-8"))
+except (OSError, json.JSONDecodeError):
+    state = {}
+preferred_port = state.get("port") if isinstance(state.get("port"), int) else None
+retired = retire_all_guard_daemons_for_home(guard_home)
+clear_guard_daemon_state(guard_home)
+repair_approval_center_locator(guard_home)
+daemon_url = ensure_guard_daemon_after_update(guard_home, preferred_port=preferred_port)
+print(json.dumps({"status": "restarted", "retired": retired, "daemon_url": daemon_url}))
+""".strip()
 
 
 def _read_direct_url_dir_info(direct_url: dict[str, object] | None) -> dict[str, object]:
@@ -1226,6 +1258,42 @@ def _refresh_package_shims_after_update(
     return refresh_payload, _package_shim_refresh_note(refresh_payload)
 
 
+def refresh_guard_daemon_after_update(context: HarnessContext) -> tuple[dict[str, object] | None, str | None]:
+    """Restart a resident daemon in a fresh interpreter after a CLI package update."""
+
+    if not (context.guard_home / "daemon-state.json").is_file():
+        return None, None
+    try:
+        refresh_env = dict(os.environ)
+        refresh_env.pop("PYTHONPATH", None)
+        result = subprocess.run(
+            [sys.executable, *_trusted_python_flags(), "-c", _DAEMON_REFRESH_SCRIPT],
+            input=json.dumps({"guard_home": str(context.guard_home)}),
+            capture_output=True,
+            check=False,
+            cwd=str(_trusted_import_root()),
+            env=refresh_env,
+            text=True,
+            timeout=_DAEMON_REFRESH_TIMEOUT_SECONDS,
+        )
+    except (OSError, subprocess.SubprocessError) as error:
+        return None, f"Could not restart the Guard daemon after update: {redact_sensitive_text(str(error))}"
+    stdout = _normalize_output_text(result.stdout)
+    stderr = _normalize_output_text(result.stderr)
+    if result.returncode != 0:
+        details = stderr or stdout or f"exit code {result.returncode}"
+        return None, f"Could not restart the Guard daemon after update: {details}"
+    try:
+        payload = json.loads(stdout) if stdout else {}
+    except json.JSONDecodeError as error:
+        return None, f"Could not parse the Guard daemon restart result after update: {error}"
+    if not isinstance(payload, dict):
+        return None, "Could not parse the Guard daemon restart result after update: invalid payload"
+    status = payload.get("status")
+    note = "Restarted the Guard daemon to load the updated package." if status == "restarted" else None
+    return payload, note
+
+
 def _package_shim_manifest_has_installed_managers(context: HarnessContext) -> bool:
     manifest_path = context.guard_home / "package-shims" / "manifest.json"
     try:

{plugin_scanner-2.0.1111 → plugin_scanner-2.0.1113}/src/codex_plugin_scanner/guard/runtime/github_command_capabilities.py

@@ -1,8 +1,8 @@
 """Classify GitHub CLI commands by their observable security capability.
 
-The classifier intentionally uses positive allowlists for prompt-free reads.  A
-new or aliased ``gh`` command therefore cannot inherit read-only status merely
-because it is followed by an output formatter in a shell pipeline.
+The classifier uses reviewed command sets for prompt-free reads and routine
+mutations. A new or aliased ``gh`` command therefore cannot inherit trusted
+status merely because it is followed by an output formatter in a shell pipeline.
 """
 
 from __future__ import annotations
@@ -15,6 +15,7 @@ from typing import Literal
 GitHubCommandCapability = Literal[
     "read_local",
     "read_remote",
+    "maintain_remote",
     "mutate_remote",
     "write_local",
     "unknown",
@@ -75,8 +76,16 @@ _MUTATING_SUBCOMMANDS: dict[str, frozenset[str]] = {
     "run": frozenset({"cancel", "delete", "rerun"}),
     "workflow": frozenset({"disable", "enable", "run"}),
 }
+_MAINTENANCE_SUBCOMMANDS: dict[str, frozenset[str]] = {"pr": frozenset({"merge"})}
 
-_ALWAYS_MUTATING_GROUPS = frozenset({"cache", "codespace", "gpg-key", "label", "secret", "ssh-key", "variable"})
+_HIGH_IMPACT_SUBCOMMANDS: dict[str, frozenset[str]] = {
+    "release": frozenset({"delete"}),
+    "repo": frozenset({"archive", "delete", "rename"}),
+    "workflow": frozenset({"disable"}),
+}
+
+_HIGH_IMPACT_GROUPS = frozenset({"gpg-key", "secret", "ssh-key"})
+_ROUTINE_MUTATING_GROUPS = frozenset({"cache", "codespace", "label", "variable"})
 _READ_ONLY_TOP_LEVEL = frozenset({"search", "status"})
 _LOCAL_TOP_LEVEL = frozenset({"completion", "help", "version"})
 _LOCAL_AUTH_SUBCOMMANDS = frozenset({"status", "token"})
@@ -106,8 +115,26 @@ _API_OPTIONS_WITH_VALUES = frozenset(
 _API_BOOLEAN_OPTIONS = frozenset({"--include", "--paginate", "--silent", "--slurp", "--verbose", "-i"})
 _METHOD_OVERRIDE_HEADER = re.compile(r"\Ax-http-method-override\s*:", re.IGNORECASE)
 _STATIC_ENDPOINT = re.compile(r"\A[A-Za-z0-9_./{}:+,@=-]+\Z")
-_GRAPHQL_NAME = re.compile(r"\b[_A-Za-z][_0-9A-Za-z]*\b")
-_GRAPHQL_ALIAS = re.compile(r"\b(?P<name>[_A-Za-z][_0-9A-Za-z]*)\s*:")
+_ROUTINE_API_ROOTS = frozenset({"gists", "notifications"})
+_ROUTINE_ACTIONS_API_RESOURCES = frozenset({"artifacts", "caches", "jobs", "runs", "workflows"})
+_ROUTINE_REPO_API_RESOURCES = frozenset(
+    {
+        "actions",
+        "check-runs",
+        "check-suites",
+        "comments",
+        "deployments",
+        "dispatches",
+        "git",
+        "issues",
+        "labels",
+        "merges",
+        "milestones",
+        "pulls",
+        "releases",
+        "statuses",
+    }
+)
 
 
 def classify_github_cli(args: Sequence[str]) -> GitHubCommandAssessment:
@@ -145,11 +172,23 @@ def classify_github_cli(args: Sequence[str]) -> GitHubCommandAssessment:
             "github.command.proven-read",
             "The command is a known read-only GitHub operation.",
         )
-    if top_level in _ALWAYS_MUTATING_GROUPS:
+    if top_level in _HIGH_IMPACT_GROUPS:
         return _assessment(
             "mutate_remote",
-            "github.command.remote-mutation",
-            "The command group can change GitHub-hosted state.",
+            "github.command.high-impact-mutation",
+            "The command changes GitHub credentials or secrets.",
+        )
+    if top_level in _ROUTINE_MUTATING_GROUPS:
+        if _group_subcommand(normalized[1:]) == "delete":
+            return _assessment(
+                "mutate_remote",
+                "github.command.high-impact-mutation",
+                "The command deletes GitHub-hosted state.",
+            )
+        return _assessment(
+            "maintain_remote",
+            "github.command.routine-mutation",
+            "The command performs a known routine GitHub mutation.",
         )
     if top_level in _READ_ONLY_SUBCOMMANDS:
         subcommand = _group_subcommand(normalized[1:])
@@ -167,11 +206,23 @@ def classify_github_cli(args: Sequence[str]) -> GitHubCommandAssessment:
                 "github.command.proven-read",
                 "The command is a known read-only GitHub operation.",
             )
-        if subcommand in _MUTATING_SUBCOMMANDS[top_level]:
+        if _is_high_impact_command(top_level, subcommand, normalized[2:]):
             return _assessment(
                 "mutate_remote",
-                "github.command.remote-mutation",
-                "The command can change GitHub-hosted state.",
+                "github.command.high-impact-mutation",
+                "The command performs an explicitly high-impact GitHub mutation.",
+            )
+        if subcommand in _MAINTENANCE_SUBCOMMANDS.get(top_level, frozenset()):
+            return _assessment(
+                "maintain_remote",
+                "github.command.pr-maintenance",
+                "The command performs a statically proven pull-request maintenance operation.",
+            )
+        if subcommand in _MUTATING_SUBCOMMANDS[top_level]:
+            return _assessment(
+                "maintain_remote",
+                "github.command.routine-mutation",
+                "The command performs a known routine GitHub mutation.",
             )
         return _assessment(
             "unknown",
@@ -185,6 +236,24 @@ def classify_github_cli(args: Sequence[str]) -> GitHubCommandAssessment:
     )
 
 
+def _is_high_impact_command(top_level: str, subcommand: str, args: Sequence[str]) -> bool:
+    if subcommand == "delete":
+        return True
+    if subcommand in _HIGH_IMPACT_SUBCOMMANDS.get(top_level, frozenset()):
+        return True
+    if top_level == "pr" and subcommand == "merge":
+        return _has_option(args, "--admin")
+    if top_level == "repo" and subcommand == "edit":
+        return _has_option(args, "--visibility")
+    if top_level == "repo" and subcommand == "sync":
+        return _has_option(args, "--force")
+    return False
+
+
+def _has_option(args: Sequence[str], option: str) -> bool:
+    return any(token == option or token.startswith(f"{option}=") for token in args)
+
+
 def _strip_global_options(args: list[str]) -> list[str]:
     index = 0
     while index < len(args):
@@ -257,12 +326,6 @@ def _classify_api(args: Sequence[str]) -> GitHubCommandAssessment:
             "An HTTP method-override header prevents reliable API capability classification.",
         )
     method = parsed.method.upper() if parsed.method is not None else None
-    if method is not None and method not in {"GET", "HEAD"}:
-        return _assessment(
-            "mutate_remote",
-            "github.api.mutating-method",
-            "The GitHub API request uses a method that can change remote state.",
-        )
     if parsed.endpoint.lower() == "graphql":
         return _classify_graphql(parsed, method=method)
     if any(_field_value_is_external(value) for _name, value in parsed.fields):
@@ -271,15 +334,56 @@ def _classify_api(args: Sequence[str]) -> GitHubCommandAssessment:
             "github.api.external-field-value",
             "A GitHub API field loaded from external data cannot be classified statically.",
         )
+    if method is not None and method not in {"GET", "HEAD"}:
+        if _api_request_is_high_impact(parsed, method=method):
+            return _assessment(
+                "mutate_remote",
+                "github.api.high-impact-mutation",
+                "The GitHub API request performs an explicitly high-impact operation.",
+            )
+        return _assessment(
+            "maintain_remote",
+            "github.api.routine-mutation",
+            "The GitHub API request performs a statically understood routine mutation.",
+        )
     if parsed.fields and method is None:
+        if _api_request_is_high_impact(parsed, method="POST"):
+            return _assessment(
+                "mutate_remote",
+                "github.api.high-impact-mutation",
+                "The GitHub API request performs an explicitly high-impact operation.",
+            )
         return _assessment(
-            "mutate_remote",
-            "github.api.implicit-write-method",
-            "GitHub API fields select a write-capable request method unless GET is explicit.",
+            "maintain_remote",
+            "github.api.routine-mutation",
+            "GitHub API fields select a statically understood routine mutation.",
         )
     return _assessment("read_remote", "github.api.proven-get", "The GitHub API request is a statically proven read.")
 
 
+def _api_request_is_high_impact(parsed: _ApiArguments, *, method: str) -> bool:
+    endpoint = parsed.endpoint.strip("/").lower()
+    segments = tuple(segment for segment in endpoint.split("/") if segment)
+    if method == "DELETE":
+        return True
+    if len(segments) < 3 or segments[0] != "repos":
+        return not segments or segments[0] not in _ROUTINE_API_ROOTS
+    resource = segments[3:]
+    if not resource:
+        return method == "PATCH"
+    if resource[0] == "rulesets" or any(segment in {"keys", "secrets"} for segment in resource):
+        return True
+    if resource[:2] in {("actions", "permissions"), ("git", "refs")}:
+        return True
+    if resource[0] == "actions":
+        return len(resource) < 2 or resource[1] not in _ROUTINE_ACTIONS_API_RESOURCES
+    if resource[0] == "branches" and "protection" in resource:
+        return True
+    if resource[0] in {"collaborators", "hooks"}:
+        return True
+    return resource[0] == "transfer" or resource[0] not in _ROUTINE_REPO_API_RESOURCES
+
+
 def _parse_api_arguments(args: Sequence[str]) -> _ApiArguments | GitHubCommandAssessment:
     endpoint: str | None = None
     method: str | None = None
@@ -367,110 +471,10 @@ def _classify_graphql(parsed: _ApiArguments, *, method: str | None) -> GitHubCom
 
 
 def _classify_graphql_document(document: str) -> GitHubCommandAssessment:
-    sanitized = _strip_graphql_strings_and_comments(document)
-    suspicious_aliases = [
-        match.group("name")
-        for match in _GRAPHQL_ALIAS.finditer(sanitized)
-        if "mutation" in match.group("name").lower() or "subscription" in match.group("name").lower()
-    ]
-    if suspicious_aliases:
-        return _assessment(
-            "unknown",
-            "github.graphql.suspicious-alias",
-            "A GraphQL alias resembles an operation type and is not classified automatically.",
-        )
-    operations = _top_level_graphql_operations(sanitized)
-    if operations is None:
-        return _assessment("unknown", "github.graphql.invalid-document", "The GraphQL document is not balanced.")
-    if not operations:
-        return _assessment("unknown", "github.graphql.missing-operation", "No static GraphQL operation was found.")
-    if len(operations) != 1:
-        return _assessment(
-            "unknown",
-            "github.graphql.multiple-operations",
-            "Multiple GraphQL operations or a batched document cannot be classified automatically.",
-        )
-    operation = operations[0]
-    if operation in {"mutation", "subscription"}:
-        return _assessment(
-            "mutate_remote",
-            "github.graphql.remote-mutation",
-            "The GraphQL operation can change or subscribe to GitHub-hosted state.",
-        )
-    return _assessment("read_remote", "github.graphql.proven-query", "The GraphQL document is a single static query.")
-
-
-def _top_level_graphql_operations(document: str) -> list[str] | None:
-    operations: list[str] = []
-    depth = 0
-    pending_definition = False
-    index = 0
-    while index < len(document):
-        character = document[index]
-        if character == "{":
-            if depth == 0:
-                if not pending_definition:
-                    operations.append("query")
-                pending_definition = False
-            depth += 1
-            index += 1
-            continue
-        if character == "}":
-            if depth == 0:
-                return None
-            depth -= 1
-            index += 1
-            continue
-        if depth == 0:
-            name_match = _GRAPHQL_NAME.match(document, index)
-            if name_match is not None:
-                name = name_match.group(0).lower()
-                if name in {"query", "mutation", "subscription"}:
-                    operations.append(name)
-                    pending_definition = True
-                elif name == "fragment":
-                    pending_definition = True
-                index = name_match.end()
-                continue
-        index += 1
-    return operations if depth == 0 else None
-
+    from .github_graphql_capabilities import classify_graphql_document
 
-def _strip_graphql_strings_and_comments(document: str) -> str:
-    output: list[str] = []
-    index = 0
-    while index < len(document):
-        if document.startswith('"""', index):
-            end = document.find('"""', index + 3)
-            if end == -1:
-                return ""
-            output.extend(" " * (end + 3 - index))
-            index = end + 3
-            continue
-        character = document[index]
-        if character == '"':
-            output.append(" ")
-            index += 1
-            escaped = False
-            while index < len(document):
-                current = document[index]
-                output.append(" ")
-                index += 1
-                if escaped:
-                    escaped = False
-                elif current == "\\":
-                    escaped = True
-                elif current == '"':
-                    break
-            continue
-        if character == "#":
-            while index < len(document) and document[index] not in "\r\n":
-                output.append(" ")
-                index += 1
-            continue
-        output.append(character)
-        index += 1
-    return "".join(output)
+    capability, reason_code, detail = classify_graphql_document(document)
+    return _assessment(capability, reason_code, detail)
 
 
 def _field_value_is_external(value: str) -> bool: