plugin-scanner 2.0.1097__tar.gz → 2.0.1098__tar.gz

{plugin_scanner-2.0.1097 → plugin_scanner-2.0.1098}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plugin-scanner
-Version: 2.0.1097
+Version: 2.0.1098
 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

{plugin_scanner-2.0.1097 → plugin_scanner-2.0.1098}/docs/guard/architecture.md

@@ -56,3 +56,4 @@ Cisco AIBOM stays out of Guard runtime policy in this phase. If it returns later
 - [Backup command extension coverage](command-backup-extension-coverage.md)
 - [Remote command extension coverage](command-remote-extension-coverage.md)
 - [Database command extension coverage](command-database-extension-coverage.md)
+- [Search and messaging command extension coverage](command-search-messaging-extension-coverage.md)

plugin_scanner-2.0.1098/docs/guard/command-search-messaging-extension-coverage.md

@@ -0,0 +1,19 @@
+# Search and Messaging Command Extension Coverage
+
+Guard's search and messaging extensions match parsed executables, HTTP methods and service targets, leading options, exact subcommands, and deletion flags. Quoted examples and unrelated HTTP APIs do not trigger these rules.
+
+## Covered Operations
+
+- Explicit Elasticsearch DELETE requests to service-specific APIs or non-root port 9200 paths
+- Kafka topic, consumer-group, offset, and record deletion
+- RabbitMQ queue, user, virtual-host deletion, and broker reset
+- NATS stream, consumer, key-value, and object-store removal or purge
+- Portable executable names and Kafka shell and batch launchers
+- RabbitMQ dry runs, help commands, version commands, and observer commands remain outside destructive review
+
+## References
+
+- [Elasticsearch delete index API](https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-delete)
+- [Kafka documentation](https://kafka.apache.org/documentation/)
+- [RabbitMQ rabbitmqctl](https://www.rabbitmq.com/docs/man/rabbitmqctl.8)
+- [NATS CLI](https://docs.nats.io/using-nats/nats-tools/nats_cli)

{plugin_scanner-2.0.1097 → plugin_scanner-2.0.1098}/pyproject.toml

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

{plugin_scanner-2.0.1097 → plugin_scanner-2.0.1098}/pyproject.toml.bak

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hol-guard"
-version = "2.0.1097"
+version = "2.0.1098"
 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"

{plugin_scanner-2.0.1097 → plugin_scanner-2.0.1098}/src/codex_plugin_scanner/guard/runtime/command_builtin_extension_catalog.py

@@ -8,6 +8,10 @@ from .command_database_extensions import DATABASE_COMMAND_EXTENSION_SPECS, DATAB
 from .command_domain_extensions import DOMAIN_COMMAND_EXTENSION_SPECS, DOMAIN_COMMAND_RULES
 from .command_extension_specs import CommandExtensionValues, command_extension_values
 from .command_remote_extensions import REMOTE_COMMAND_EXTENSION_SPECS, REMOTE_COMMAND_RULES
+from .command_search_messaging_extensions import (
+    SEARCH_MESSAGING_COMMAND_EXTENSION_SPECS,
+    SEARCH_MESSAGING_COMMAND_RULES,
+)
 from .command_storage_extensions import STORAGE_COMMAND_EXTENSION_SPECS, STORAGE_COMMAND_RULES
 
 _DIRECT_EXTENSION_CATALOGS = (
@@ -17,6 +21,7 @@ _DIRECT_EXTENSION_CATALOGS = (
     (STORAGE_COMMAND_EXTENSION_SPECS, STORAGE_COMMAND_RULES),
     (BACKUP_COMMAND_EXTENSION_SPECS, BACKUP_COMMAND_RULES),
     (REMOTE_COMMAND_EXTENSION_SPECS, REMOTE_COMMAND_RULES),
+    (SEARCH_MESSAGING_COMMAND_EXTENSION_SPECS, SEARCH_MESSAGING_COMMAND_RULES),
 )
 
 DIRECT_COMMAND_EXTENSION_VALUES: tuple[CommandExtensionValues, ...] = tuple(

{plugin_scanner-2.0.1097 → plugin_scanner-2.0.1098}/src/codex_plugin_scanner/guard/runtime/command_builtin_rules.py

@@ -17,6 +17,7 @@ from .command_rules import (
     ExecutableMatcher,
     PipelineMatcher,
 )
+from .command_search_messaging_extensions import SEARCH_MESSAGING_COMMAND_RULES
 from .command_storage_extensions import STORAGE_COMMAND_RULES
 
 COMMAND_ACTION_RISK_CLASSES: dict[str, tuple[str, ...]] = {
@@ -358,6 +359,7 @@ BUILT_IN_COMMAND_RULES = (
     *BACKUP_COMMAND_RULES,
     *REMOTE_COMMAND_RULES,
     *DATABASE_COMMAND_RULES,
+    *SEARCH_MESSAGING_COMMAND_RULES,
 )
 
 _RULES_BY_EXTENSION: dict[str, tuple[CommandSafetyRule, ...]] = {}

plugin_scanner-2.0.1098/src/codex_plugin_scanner/guard/runtime/command_search_messaging_extensions.py

@@ -0,0 +1,304 @@
+"""Structured rules and metadata for search and messaging commands."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from urllib.parse import urlsplit
+
+from .command_database_matchers import LeadingSubcommandMatcher
+from .command_extension_matchers import executable_names, safe_flag_variant
+from .command_extension_specs import CommandExtensionSpec
+from .command_matcher_contracts import CommandMatcher, MatcherEvidence
+from .command_model import CanonicalCommand
+from .command_rules import (
+    AnyMatcher,
+    CommandSafetyRule,
+    CommandSafeVariant,
+    ExecutableMatcher,
+)
+
+_CURL_EXECUTABLES = executable_names("curl")
+_RABBITMQ_OPTIONS_WITH_VALUES = frozenset({"-n", "--node", "-t", "--timeout", "--formatter", "--erlang-cookie"})
+_NATS_OPTIONS_WITH_VALUES = frozenset(
+    {
+        "-s",
+        "--server",
+        "--user",
+        "--password",
+        "--creds",
+        "--nkey",
+        "--tlscert",
+        "--tlskey",
+        "--tlsca",
+        "--socks-proxy",
+        "--colors",
+        "--timeout",
+        "--context",
+    }
+)
+
+
+def _portable_script_names(name: str) -> frozenset[str]:
+    return executable_names(name) | {f"{name}.bat", f"{name}.sh"}
+
+
+@dataclass(frozen=True, slots=True)
+class CurlElasticsearchDeleteMatcher:
+    """Match explicit curl DELETE requests to recognizable Elasticsearch targets."""
+
+    executables: frozenset[str] = _CURL_EXECUTABLES
+    service_ports: frozenset[int] = frozenset({9200})
+
+    def match(self, command: CanonicalCommand) -> tuple[MatcherEvidence, ...]:
+        evidence: list[MatcherEvidence] = []
+        for index, segment in enumerate(command.segments):
+            executable = (segment.executable or "").replace("\\", "/").rsplit("/", 1)[-1].lower()
+            if executable not in self.executables:
+                continue
+            method, targets = _curl_method_and_targets(segment.arguments)
+            if method != "delete" or not any(self._matches_target(target) for target in targets):
+                continue
+            evidence.append(
+                MatcherEvidence(
+                    segment_index=index,
+                    executable=segment.executable,
+                    detail="Matched an explicit DELETE request to an Elasticsearch API target.",
+                )
+            )
+        return tuple(evidence)
+
+    def _matches_target(self, target: str) -> bool:
+        lowered = target.lower()
+        if lowered.startswith(("$elasticsearch_", "${elasticsearch_")):
+            return "/" in lowered
+        try:
+            parsed = urlsplit(target)
+            port = parsed.port
+        except ValueError:
+            return False
+        hostname = parsed.hostname or ""
+        recognizable_host = port in self.service_ports or "elasticsearch" in hostname.split(".")
+        return parsed.scheme in {"http", "https"} and recognizable_host and parsed.path not in {"", "/"}
+
+
+def _curl_method_and_targets(arguments: tuple[str, ...]) -> tuple[str | None, tuple[str, ...]]:
+    method: str | None = None
+    targets: list[str] = []
+    index = 0
+    while index < len(arguments):
+        argument = arguments[index]
+        lowered = argument.lower()
+        if argument == "-x" or lowered == "--proxy":
+            index += 2
+            continue
+        if (argument.startswith("-x") and len(argument) > 2) or lowered.startswith("--proxy="):
+            index += 1
+            continue
+        if (argument == "-X" or lowered == "--request") and index + 1 < len(arguments):
+            method = arguments[index + 1].lower()
+            index += 2
+            continue
+        if lowered.startswith("--request="):
+            method = lowered.split("=", 1)[1]
+        elif argument.startswith("-X") and len(argument) > 2:
+            method = argument[2:].lower()
+        if argument.startswith(("http://", "https://", "$")):
+            targets.append(argument.strip("'\""))
+        index += 1
+    return method, tuple(targets)
+
+
+def _safe_flag_variant(
+    executables: frozenset[str],
+    *,
+    variant_id: str,
+    title: str,
+    flag: str,
+) -> CommandSafeVariant:
+    return CommandSafeVariant(
+        variant_id=variant_id,
+        title=title,
+        matcher=ExecutableMatcher(
+            executables=executables,
+            required_flags=frozenset({flag}),
+            required_flags_in_all_arguments=True,
+        ),
+    )
+
+
+_ELASTICSEARCH_DELETE = CurlElasticsearchDeleteMatcher()
+_KAFKA_DELETE = AnyMatcher(
+    matchers=(
+        ExecutableMatcher(
+            executables=_portable_script_names("kafka-topics"),
+            required_flags=frozenset({"--delete"}),
+            required_flags_in_all_arguments=True,
+        ),
+        ExecutableMatcher(
+            executables=_portable_script_names("kafka-consumer-groups"),
+            required_flags=frozenset({"--delete"}),
+            required_flags_in_all_arguments=True,
+        ),
+        ExecutableMatcher(
+            executables=_portable_script_names("kafka-consumer-groups"),
+            required_flags=frozenset({"--delete-offsets"}),
+            required_flags_in_all_arguments=True,
+        ),
+        ExecutableMatcher(
+            executables=_portable_script_names("kafka-delete-records"),
+            required_flags=frozenset({"--offset-json-file"}),
+            required_flags_in_all_arguments=True,
+        ),
+    )
+)
+_RABBITMQ_EXECUTABLES = executable_names("rabbitmqctl") | {"rabbitmqctl.bat"}
+_RABBITMQ_DELETE = AnyMatcher(
+    matchers=tuple(
+        LeadingSubcommandMatcher(
+            executables=_RABBITMQ_EXECUTABLES,
+            subcommands=(command,),
+            options_with_values=_RABBITMQ_OPTIONS_WITH_VALUES,
+        )
+        for command in ("delete_queue", "delete_user", "delete_vhost", "force_reset", "reset")
+    )
+)
+_NATS_EXECUTABLES = executable_names("nats")
+_NATS_DELETE = AnyMatcher(
+    matchers=tuple(
+        LeadingSubcommandMatcher(
+            executables=_NATS_EXECUTABLES,
+            subcommands=subcommands,
+            options_with_values=_NATS_OPTIONS_WITH_VALUES,
+        )
+        for subcommands in (
+            ("stream", "rm"),
+            ("stream", "purge"),
+            ("str", "rm"),
+            ("str", "purge"),
+            ("consumer", "rm"),
+            ("con", "rm"),
+            ("kv", "rm"),
+            ("kv", "nuke"),
+            ("object", "rm"),
+            ("object", "nuke"),
+            ("obj", "rm"),
+            ("obj", "nuke"),
+        )
+    )
+)
+
+
+def _service_rule(
+    *,
+    rule_id: str,
+    title: str,
+    description: str,
+    matcher: CommandMatcher,
+    action_class: str,
+    safer_alternative: str,
+    safe_variants: tuple[CommandSafeVariant, ...] = (),
+) -> CommandSafetyRule:
+    return CommandSafetyRule(
+        rule_id=rule_id,
+        title=title,
+        description=description,
+        severity="critical",
+        risk_classes=("destructive_shell", "network_egress"),
+        action_classes=(action_class,),
+        safer_alternatives=(safer_alternative,),
+        matcher=matcher,
+        safe_variants=safe_variants,
+    )
+
+
+SEARCH_MESSAGING_COMMAND_RULES = (
+    _service_rule(
+        rule_id="command.search.elasticsearch.delete",
+        title="Elasticsearch resource deletion",
+        description="Identifies explicit DELETE requests to recognizable Elasticsearch APIs.",
+        matcher=_ELASTICSEARCH_DELETE,
+        action_class="Elasticsearch destructive command",
+        safer_alternative="List the exact resource and capture its configuration before sending DELETE.",
+    ),
+    _service_rule(
+        rule_id="command.messaging.kafka.delete",
+        title="Kafka resource deletion",
+        description="Identifies topic, consumer-group, offset, and record deletion operations.",
+        matcher=_KAFKA_DELETE,
+        action_class="Kafka destructive command",
+        safer_alternative="Describe the exact topic or group and verify retention and recovery state first.",
+        safe_variants=(
+            safe_flag_variant(_KAFKA_DELETE, variant_id="help", title="Kafka command help", flag="--help"),
+            safe_flag_variant(_KAFKA_DELETE, variant_id="version", title="Kafka version", flag="--version"),
+        ),
+    ),
+    _service_rule(
+        rule_id="command.messaging.rabbitmq.delete",
+        title="RabbitMQ resource deletion",
+        description="Identifies queue, user, virtual-host, and broker reset operations.",
+        matcher=_RABBITMQ_DELETE,
+        action_class="RabbitMQ destructive command",
+        safer_alternative="List the target resource, bindings, permissions, and recovery policy first.",
+        safe_variants=(
+            _safe_flag_variant(
+                _RABBITMQ_EXECUTABLES,
+                variant_id="dry-run",
+                title="RabbitMQ command preview",
+                flag="--dry-run",
+            ),
+            _safe_flag_variant(_RABBITMQ_EXECUTABLES, variant_id="help", title="RabbitMQ command help", flag="--help"),
+        ),
+    ),
+    _service_rule(
+        rule_id="command.messaging.nats.delete",
+        title="NATS resource deletion",
+        description="Identifies stream, consumer, key-value, and object-store removal operations.",
+        matcher=_NATS_DELETE,
+        action_class="NATS destructive command",
+        safer_alternative="Report the selected context and inspect the resource before removal or purge.",
+        safe_variants=(
+            _safe_flag_variant(_NATS_EXECUTABLES, variant_id="help", title="NATS command help", flag="--help"),
+            _safe_flag_variant(_NATS_EXECUTABLES, variant_id="version", title="NATS version", flag="--version"),
+        ),
+    ),
+)
+
+
+SEARCH_MESSAGING_COMMAND_EXTENSION_SPECS = (
+    CommandExtensionSpec(
+        extension_id="command.search.elasticsearch",
+        name="Elasticsearch command protection",
+        description="Reviews explicit DELETE requests to recognizable Elasticsearch API targets.",
+        action_classes=("Elasticsearch destructive command",),
+        risk_classes=("destructive_shell", "network_egress"),
+        safer_alternatives=("List and export the target resource before sending DELETE.",),
+        reference_urls=("https://www.elastic.co/docs/api/doc/elasticsearch/operation/operation-indices-delete",),
+    ),
+    CommandExtensionSpec(
+        extension_id="command.messaging.kafka",
+        name="Kafka command protection",
+        description="Reviews Kafka topic, group, offset, and record deletion operations.",
+        action_classes=("Kafka destructive command",),
+        risk_classes=("destructive_shell", "network_egress"),
+        safer_alternatives=("Describe the target and verify retention and recovery state first.",),
+        reference_urls=("https://kafka.apache.org/documentation/",),
+    ),
+    CommandExtensionSpec(
+        extension_id="command.messaging.rabbitmq",
+        name="RabbitMQ command protection",
+        description="Reviews RabbitMQ deletion and broker reset operations.",
+        action_classes=("RabbitMQ destructive command",),
+        risk_classes=("destructive_shell", "network_egress"),
+        safer_alternatives=("List bindings, permissions, and recovery state before deletion.",),
+        reference_urls=("https://www.rabbitmq.com/docs/man/rabbitmqctl.8",),
+    ),
+    CommandExtensionSpec(
+        extension_id="command.messaging.nats",
+        name="NATS command protection",
+        description="Reviews NATS stream, consumer, key-value, and object-store removal operations.",
+        action_classes=("NATS destructive command",),
+        risk_classes=("destructive_shell", "network_egress"),
+        safer_alternatives=("Inspect the active context and selected resource before removal.",),
+        reference_urls=("https://docs.nats.io/using-nats/nats-tools/nats_cli",),
+    ),
+)

{plugin_scanner-2.0.1097 → plugin_scanner-2.0.1098}/src/codex_plugin_scanner/version.py

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

{plugin_scanner-2.0.1097 → plugin_scanner-2.0.1098}/tests/test_guard_command_extensions.py

@@ -93,7 +93,7 @@ def test_command_extension_registry_is_deterministic_and_complete() -> None:
     assert "command.shell-mutations" in ids
     assert BUILT_IN_COMMAND_EXTENSION_REGISTRY.for_action_class("destructive shell command") is not None
     assert BUILT_IN_COMMAND_EXTENSION_REGISTRY.rule_for_action_class("destructive shell command") is not None
-    assert sum(extension["rule_count"] for extension in payload["extensions"]) == 47
+    assert sum(extension["rule_count"] for extension in payload["extensions"]) == 51
 
 
 @pytest.mark.parametrize(

plugin_scanner-2.0.1098/tests/test_guard_command_search_messaging_extensions.py

@@ -0,0 +1,155 @@
+"""Structured search and messaging command extension tests."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from codex_plugin_scanner.guard.runtime.command_extensions import BUILT_IN_COMMAND_EXTENSION_REGISTRY
+from codex_plugin_scanner.guard.runtime.command_inspection import inspect_command
+from codex_plugin_scanner.guard.runtime.secret_file_requests import extract_sensitive_tool_action_request
+
+
+@pytest.mark.parametrize(
+    ("command", "action_class", "rule_id"),
+    [
+        (
+            "curl -X DELETE http://localhost:9200/customer-index",
+            "Elasticsearch destructive command",
+            "command.search.elasticsearch.delete",
+        ),
+        (
+            "curl.exe --request=DELETE '$ELASTICSEARCH_URL/_data_stream/events'",
+            "Elasticsearch destructive command",
+            "command.search.elasticsearch.delete",
+        ),
+        (
+            "curl -X DELETE -x http://proxy.example http://localhost:9200/customer-index",
+            "Elasticsearch destructive command",
+            "command.search.elasticsearch.delete",
+        ),
+        (
+            "kafka-topics.sh --bootstrap-server localhost:9092 --delete --topic events",
+            "Kafka destructive command",
+            "command.messaging.kafka.delete",
+        ),
+        (
+            "kafka-consumer-groups.bat --bootstrap-server localhost:9092 "
+            "--delete-offsets --group workers --topic events",
+            "Kafka destructive command",
+            "command.messaging.kafka.delete",
+        ),
+        (
+            "kafka-delete-records --bootstrap-server localhost:9092 --offset-json-file offsets.json",
+            "Kafka destructive command",
+            "command.messaging.kafka.delete",
+        ),
+        (
+            "rabbitmqctl -n rabbit@host delete_vhost production",
+            "RabbitMQ destructive command",
+            "command.messaging.rabbitmq.delete",
+        ),
+        (
+            "rabbitmqctl.bat force_reset",
+            "RabbitMQ destructive command",
+            "command.messaging.rabbitmq.delete",
+        ),
+        (
+            "nats --server nats://localhost:4222 stream rm EVENTS",
+            "NATS destructive command",
+            "command.messaging.nats.delete",
+        ),
+        (
+            "nats.exe --context production kv rm sessions",
+            "NATS destructive command",
+            "command.messaging.nats.delete",
+        ),
+        (
+            "nats str purge EVENTS --force",
+            "NATS destructive command",
+            "command.messaging.nats.delete",
+        ),
+        (
+            "nats con rm ORDERS PROCESSOR",
+            "NATS destructive command",
+            "command.messaging.nats.delete",
+        ),
+        (
+            "nats obj nuke artifacts --force",
+            "NATS destructive command",
+            "command.messaging.nats.delete",
+        ),
+        (
+            "nats kv nuke sessions --force",
+            "NATS destructive command",
+            "command.messaging.nats.delete",
+        ),
+    ],
+)
+def test_search_messaging_rules_feed_runtime_hooks(
+    command: str,
+    action_class: str,
+    rule_id: str,
+    tmp_path: Path,
+) -> None:
+    payload = inspect_command(command, cwd=tmp_path, home_dir=tmp_path)
+
+    assert payload["status"] == "review"
+    assert payload["classification"]["action_class"] == action_class
+    assert payload["controlling_rule_id"] == rule_id
+    runtime_match = extract_sensitive_tool_action_request(
+        "Shell",
+        {"command": command},
+        cwd=tmp_path,
+        home_dir=tmp_path,
+    )
+    assert runtime_match is not None
+    assert runtime_match.action_class == action_class
+
+
+@pytest.mark.parametrize(
+    "command",
+    [
+        "curl -X DELETE https://api.example.com/users/1",
+        "curl -X DELETE https://api.example.com/_snapshot/old",
+        "curl -x http://localhost:9200/customer-index https://api.example.com/users/1",
+        "curl http://localhost:9200/customer-index",
+        "curl -X GET http://localhost:9200/customer-index",
+        "kafka-topics.sh --bootstrap-server localhost:9092 --list",
+        "kafka-topics.sh --delete --help",
+        "rabbitmqctl list_vhosts",
+        "rabbitmqctl delete_vhost production --dry-run",
+        "rabbitmqctl delete_user operator --help",
+        "nats stream ls",
+        "nats stream rm EVENTS --help",
+        "grep 'curl -X DELETE|kafka-topics --delete|rabbitmqctl delete_vhost|nats stream rm' docs",
+    ],
+)
+def test_search_messaging_observer_and_preview_commands_remain_safe(command: str, tmp_path: Path) -> None:
+    payload = inspect_command(command, cwd=tmp_path, home_dir=tmp_path)
+
+    assert payload["status"] == "no_match"
+    assert (
+        extract_sensitive_tool_action_request(
+            "Shell",
+            {"command": command},
+            cwd=tmp_path,
+            home_dir=tmp_path,
+        )
+        is None
+    )
+
+
+def test_search_messaging_extensions_publish_official_references() -> None:
+    for extension_id in (
+        "command.search.elasticsearch",
+        "command.messaging.kafka",
+        "command.messaging.rabbitmq",
+        "command.messaging.nats",
+    ):
+        extension = BUILT_IN_COMMAND_EXTENSION_REGISTRY.get(extension_id)
+
+        assert extension is not None
+        assert extension.reference_urls
+        assert all(url.startswith("https://") for url in extension.reference_urls)

{plugin_scanner-2.0.1097 → plugin_scanner-2.0.1098}/uv.lock

@@ -1171,7 +1171,7 @@ wheels = [
 
 [[package]]
 name = "hol-guard"
-version = "2.0.1097"
+version = "2.0.1098"
 source = { editable = "." }
 dependencies = [
     { name = "cisco-ai-skill-scanner" },