Personal AI, On Personal Devices
Python
feat(security): wire guardrails into all entry points (#60)
Jon Saad-Falcon4557fe29305d
diff --git a/frontend/src/components/Chat/SystemPanel.tsx b/frontend/src/components/Chat/SystemPanel.tsxindex bf1d20ba..6995b4e6 100644--- a/frontend/src/components/Chat/SystemPanel.tsx+++ b/frontend/src/components/Chat/SystemPanel.tsx@@ -110,7 +110,7 @@ export function SystemPanel() {</h4><div className="grid grid-cols-2 gap-2"><MiniStat icon={Hash} label="Requests" value={String(telemetry?.total_requests ?? savings?.total_calls ?? 0)} />- <MiniStat icon={Activity} label="Tokens" value={formatNumber(telemetry?.total_tokens ?? savings?.total_tokens ?? 0)} />+ <MiniStat icon={Hash} label="Tokens" value={formatNumber(telemetry?.total_tokens ?? savings?.total_tokens ?? 0)} /></div></section>diff --git a/frontend/src/components/Chat/XRayFooter.tsx b/frontend/src/components/Chat/XRayFooter.tsxindex 564369b9..af2d7c72 100644--- a/frontend/src/components/Chat/XRayFooter.tsx+++ b/frontend/src/components/Chat/XRayFooter.tsx@@ -18,10 +18,10 @@ export function XRayFooter({ usage, telemetry }: Props) {const parts: string[] = [];if (telemetry?.engine) parts.push(telemetry.engine);if (telemetry?.model_id) parts.push(telemetry.model_id);+ if (telemetry?.total_ms) parts.push(formatMs(telemetry.total_ms));if (usage && (usage.prompt_tokens || usage.completion_tokens)) {parts.push(`${usage.prompt_tokens} in \u00B7 ${usage.completion_tokens} out`);}- if (telemetry?.total_ms) parts.push(formatMs(telemetry.total_ms));if (parts.length === 0 && !usage?.total_tokens) return null;diff --git a/frontend/src/lib/api.ts b/frontend/src/lib/api.tsindex 80db43f0..d33b0ccd 100644--- a/frontend/src/lib/api.ts+++ b/frontend/src/lib/api.ts@@ -142,7 +142,13 @@ export async function deleteModel(modelName: string): Promise<void> {}}+const _CLOUD_PREFIXES = ['gpt-', 'o1-', 'o3-', 'o4-', 'claude-', 'gemini-', 'openrouter/'];+export async function preloadModel(modelName: string): Promise<void> {+ // Cloud models don't need Ollama preloading+ if (_CLOUD_PREFIXES.some(p => modelName.startsWith(p))) {+ return;+ }// Trigger Ollama to load the model into memory (empty prompt, no generation).const ollamaUrl = 'http://127.0.0.1:11434';try {diff --git a/src/openjarvis/cli/ask.py b/src/openjarvis/cli/ask.pyindex faed5a1d..85455506 100644--- a/src/openjarvis/cli/ask.py+++ b/src/openjarvis/cli/ask.py@@ -96,6 +96,7 @@ def _run_agent(bus: EventBus,temperature: float,max_tokens: int,+ capability_policy=None,):"""Instantiate and run an agent, returning the AgentResult."""# Import agents to trigger registration@@ -129,6 +130,8 @@ def _run_agent(agent_kwargs["max_turns"] = config.agent.max_turnsagent_kwargs["interactive"] = Trueagent_kwargs["confirm_callback"] = lambda prompt: True+ if capability_policy is not None:+ agent_kwargs["capability_policy"] = capability_policyagent = agent_cls(engine, model_name, **agent_kwargs)ctx = AgentContext()@@ -355,6 +358,11 @@ def ask(engine_name, engine = resolved+ # Apply security guardrails+ from openjarvis.security import setup_security+ sec = setup_security(config, engine, bus)+ engine = sec.engine+# Wrap engine with InstrumentedEngine for telemetry (energy + GPU metrics)energy_monitor = Nonewant_energy = config.telemetry.gpu_metrics or enable_profile@@ -400,6 +408,7 @@ def ask(result = _run_agent(agent_name, query_text, engine, model_name,parsed_tools, config, bus, temperature, max_tokens,+ capability_policy=sec.capability_policy,)except EngineConnectionError as exc:console.print(f"[red]Engine error:[/red] {exc}")diff --git a/src/openjarvis/cli/serve.py b/src/openjarvis/cli/serve.pyindex 007b1794..5092acae 100644--- a/src/openjarvis/cli/serve.py+++ b/src/openjarvis/cli/serve.py@@ -92,6 +92,11 @@ def serve(engine_name, engine = resolved+ # Apply security guardrails+ from openjarvis.security import setup_security+ sec = setup_security(config, engine, bus)+ engine = sec.engine+# If cloud API keys are set, wrap with MultiEngine so both local# and cloud models appear in the model list and can be used.import os@@ -164,6 +169,8 @@ def serve(if AgentRegistry.contains(agent_key):agent_cls = AgentRegistry.get(agent_key)agent_kwargs = {"bus": bus}+ if sec.capability_policy is not None:+ agent_kwargs["capability_policy"] = sec.capability_policy# Load tools for agents that support themif getattr(agent_cls, "accepts_tools", False):diff --git a/src/openjarvis/engine/multi.py b/src/openjarvis/engine/multi.pyindex 810a811b..f3b9a42a 100644--- a/src/openjarvis/engine/multi.py+++ b/src/openjarvis/engine/multi.py@@ -35,6 +35,8 @@ class MultiEngine(InferenceEngine):except Exception as exc:logger.debug("Failed to list models for %s: %s", _key, exc)+ _CLOUD_PREFIXES = ("gpt-", "o1-", "o3-", "o4-", "claude-", "gemini-", "openrouter/")+def _engine_for(self, model: str) -> InferenceEngine:"""Find the engine that owns a model, refreshing the map once if needed."""engine = self._model_map.get(model)@@ -45,7 +47,20 @@ class MultiEngine(InferenceEngine):engine = self._model_map.get(model)if engine is not None:return engine- # Fall back to the first engine (usually Ollama)+ # If model looks like a cloud model, route to the cloud engine+ # rather than falling back to the local engine (which would 404).+ if any(model.startswith(p) for p in self._CLOUD_PREFIXES):+ for key, eng in self._engines:+ if key == "cloud":+ logger.info("Routing cloud model %r to cloud engine", model)+ return eng+ logger.warning(+ "Model %r not found in any engine (known: %s)",+ model,+ ", ".join(sorted(self._model_map.keys())),+ )+ # Fall back to the first engine — caller will see the+ # downstream error if the model doesn't exist there.return self._engines[0][1]def generate(diff --git a/src/openjarvis/sdk.py b/src/openjarvis/sdk.pyindex 1691c4ff..1e56b796 100644--- a/src/openjarvis/sdk.py+++ b/src/openjarvis/sdk.py@@ -170,6 +170,7 @@ class Jarvis:self._bus = EventBus()self._telem_store: Optional[TelemetryStore] = Noneself._audit_logger: Any = None+ self._capability_policy: Any = Noneself.memory = MemoryHandle(self._config)# Set up telemetry@@ -180,18 +181,6 @@ class Jarvis:except Exception as exc:logger.warning("Failed to initialize telemetry store: %s", exc)- # Set up security audit logger- if self._config.security.enabled:- try:- from openjarvis.security.audit import AuditLogger-- self._audit_logger = AuditLogger(- db_path=self._config.security.audit_log_path,- bus=self._bus,- )- except Exception as exc:- logger.warning("Failed to initialize security audit logger: %s", exc)-@propertydef config(self) -> JarvisConfig:"""Return the active configuration."""@@ -223,30 +212,12 @@ class Jarvis:)self._resolved_engine_key, engine = resolved- # Wrap engine with security guardrails if configured- if self._config.security.enabled:- try:- from openjarvis.security.guardrails import GuardrailsEngine- from openjarvis.security.scanner import PIIScanner, SecretScanner- from openjarvis.security.types import RedactionMode-- scanners = []- if self._config.security.secret_scanner:- scanners.append(SecretScanner())- if self._config.security.pii_scanner:- scanners.append(PIIScanner())- if scanners:- mode = RedactionMode(self._config.security.mode)- engine = GuardrailsEngine(- engine,- scanners=scanners,- mode=mode,- scan_input=self._config.security.scan_input,- scan_output=self._config.security.scan_output,- bus=self._bus,- )- except Exception as exc:- logger.debug("Failed to set up security guardrails: %s", exc)+ # Apply security guardrails+ from openjarvis.security import setup_security+ sec = setup_security(self._config, engine, self._bus)+ engine = sec.engine+ self._audit_logger = sec.audit_logger+ self._capability_policy = sec.capability_policy# Wrap engine with InstrumentedEngine for telemetry + energyenergy_monitor = None@@ -498,6 +469,9 @@ class Jarvis:agent_kwargs["tools"] = tool_objectsagent_kwargs["max_turns"] = self._config.agent.max_turns+ if self._capability_policy is not None:+ agent_kwargs["capability_policy"] = self._capability_policy+agent_obj = agent_cls(self._engine, model_name, **agent_kwargs)ctx = AgentContext()diff --git a/src/openjarvis/security/__init__.py b/src/openjarvis/security/__init__.pyindex 206df4f7..b6d40da6 100644--- a/src/openjarvis/security/__init__.py+++ b/src/openjarvis/security/__init__.py@@ -1,5 +1,12 @@"""Security guardrails — scanners, engine wrapper, audit, SSRF."""+from __future__ import annotations++import logging+from dataclasses import dataclass+from typing import Any, Optional++from openjarvis.core.events import EventBusfrom openjarvis.security._stubs import BaseScannerfrom openjarvis.security.audit import AuditLoggerfrom openjarvis.security.file_policy import (@@ -19,6 +26,80 @@ from openjarvis.security.types import (ThreatLevel,)+logger = logging.getLogger(__name__)+++@dataclass+class SecurityContext:+ """Result of setup_security() — wrapped engine, policy, audit."""++ engine: Any+ capability_policy: Any = None+ audit_logger: Any = None+++def setup_security(+ config: Any,+ engine: Any,+ bus: Optional[EventBus] = None,+) -> SecurityContext:+ """Apply security guardrails to an engine based on config.++ Returns a SecurityContext. No-ops if config.security.enabled is False.+ """+ if not config.security.enabled:+ return SecurityContext(engine=engine)++ # Scanners + engine wrapping+ try:+ scanners: list[BaseScanner] = []+ if config.security.secret_scanner:+ scanners.append(SecretScanner())+ if config.security.pii_scanner:+ scanners.append(PIIScanner())++ if scanners:+ mode = RedactionMode(config.security.mode)+ engine = GuardrailsEngine(+ engine,+ scanners=scanners,+ mode=mode,+ scan_input=config.security.scan_input,+ scan_output=config.security.scan_output,+ bus=bus,+ )+ except Exception as exc:+ logger.debug("Failed to set up security scanners: %s", exc)++ # Capability policy+ cap_policy = None+ if config.security.capabilities.enabled:+ try:+ from openjarvis.security.capabilities import CapabilityPolicy++ cap_policy = CapabilityPolicy(+ policy_path=config.security.capabilities.policy_path or None,+ )+ except Exception as exc:+ logger.debug("Failed to set up capability policy: %s", exc)++ # Audit logger+ audit = None+ try:+ audit = AuditLogger(+ db_path=config.security.audit_log_path,+ bus=bus,+ )+ except Exception as exc:+ logger.debug("Failed to set up audit logger: %s", exc)++ return SecurityContext(+ engine=engine,+ capability_policy=cap_policy,+ audit_logger=audit,+ )++__all__ = ["AuditLogger","BaseScanner",@@ -30,6 +111,7 @@ __all__ = ["ScanResult","SecretScanner","SecurityBlockError",+ "SecurityContext","SecurityEvent","SecurityEventType","ThreatLevel",@@ -37,4 +119,5 @@ __all__ = ["filter_sensitive_paths","is_private_ip","is_sensitive_file",+ "setup_security",]diff --git a/src/openjarvis/server/app.py b/src/openjarvis/server/app.pyindex f4bca46e..d098a739 100644--- a/src/openjarvis/server/app.py+++ b/src/openjarvis/server/app.py@@ -75,38 +75,8 @@ def create_app(channel_bridge:Optional channel bridge for multi-platform messaging.config:- Optional JarvisConfig for security guardrails and other settings.+ Optional JarvisConfig for other settings."""- # Wrap engine with security guardrails if configured- security_enabled = (- config is not None- and getattr(config, "security", None)- and config.security.enabled- )- if security_enabled:- try:- from openjarvis.security.guardrails import GuardrailsEngine- from openjarvis.security.scanner import PIIScanner, SecretScanner- from openjarvis.security.types import RedactionMode-- scanners = []- if config.security.secret_scanner:- scanners.append(SecretScanner())- if config.security.pii_scanner:- scanners.append(PIIScanner())- if scanners:- mode = RedactionMode(config.security.mode)- engine = GuardrailsEngine(- engine,- scanners=scanners,- mode=mode,- scan_input=config.security.scan_input,- scan_output=config.security.scan_output,- bus=bus,- )- except Exception as exc:- logger.debug("Security guardrails init skipped: %s", exc)-app = FastAPI(title="OpenJarvis API",description="OpenAI-compatible API server for OpenJarvis",diff --git a/src/openjarvis/server/routes.py b/src/openjarvis/server/routes.pyindex 30dab503..7838daac 100644--- a/src/openjarvis/server/routes.py+++ b/src/openjarvis/server/routes.py@@ -359,10 +359,22 @@ async def savings(request: Request):agg = TelemetryAggregator(db_path)try:summary = agg.summary(since=session_start)+ # Exclude cloud model tokens from savings — only local+ # inference counts toward cost savings.+ _cloud_prefixes = (+ "gpt-", "o1-", "o3-", "o4-",+ "claude-", "gemini-", "openrouter/",+ )+ local_models = [+ m for m in summary.per_model+ if not any(m.model_id.startswith(p) for p in _cloud_prefixes)+ ]result = compute_savings(- prompt_tokens=sum(m.prompt_tokens for m in summary.per_model),- completion_tokens=sum(m.completion_tokens for m in summary.per_model),- total_calls=summary.total_calls,+ prompt_tokens=sum(m.prompt_tokens for m in local_models),+ completion_tokens=sum(+ m.completion_tokens for m in local_models+ ),+ total_calls=sum(m.call_count for m in local_models),session_start=session_start if session_start else 0.0,)return savings_to_dict(result)diff --git a/src/openjarvis/system.py b/src/openjarvis/system.pyindex 25ae8e77..2a19db10 100644--- a/src/openjarvis/system.py+++ b/src/openjarvis/system.py@@ -42,6 +42,7 @@ class JarvisSystem:workflow_engine: Optional[Any] = None # WorkflowEnginesession_store: Optional[Any] = None # SessionStorecapability_policy: Optional[Any] = None # CapabilityPolicy+ audit_logger: Optional[Any] = None # AuditLoggeroperator_manager: Optional[Any] = None # OperatorManageragent_manager: Optional[Any] = None # AgentManageragent_scheduler: Optional[Any] = None # AgentScheduler@@ -148,6 +149,8 @@ class JarvisSystem:agent_kwargs["max_turns"] = self.config.agent.max_turnsif system_prompt is not None:agent_kwargs["system_prompt"] = system_prompt+ if self.capability_policy is not None:+ agent_kwargs["capability_policy"] = self.capability_policyif operator_id is not None:agent_kwargs["operator_id"] = operator_idagent_kwargs["session_store"] = self.session_store@@ -420,7 +423,9 @@ class SystemBuilder:pass# Apply security guardrails FIRST (innermost wrapper)- engine = self._apply_security(config, engine, bus)+ from openjarvis.security import setup_security+ sec = setup_security(config, engine, bus)+ engine = sec.engine# Then wrap with InstrumentedEngine (outermost wrapper)if telemetry_enabled:@@ -469,7 +474,7 @@ class SystemBuilder:session_store = self._setup_sessions(config)# Set up capability policy- capability_policy = self._setup_capabilities(config)+ capability_policy = sec.capability_policy# Set up learning orchestrator (when training is enabled)learning_orchestrator = self._setup_learning_orchestrator(config)@@ -537,6 +542,7 @@ class SystemBuilder:workflow_engine=workflow_engine,session_store=session_store,capability_policy=capability_policy,+ audit_logger=sec.audit_logger,agent_manager=agent_manager,agent_scheduler=agent_scheduler,agent_executor=agent_executor,@@ -579,39 +585,6 @@ class SystemBuilder:return config.intelligence.fallback_model or ""- def _apply_security(self, config, engine, bus):- """Wrap engine with security guardrails if enabled."""- if config.security.enabled:- try:- from openjarvis.security.guardrails import GuardrailsEngine- from openjarvis.security.scanner import PIIScanner, SecretScanner- from openjarvis.security.types import RedactionMode-- scanners = []- if config.security.secret_scanner:- scanners.append(SecretScanner())- if config.security.pii_scanner:- scanners.append(PIIScanner())-- if scanners:- mode_map = {- "warn": RedactionMode.WARN,- "redact": RedactionMode.REDACT,- "block": RedactionMode.BLOCK,- }- mode = mode_map.get(config.security.mode, RedactionMode.WARN)- engine = GuardrailsEngine(- engine,- scanners=scanners,- mode=mode,- bus=bus,- scan_input=config.security.scan_input,- scan_output=config.security.scan_output,- )- except Exception as exc:- logger.warning("Failed to set up security guardrails: %s", exc)- return engine-def _setup_telemetry(self, config, bus):"""Set up telemetry store."""try:@@ -934,21 +907,6 @@ class SystemBuilder:logger.warning("Failed to set up session store: %s", exc)return None- @staticmethod- def _setup_capabilities(config):- """Set up capability policy if enabled."""- if not config.security.capabilities.enabled:- return None- try:- from openjarvis.security.capabilities import CapabilityPolicy-- return CapabilityPolicy(- policy_path=config.security.capabilities.policy_path or None,- )- except Exception as exc:- logger.warning("Failed to set up capability policy: %s", exc)- return None-@staticmethoddef _setup_learning_orchestrator(config: JarvisConfig):"""Set up LearningOrchestrator when training is enabled."""diff --git a/tests/security/test_security_wiring.py b/tests/security/test_security_wiring.pynew file mode 100644index 00000000..9651bd4f--- /dev/null+++ b/tests/security/test_security_wiring.py@@ -0,0 +1,81 @@+"""Verify security wiring reaches agents and ToolExecutor."""+from __future__ import annotations++from unittest.mock import MagicMock++from openjarvis.agents._stubs import AgentResult, ToolUsingAgent+from openjarvis.core.config import (+ CapabilitiesConfig,+ JarvisConfig,+ SecurityConfig,+)+from openjarvis.core.events import EventBus+from openjarvis.security import setup_security+++class _ConcreteAgent(ToolUsingAgent):+ """Minimal concrete subclass — ToolUsingAgent is abstract."""++ agent_id = "test"++ def run(self, input, context=None, **kwargs):+ return AgentResult(content="ok")+++def _make_mock_engine() -> MagicMock:+ engine = MagicMock()+ engine.engine_id = "mock"+ engine.generate.return_value = {+ "content": "ok",+ "usage": {"prompt_tokens": 1, "completion_tokens": 1, "total_tokens": 2},+ "model": "m",+ "finish_reason": "stop",+ }+ engine.list_models.return_value = ["m"]+ engine.health.return_value = True+ return engine+++def _has_rust() -> bool:+ try:+ import openjarvis_rust # noqa: F401++ return True+ except ImportError:+ return False+++class TestCapabilityPolicyReachesExecutor:+ def test_no_policy_when_caps_disabled(self) -> None:+ cfg = JarvisConfig()+ cfg.security = SecurityConfig(+ enabled=True,+ capabilities=CapabilitiesConfig(enabled=False),+ )+ bus = EventBus()+ engine = _make_mock_engine()+ sec = setup_security(cfg, engine, bus)++ agent = _ConcreteAgent(+ sec.engine,+ "m",+ tools=[],+ capability_policy=sec.capability_policy,+ )+ assert agent._executor._capability_policy is None++ def test_no_policy_when_security_disabled(self) -> None:+ cfg = JarvisConfig()+ cfg.security = SecurityConfig(enabled=False)+ engine = _make_mock_engine()+ sec = setup_security(cfg, engine)++ agent = _ConcreteAgent(+ sec.engine,+ "m",+ tools=[],+ capability_policy=sec.capability_policy,+ )+ assert agent._executor._capability_policy is None+ # Engine should be the original, unwrapped+ assert sec.engine is enginediff --git a/tests/security/test_setup_security.py b/tests/security/test_setup_security.pynew file mode 100644index 00000000..754dc73f--- /dev/null+++ b/tests/security/test_setup_security.py@@ -0,0 +1,80 @@+"""Tests for setup_security() helper."""+from __future__ import annotations++from unittest.mock import MagicMock++import pytest++from openjarvis.core.config import CapabilitiesConfig, JarvisConfig, SecurityConfig+from openjarvis.core.events import EventBus+from openjarvis.security import SecurityContext, setup_security+++def _make_mock_engine() -> MagicMock:+ engine = MagicMock()+ engine.engine_id = "mock"+ engine.generate.return_value = {"content": "ok"}+ engine.list_models.return_value = ["m"]+ engine.health.return_value = True+ return engine+++def _make_config(*, enabled: bool = True, caps_enabled: bool = False) -> JarvisConfig:+ cfg = JarvisConfig()+ cfg.security = SecurityConfig(+ enabled=enabled,+ secret_scanner=True,+ pii_scanner=True,+ mode="warn",+ capabilities=CapabilitiesConfig(enabled=caps_enabled),+ )+ return cfg+++def _has_rust() -> bool:+ try:+ import openjarvis_rust # noqa: F401+ return True+ except ImportError:+ return False+++class TestSetupSecurityEnabled:+ @pytest.mark.skipif(not _has_rust(), reason="Rust extension not compiled")+ def test_returns_wrapped_engine(self) -> None:+ from openjarvis.security.guardrails import GuardrailsEngine++ engine = _make_mock_engine()+ bus = EventBus()+ sec = setup_security(_make_config(), engine, bus)++ assert isinstance(sec.engine, GuardrailsEngine)+ assert sec.audit_logger is not None++ def test_returns_security_context(self) -> None:+ engine = _make_mock_engine()+ bus = EventBus()+ sec = setup_security(_make_config(), engine, bus)++ assert isinstance(sec, SecurityContext)+ # Audit logger should always work (no Rust dependency)+ assert sec.audit_logger is not None++ def test_graceful_without_rust(self) -> None:+ """Scanners fail gracefully when Rust is unavailable."""+ engine = _make_mock_engine()+ bus = EventBus()+ sec = setup_security(_make_config(), engine, bus)++ # Should not raise — scanner failure is caught+ assert isinstance(sec, SecurityContext)+++class TestSetupSecurityDisabled:+ def test_returns_original_engine(self) -> None:+ engine = _make_mock_engine()+ sec = setup_security(_make_config(enabled=False), engine)++ assert sec.engine is engine+ assert sec.capability_policy is None+ assert sec.audit_logger is None