omnimancer-cli 0.2.13__tar.gz → 0.2.15__tar.gz

{omnimancer_cli-0.2.13/omnimancer_cli.egg-info → omnimancer_cli-0.2.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omnimancer-cli
-Version: 0.2.13
+Version: 0.2.15
 Summary: A unified command-line interface for multiple AI language models
 Author-email: Kellan Strong <kellan@jite.ai>
 License: MIT

{omnimancer_cli-0.2.13 → omnimancer_cli-0.2.15}/omnimancer/cli/headless.py

@@ -255,6 +255,26 @@ class HeadlessRunner:
         if enhanced is not None:
             enhanced.set_approval_callback(_approve)
 
+    @staticmethod
+    def _enable_full_trust(agent_engine: Any) -> None:
+        """Relax the hard security layers for unattended full-trust runs.
+
+        Auto-approval alone is not enough: the command argument sanitizer
+        (pipes, &&, redirects), the forbidden-command list, the sensitive
+        filename patterns (*key*, *token*, .env, ...), and the 30s default
+        command timeout all block operations before/outside the approval
+        step, so a --dangerously-skip-permissions run still could not do real
+        work. The caller (e.g. a CI or agent container) is the security
+        boundary; hard-restricted system paths (~/.ssh, /etc, ...) stay
+        blocked.
+        """
+        executor = getattr(agent_engine, "executor", None)
+        if executor is not None and hasattr(executor, "set_full_trust"):
+            executor.set_full_trust(True)
+        file_system = getattr(agent_engine, "file_system", None)
+        if file_system is not None and hasattr(file_system, "set_full_trust"):
+            file_system.set_full_trust(True)
+
     async def run(self, prompt: str) -> int:
         agent_engine = getattr(self._engine, "agent_engine", None)
         if not agent_engine:
@@ -263,6 +283,7 @@ class HeadlessRunner:
 
         if self._no_approval:
             self._enable_auto_approval(agent_engine)
+            self._enable_full_trust(agent_engine)
 
         model = self._engine.config_manager.get_config().default_provider or "unknown"
         self._emitter.emit_init(model)

{omnimancer_cli-0.2.13 → omnimancer_cli-0.2.15}/omnimancer/core/agent/file_system_manager.py

@@ -79,6 +79,14 @@ class FileSystemManager:
         # Operation tracking
         self.active_operations: Dict[str, Dict[str, Any]] = {}
 
+    def set_full_trust(self, enabled: bool) -> None:
+        """Enable/disable full-trust mode on the underlying security manager.
+
+        In full trust, sensitive name patterns (.env, *key*, *token*, ...)
+        stop blocking reads/writes; hard-restricted system paths still deny.
+        """
+        self.security.set_full_trust(enabled)
+
     async def _request_approval_if_needed(self, operation: Operation) -> bool:
         """Request approval for operation if approval manager is configured."""
         if not self.require_approval or not self.approval_manager:

{omnimancer_cli-0.2.13 → omnimancer_cli-0.2.15}/omnimancer/core/agent/program_executor.py

@@ -86,6 +86,10 @@ class CommandValidator:
     """Validates commands against security policies."""
 
     def __init__(self) -> None:
+        # Full-trust mode (unattended headless runs where an outer sandbox is
+        # the security boundary): argument sanitization is skipped so shell
+        # constructs (pipes, &&, redirects) reach the shell executor intact.
+        self.full_trust = False
         self.command_categories = {
             CommandCategory.SAFE_READ: {
                 "ls",
@@ -295,6 +299,11 @@ class CommandValidator:
 
     def validate_command_args(self, command: str, args: List[str]) -> List[str]:
         """Validate and sanitize command arguments."""
+        # Full trust: commands run via the shell on purpose — pipes, &&, and
+        # redirects are legitimate agent usage there.
+        if self.full_trust:
+            return list(args)
+
         import re
 
         # Define dangerous shell metacharacters and patterns

{omnimancer_cli-0.2.13 → omnimancer_cli-0.2.15}/omnimancer/core/agent_managers.py

@@ -159,6 +159,10 @@ class ProgramExecutor(BaseManager):
         }
         self.timeout_seconds = self.default_config.timeout_seconds
 
+        # Full-trust mode (unattended headless runs where an outer sandbox is
+        # the security boundary) — see set_full_trust().
+        self.full_trust = False
+
     async def execute_operation(self, operation: Operation) -> OperationResult:
         """Execute command operation using enhanced executor.
 
@@ -261,6 +265,22 @@ class ProgramExecutor(BaseManager):
         """Terminate a running command."""
         return await self.enhanced_executor.terminate_command(execution_id)
 
+    def set_full_trust(self, enabled: bool) -> None:
+        """Enable full-trust mode for unattended runs.
+
+        The caller (e.g. a headless agent inside a container) is the security
+        boundary: the forbidden-command list and argument sanitization stop
+        blocking, and the default per-command timeout is raised so real build/
+        test runs can finish. Explicit per-operation timeouts are still honored.
+        """
+        self.full_trust = enabled
+        if enabled:
+            self.timeout_seconds = 600
+            self.default_config.timeout_seconds = 600
+        validator = getattr(self.enhanced_executor, "validator", None)
+        if validator is not None:
+            validator.full_trust = enabled
+
     def _validate_command(self, command: str) -> bool:
         """
         Validate command for backward compatibility with tests.
@@ -278,6 +298,10 @@ class ProgramExecutor(BaseManager):
             Security is provided through the approval system's risk assessment
             and user confirmation. Only explicitly dangerous commands are blocked.
         """
+        # Full trust: forbidden-command blocking is disabled.
+        if self.full_trust:
+            return True
+
         # Extract the base command (first word)
         base_command = command.strip().split()[0] if command.strip() else ""
 

{omnimancer_cli-0.2.13 → omnimancer_cli-0.2.15}/omnimancer/core/security/permission_controller.py

@@ -46,6 +46,11 @@ class PermissionController:
         self.allowed_commands = self._get_default_allowed_commands()
         self.permission_rules = self._get_default_permission_rules()
 
+        # Full-trust mode (unattended headless runs where an outer sandbox is
+        # the security boundary): sensitive name patterns and the command
+        # allowlist stop blocking. Hard-restricted paths still deny.
+        self.full_trust = False
+
         # Initialize approval memory storage
         self._approval_memory: Dict[str, Dict[str, Any]] = {}
 
@@ -193,11 +198,16 @@ class PermissionController:
             # Normalize path
             normalized_path = str(Path(path).resolve())
 
-            # Hard-restricted paths are denied regardless of approval.
+            # Hard-restricted paths are denied regardless of approval —
+            # including full-trust mode.
             for restricted in self.restricted_paths:
                 if self._path_matches_pattern(normalized_path, restricted):
                     return False
 
+            # Full trust treats every operation as explicitly allowed.
+            if self.full_trust:
+                allow_sensitive = True
+
             # Sensitive name patterns are denied unless explicitly allowed.
             if not allow_sensitive:
                 for pattern in self.sensitive_patterns:
@@ -238,6 +248,11 @@ class PermissionController:
 
     def validate_command(self, command: str) -> bool:
         """Validate if command execution is allowed."""
+        # Full trust: the allowlist and pattern checks stop blocking — the
+        # outer sandbox is the security boundary.
+        if self.full_trust:
+            return True
+
         # Extract base command (first word)
         base_command = command.strip().split()[0]
 

{omnimancer_cli-0.2.13 → omnimancer_cli-0.2.15}/omnimancer/core/security/security_manager.py

@@ -327,6 +327,17 @@ class SecurityManager:
             result["stderr"] = f"Security manager error: {str(e)}"
             return result
 
+    def set_full_trust(self, enabled: bool) -> None:
+        """Enable/disable full-trust mode on the permission controller.
+
+        Full trust is for unattended runs (e.g. headless agents inside a
+        container) where the caller is the security boundary: sensitive name
+        patterns and the command allowlist stop blocking operations. The
+        hard-restricted system paths in PermissionController.restricted_paths
+        still deny.
+        """
+        self.permissions.full_trust = enabled
+
     async def secure_file_access(
         self,
         file_path: str,

{omnimancer_cli-0.2.13 → omnimancer_cli-0.2.15/omnimancer_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omnimancer-cli
-Version: 0.2.13
+Version: 0.2.15
 Summary: A unified command-line interface for multiple AI language models
 Author-email: Kellan Strong <kellan@jite.ai>
 License: MIT

{omnimancer_cli-0.2.13 → omnimancer_cli-0.2.15}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "omnimancer-cli"
-version = "0.2.13"
+version = "0.2.15"
 description = "A unified command-line interface for multiple AI language models"
 readme = "README.md"
 requires-python = ">=3.10"