plugin-scanner 2.0.1094__tar.gz → 2.0.1096__tar.gz

{plugin_scanner-2.0.1094 → plugin_scanner-2.0.1096}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plugin-scanner
-Version: 2.0.1094
+Version: 2.0.1096
 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.1094 → plugin_scanner-2.0.1096}/docs/guard/architecture.md

@@ -54,3 +54,4 @@ Cisco AIBOM stays out of Guard runtime policy in this phase. If it returns later
 - [Cloud command extension coverage](command-cloud-extension-coverage.md)
 - [Storage command extension coverage](command-storage-extension-coverage.md)
 - [Backup command extension coverage](command-backup-extension-coverage.md)
+- [Remote command extension coverage](command-remote-extension-coverage.md)

plugin_scanner-2.0.1096/docs/guard/command-remote-extension-coverage.md

@@ -0,0 +1,23 @@
+# Remote Command Extension Coverage
+
+Guard's built-in remote administration extensions use parsed executables, leading options, operands, and flags. Quoted examples and unrelated command arguments do not trigger these rules.
+
+## Covered Operations
+
+- Explicit commands executed through SSH after a destination
+- Active command-bearing SSH configuration options supplied with `-o`
+- SCP transfers that can overwrite local or remote destinations
+- Rsync destination deletions and synchronized source-file removal
+- Rsync remote command overrides supplied with `-e`, `--rsh`, `--rsync-path`, or `RSYNC_RSH`
+- Portable `.cmd` and `.exe` launcher names
+- Rsync `--dry-run` and `-n` safe variants, including bundled short flags
+- SSH inspection, query, control, and no-command modes
+
+Interactive SSH connections remain outside the explicit remote-execution rule. Ordinary rsync copies without deletion flags also remain outside the destructive synchronization rule.
+
+## References
+
+- [OpenSSH client](https://man.openbsd.org/ssh)
+- [OpenSSH client configuration](https://man.openbsd.org/ssh_config)
+- [OpenSSH secure copy client](https://man.openbsd.org/scp)
+- [Rsync manual](https://rsync.samba.org/ftp/rsync/rsync.1.html)

{plugin_scanner-2.0.1094 → plugin_scanner-2.0.1096}/pyproject.toml

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

{plugin_scanner-2.0.1094 → plugin_scanner-2.0.1096}/pyproject.toml.bak

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hol-guard"
-version = "2.0.1094"
+version = "2.0.1096"
 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.1094 → plugin_scanner-2.0.1096}/src/codex_plugin_scanner/guard/cli/update_commands.py

@@ -201,7 +201,18 @@ def run_guard_update(
         vcs_install=vcs_install,
         local_source_install=local_source_install,
     )
-    command = _update_command(installer, use_pypi=use_pypi, wheel_path=requested_wheel_path)
+    target_version = None
+    if version_check.get("update_available") is True:
+        latest_version = version_check.get("latest_version")
+        if isinstance(latest_version, str) and latest_version.strip():
+            target_version = latest_version.strip()
+            use_pypi = True
+    command = _update_command(
+        installer,
+        use_pypi=use_pypi,
+        target_version=target_version,
+        wheel_path=requested_wheel_path,
+    )
     execution_command = _execution_update_command(command, installer=installer, context=context)
     if force_pypi_reinstall:
         payload["recovery_reinstall"] = True

{plugin_scanner-2.0.1094 → plugin_scanner-2.0.1096}/src/codex_plugin_scanner/guard/runtime/command_builtin_extension_catalog.py

@@ -6,6 +6,7 @@ from .command_backup_extensions import BACKUP_COMMAND_EXTENSION_SPECS, BACKUP_CO
 from .command_cloud_extensions import CLOUD_COMMAND_EXTENSION_SPECS, CLOUD_COMMAND_RULES
 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_storage_extensions import STORAGE_COMMAND_EXTENSION_SPECS, STORAGE_COMMAND_RULES
 
 _DIRECT_EXTENSION_CATALOGS = (
@@ -13,6 +14,7 @@ _DIRECT_EXTENSION_CATALOGS = (
     (CLOUD_COMMAND_EXTENSION_SPECS, CLOUD_COMMAND_RULES),
     (STORAGE_COMMAND_EXTENSION_SPECS, STORAGE_COMMAND_RULES),
     (BACKUP_COMMAND_EXTENSION_SPECS, BACKUP_COMMAND_RULES),
+    (REMOTE_COMMAND_EXTENSION_SPECS, REMOTE_COMMAND_RULES),
 )
 
 DIRECT_COMMAND_EXTENSION_VALUES: tuple[CommandExtensionValues, ...] = tuple(

{plugin_scanner-2.0.1094 → plugin_scanner-2.0.1096}/src/codex_plugin_scanner/guard/runtime/command_builtin_rules.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from .command_backup_extensions import BACKUP_COMMAND_RULES
 from .command_cloud_extensions import CLOUD_COMMAND_RULES
 from .command_domain_extensions import DOMAIN_COMMAND_RULES
+from .command_remote_extensions import REMOTE_COMMAND_RULES
 from .command_rules import (
     AnyMatcher,
     ArgumentMatcher,
@@ -50,6 +51,11 @@ COMMAND_ACTION_RISK_CLASSES: dict[str, tuple[str, ...]] = {
     "restic destructive command": ("destructive_shell", "network_egress"),
     "borg destructive command": ("destructive_shell", "network_egress"),
     "velero destructive command": ("destructive_shell", "network_egress"),
+    "ssh remote execution command": ("execution", "network_egress"),
+    "ssh configured execution command": ("execution", "network_egress"),
+    "scp overwrite command": ("destructive_shell", "network_egress"),
+    "rsync destructive command": ("destructive_shell", "network_egress"),
+    "rsync remote shell command": ("execution", "network_egress"),
 }
 _GIT_GLOBAL_OPTIONS_WITH_VALUES = frozenset(
     {"-c", "-C", "--config-env", "--exec-path", "--git-dir", "--namespace", "--super-prefix", "--work-tree"}
@@ -343,6 +349,7 @@ BUILT_IN_COMMAND_RULES = (
     *CLOUD_COMMAND_RULES,
     *STORAGE_COMMAND_RULES,
     *BACKUP_COMMAND_RULES,
+    *REMOTE_COMMAND_RULES,
 )
 
 _RULES_BY_EXTENSION: dict[str, tuple[CommandSafetyRule, ...]] = {}

plugin_scanner-2.0.1096/src/codex_plugin_scanner/guard/runtime/command_matcher_contracts.py

@@ -0,0 +1,30 @@
+"""Dependency-neutral contracts shared by command matchers and rules."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Protocol
+
+from .command_model import CanonicalCommand
+
+
+@dataclass(frozen=True, slots=True)
+class MatcherEvidence:
+    """Redaction-safe location emitted by one structured matcher."""
+
+    segment_index: int
+    executable: str | None
+    detail: str
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "segment_index": self.segment_index,
+            "executable": self.executable,
+            "detail": self.detail,
+        }
+
+
+class CommandMatcher(Protocol):
+    """Side-effect-free structured command matcher."""
+
+    def match(self, command: CanonicalCommand) -> tuple[MatcherEvidence, ...]: ...

plugin_scanner-2.0.1096/src/codex_plugin_scanner/guard/runtime/command_remote_extensions.py

@@ -0,0 +1,299 @@
+"""Structured rules and metadata for remote administration commands."""
+
+from __future__ import annotations
+
+from .command_extension_matchers import executable_names, safe_flag_variant
+from .command_extension_specs import CommandExtensionSpec
+from .command_rules import (
+    AnyMatcher,
+    CommandMatcher,
+    CommandRuleSeverity,
+    CommandSafetyRule,
+    CommandSafeVariant,
+    ExecutableMatcher,
+)
+from .command_structured_matchers import EnvironmentNameMatcher, LeadingOperandCountMatcher, OptionValueKeyMatcher
+
+_SSH_OPTIONS_WITH_VALUES = frozenset(
+    {
+        "-B",
+        "-b",
+        "-c",
+        "-D",
+        "-E",
+        "-e",
+        "-F",
+        "-I",
+        "-i",
+        "-J",
+        "-L",
+        "-l",
+        "-m",
+        "-O",
+        "-o",
+        "-P",
+        "-p",
+        "-Q",
+        "-R",
+        "-S",
+        "-W",
+        "-w",
+    }
+)
+_SCP_OPTIONS_WITH_VALUES = frozenset({"-c", "-D", "-F", "-i", "-J", "-l", "-o", "-P", "-S", "-X"})
+_SSH_REMOTE_EXECUTION = LeadingOperandCountMatcher(
+    executables=executable_names("ssh"),
+    minimum_operands=2,
+    options_with_values=_SSH_OPTIONS_WITH_VALUES,
+    forbidden_flags=frozenset({"-G", "-N", "-O", "-Q", "-V", "-W"}),
+)
+_SCP_TRANSFER = LeadingOperandCountMatcher(
+    executables=executable_names("scp"),
+    minimum_operands=2,
+    options_with_values=_SCP_OPTIONS_WITH_VALUES,
+)
+_SSH_CONFIGURED_EXECUTION = AnyMatcher(
+    matchers=(
+        OptionValueKeyMatcher(
+            executables=executable_names("ssh"),
+            option_names=frozenset({"-o"}),
+            value_keys=frozenset({"knownhostscommand", "proxycommand", "remotecommand"}),
+            forbidden_flags=frozenset({"-G", "-O", "-Q", "-V"}),
+            ignored_values=frozenset({"none"}),
+        ),
+        OptionValueKeyMatcher(
+            executables=executable_names("ssh"),
+            option_names=frozenset({"-o"}),
+            value_keys=frozenset({"localcommand"}),
+            forbidden_flags=frozenset({"-G", "-O", "-Q", "-V"}),
+            ignored_values=frozenset({"none"}),
+            required_key_values=(("permitlocalcommand", "yes"),),
+        ),
+    )
+)
+_RSYNC_DESTRUCTIVE_FLAGS = (
+    "--del",
+    "--delete",
+    "--delete-after",
+    "--delete-before",
+    "--delete-delay",
+    "--delete-during",
+    "--delete-excluded",
+    "--delete-missing-args",
+    "--remove-source-files",
+)
+_RSYNC_OPTIONS_WITH_VALUES = frozenset(
+    {
+        "--backup-dir",
+        "--address",
+        "--block-size",
+        "--bwlimit",
+        "--checksum-choice",
+        "--checksum-seed",
+        "--chmod",
+        "--chown",
+        "--compare-dest",
+        "--compress-choice",
+        "--compress-level",
+        "--compress-threads",
+        "--config",
+        "--contimeout",
+        "--copy-as",
+        "--copy-dest",
+        "--debug",
+        "--dparam",
+        "--early-input",
+        "--exclude",
+        "--exclude-from",
+        "--files-from",
+        "--filter",
+        "--groupmap",
+        "--iconv",
+        "--include",
+        "--include-from",
+        "--info",
+        "--log-file",
+        "--log-file-format",
+        "--log-format",
+        "--link-dest",
+        "--max-alloc",
+        "--max-delete",
+        "--max-size",
+        "--min-size",
+        "--modify-window",
+        "--only-write-batch",
+        "--outbuf",
+        "--out-format",
+        "--partial-dir",
+        "--password-file",
+        "--port",
+        "--protocol",
+        "--read-batch",
+        "--remote-option",
+        "--rsh",
+        "--rsync-path",
+        "--skip-compress",
+        "--sockopts",
+        "--stderr",
+        "--stop-after",
+        "--stop-at",
+        "--suffix",
+        "--timeout",
+        "--temp-dir",
+        "--usermap",
+        "--write-batch",
+        "--cc",
+        "--zc",
+        "--zl",
+        "--zt",
+        "-B",
+        "-e",
+        "-f",
+        "-M",
+        "-T",
+    }
+)
+_RSYNC_MUTATION = AnyMatcher(
+    matchers=tuple(
+        ExecutableMatcher(
+            executables=executable_names("rsync"),
+            required_flags=frozenset({flag}),
+            options_with_values=_RSYNC_OPTIONS_WITH_VALUES,
+            required_flags_in_all_arguments=True,
+        )
+        for flag in _RSYNC_DESTRUCTIVE_FLAGS
+    )
+)
+_RSYNC_REMOTE_SHELL = AnyMatcher(
+    matchers=(
+        *(
+            ExecutableMatcher(
+                executables=executable_names("rsync"),
+                required_flags=frozenset({flag}),
+                options_with_values=_RSYNC_OPTIONS_WITH_VALUES,
+                required_flags_in_all_arguments=True,
+            )
+            for flag in ("--rsync-path", "--rsh", "-e")
+        ),
+        EnvironmentNameMatcher(
+            executables=executable_names("rsync"),
+            environment_names=frozenset({"RSYNC_RSH"}),
+        ),
+    )
+)
+
+
+def _remote_rule(
+    *,
+    rule_id: str,
+    title: str,
+    description: str,
+    matcher: CommandMatcher,
+    action_class: str,
+    safer_alternative: str,
+    severity: CommandRuleSeverity,
+    risk_classes: tuple[str, ...] = ("destructive_shell", "network_egress"),
+    safe_variants: tuple[CommandSafeVariant, ...] = (),
+) -> CommandSafetyRule:
+    return CommandSafetyRule(
+        rule_id=rule_id,
+        title=title,
+        description=description,
+        severity=severity,
+        risk_classes=risk_classes,
+        action_classes=(action_class,),
+        safer_alternatives=(safer_alternative,),
+        matcher=matcher,
+        safe_variants=safe_variants,
+    )
+
+
+REMOTE_COMMAND_RULES = (
+    _remote_rule(
+        rule_id="command.remote.ssh.execution",
+        title="Explicit SSH remote execution",
+        description="Identifies SSH commands that provide an explicit command to execute after the destination.",
+        matcher=_SSH_REMOTE_EXECUTION,
+        action_class="SSH remote execution command",
+        safer_alternative="Connect interactively first or inspect the resolved SSH configuration with ssh -G.",
+        severity="high",
+        risk_classes=("execution", "network_egress"),
+    ),
+    _remote_rule(
+        rule_id="command.remote.ssh.configured-execution",
+        title="SSH configured command execution",
+        description="Identifies SSH options that configure local, host-key, proxy, or remote shell commands.",
+        matcher=_SSH_CONFIGURED_EXECUTION,
+        action_class="SSH configured execution command",
+        safer_alternative=(
+            "Move connection-only settings into reviewed SSH configuration and omit command-bearing options."
+        ),
+        severity="high",
+        risk_classes=("execution", "network_egress"),
+    ),
+    _remote_rule(
+        rule_id="command.remote.scp.transfer",
+        title="SCP file transfer",
+        description="Identifies SCP transfers that can overwrite files at a local or remote destination.",
+        matcher=_SCP_TRANSFER,
+        action_class="SCP overwrite command",
+        safer_alternative="Inspect both endpoints and copy to a new destination path before replacing existing data.",
+        severity="high",
+    ),
+    _remote_rule(
+        rule_id="command.remote.rsync.remote-shell",
+        title="Rsync remote shell command",
+        description="Identifies rsync commands that override the remote-side command executed through the shell.",
+        matcher=_RSYNC_REMOTE_SHELL,
+        action_class="Rsync remote shell command",
+        safer_alternative=(
+            "Use the default remote rsync command or inspect the remote command override before execution."
+        ),
+        severity="high",
+        risk_classes=("execution", "network_egress"),
+    ),
+    _remote_rule(
+        rule_id="command.remote.rsync.deletion",
+        title="Rsync destructive synchronization",
+        description="Identifies rsync deletion and source-removal options that can remove synchronized data.",
+        matcher=_RSYNC_MUTATION,
+        action_class="Rsync destructive command",
+        safer_alternative="Run the same rsync command with --dry-run and inspect every deletion first.",
+        severity="critical",
+        safe_variants=(
+            safe_flag_variant(_RSYNC_MUTATION, variant_id="dry-run", title="Rsync dry run", flag="--dry-run"),
+            safe_flag_variant(_RSYNC_MUTATION, variant_id="short-dry-run", title="Rsync short dry run", flag="-n"),
+        ),
+    ),
+)
+
+
+REMOTE_COMMAND_EXTENSION_SPECS = (
+    CommandExtensionSpec(
+        extension_id="command.remote.ssh",
+        name="SSH remote execution protection",
+        description="Reviews SSH invocations that explicitly execute a remote command.",
+        action_classes=("SSH remote execution command", "SSH configured execution command"),
+        risk_classes=("execution", "network_egress"),
+        safer_alternatives=("Connect interactively or inspect resolved connection settings with ssh -G first.",),
+        reference_urls=("https://man.openbsd.org/ssh", "https://man.openbsd.org/ssh_config"),
+    ),
+    CommandExtensionSpec(
+        extension_id="command.remote.scp",
+        name="SCP transfer protection",
+        description="Reviews SCP transfers that can overwrite local or remote destination files.",
+        action_classes=("SCP overwrite command",),
+        risk_classes=("destructive_shell", "network_egress"),
+        safer_alternatives=("Transfer to a new path and verify both endpoints before replacing data.",),
+        reference_urls=("https://man.openbsd.org/scp",),
+    ),
+    CommandExtensionSpec(
+        extension_id="command.remote.rsync",
+        name="Rsync deletion protection",
+        description="Reviews rsync options that delete destination data or remove synchronized source files.",
+        action_classes=("Rsync destructive command", "Rsync remote shell command"),
+        risk_classes=("destructive_shell", "execution", "network_egress"),
+        safer_alternatives=("Use --dry-run and inspect the itemized change list before applying deletions.",),
+        reference_urls=("https://rsync.samba.org/ftp/rsync/rsync.1.html",),
+    ),
+)

{plugin_scanner-2.0.1094 → plugin_scanner-2.0.1096}/src/codex_plugin_scanner/guard/runtime/command_rules.py

@@ -3,8 +3,9 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Literal, Protocol, final
+from typing import Literal, final
 
+from .command_matcher_contracts import CommandMatcher, MatcherEvidence
 from .command_model import CanonicalCommand, CommandSegment
 
 CommandRuleSeverity = Literal["critical", "high", "medium", "low"]
@@ -15,28 +16,6 @@ _VALID_MODES = frozenset({"required", "enforce", "review", "monitor", "disabled"
 _EMPTY_STRING_SET: frozenset[str] = frozenset()
 
 
-@dataclass(frozen=True, slots=True)
-class MatcherEvidence:
-    """Redaction-safe location emitted by one structured matcher."""
-
-    segment_index: int
-    executable: str | None
-    detail: str
-
-    def to_dict(self) -> dict[str, object]:
-        return {
-            "segment_index": self.segment_index,
-            "executable": self.executable,
-            "detail": self.detail,
-        }
-
-
-class CommandMatcher(Protocol):
-    """Side-effect-free structured command matcher."""
-
-    def match(self, command: CanonicalCommand) -> tuple[MatcherEvidence, ...]: ...
-
-
 @final
 @dataclass(frozen=True, slots=True)
 class ExecutableMatcher:
@@ -342,6 +321,12 @@ def matcher_index_hints(matcher: CommandMatcher) -> MatcherIndexHints:
             executables=matcher.executables,
             keywords=matcher.required_arguments,
         )
+    from .command_structured_matchers import structured_matcher_index_hints
+
+    structured_hints = structured_matcher_index_hints(matcher)
+    if structured_hints is not None:
+        executables, keywords = structured_hints
+        return MatcherIndexHints(executables=executables, keywords=keywords)
     if isinstance(matcher, PipelineMatcher):
         return _merge_matcher_hints((matcher.producer, matcher.consumer))
     if isinstance(matcher, (AnyMatcher, AllMatcher)):
@@ -365,6 +350,11 @@ def _segment_matches_executable(segment: CommandSegment, executables: frozenset[
     return executable in executables
 
 
+def _normalize_option_token(value: str) -> str:
+    stripped = value.strip()
+    return stripped.lower() if stripped.startswith("--") else stripped
+
+
 def _present_flags(
     arguments: tuple[str, ...],
     *,
@@ -381,7 +371,7 @@ def _present_flags(
             flags.add(argument.split("=", 1)[0])
         if argument.startswith("-") and not argument.startswith("--") and len(argument) > 2:
             for character in argument[1:]:
-                if not character.isalpha():
+                if not character.isalnum():
                     continue
                 short_flag = f"-{character}"
                 flags.add(short_flag)