Skip to content

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.tsx
index 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.tsx
index 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.ts
index 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.py
index 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_turns
agent_kwargs["interactive"] = True
agent_kwargs["confirm_callback"] = lambda prompt: True
+ if capability_policy is not None:
+ agent_kwargs["capability_policy"] = capability_policy
agent = 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 = None
want_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.py
index 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 them
if getattr(agent_cls, "accepts_tools", False):
diff --git a/src/openjarvis/engine/multi.py b/src/openjarvis/engine/multi.py
index 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.py
index 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] = None
self._audit_logger: Any = None
+ self._capability_policy: Any = None
self.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)
-
@property
def 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 + energy
energy_monitor = None
@@ -498,6 +469,9 @@ class Jarvis:
agent_kwargs["tools"] = tool_objects
agent_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__.py
index 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 EventBus
from openjarvis.security._stubs import BaseScanner
from openjarvis.security.audit import AuditLogger
from 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.py
index 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.py
index 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.py
index 25ae8e77..2a19db10 100644
--- a/src/openjarvis/system.py
+++ b/src/openjarvis/system.py
@@ -42,6 +42,7 @@ class JarvisSystem:
workflow_engine: Optional[Any] = None # WorkflowEngine
session_store: Optional[Any] = None # SessionStore
capability_policy: Optional[Any] = None # CapabilityPolicy
+ audit_logger: Optional[Any] = None # AuditLogger
operator_manager: Optional[Any] = None # OperatorManager
agent_manager: Optional[Any] = None # AgentManager
agent_scheduler: Optional[Any] = None # AgentScheduler
@@ -148,6 +149,8 @@ class JarvisSystem:
agent_kwargs["max_turns"] = self.config.agent.max_turns
if system_prompt is not None:
agent_kwargs["system_prompt"] = system_prompt
+ if self.capability_policy is not None:
+ agent_kwargs["capability_policy"] = self.capability_policy
if operator_id is not None:
agent_kwargs["operator_id"] = operator_id
agent_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
-
@staticmethod
def _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.py
new file mode 100644
index 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 engine
diff --git a/tests/security/test_setup_security.py b/tests/security/test_setup_security.py
new file mode 100644
index 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