Personal AI, On Personal Devices
Python
"""Adversarial security wiring tests for the programmatic app factory."""
from __future__ import annotations
from types import SimpleNamespace
from unittest.mock import MagicMock
import pytest
pytest.importorskip("fastapi")
from openjarvis.core.config import JarvisConfig
from openjarvis.core.events import EventBus, EventType
from openjarvis.security import SecurityContext
from openjarvis.security.capabilities import CapabilityPolicy
from openjarvis.server.app import create_app
def _config() -> JarvisConfig:
config = JarvisConfig()
config.analytics.enabled = False
config.traces.enabled = False
config.security.enabled = True
return config
def _runtime_config() -> JarvisConfig:
"""Factory config without external analytics or derived security."""
config = JarvisConfig()
config.analytics.enabled = False
config.traces.enabled = False
config.security.enabled = False
return config
def test_factory_derives_missing_security_and_secures_prebuilt_agent(
monkeypatch,
) -> None:
engine = MagicMock(name="raw-engine")
wrapped = MagicMock(name="wrapped-engine")
policy = object()
limiter = object()
audit = object()
setup = MagicMock(
return_value=SecurityContext(
engine=wrapped,
capability_policy=policy,
rate_limiter=limiter,
audit_logger=audit,
)
)
monkeypatch.setattr("openjarvis.security.setup_security", setup)
agent = SimpleNamespace(
agent_id="tool-agent",
_engine=engine,
_executor=SimpleNamespace(
_capability_policy=None,
_rate_limiter=None,
_agent_id="",
),
)
app = create_app(engine, "model", agent=agent, config=_config())
setup.assert_called_once()
assert app.state.engine is wrapped
assert app.state.bus is not None
assert app.state.capability_policy is policy
assert app.state.rate_limiter is limiter
assert app.state.audit_logger is audit
assert agent._engine is wrapped
assert agent._bus is app.state.bus
assert agent._executor._bus is app.state.bus
assert agent._executor._capability_policy is policy
assert agent._executor._rate_limiter is limiter
assert agent._executor._agent_id == "tool-agent"
def test_factory_preserves_explicit_security_primitives(monkeypatch) -> None:
derived_policy = object()
derived_limiter = object()
derived_audit = object()
explicit_policy = object()
explicit_limiter = object()
setup = MagicMock(
return_value=SecurityContext(
engine="wrapped",
capability_policy=derived_policy,
rate_limiter=derived_limiter,
audit_logger=derived_audit,
)
)
monkeypatch.setattr("openjarvis.security.setup_security", setup)
app = create_app(
"raw",
"model",
config=_config(),
capability_policy=explicit_policy,
rate_limiter=explicit_limiter,
)
assert app.state.engine == "wrapped"
assert app.state.capability_policy is explicit_policy
assert app.state.rate_limiter is explicit_limiter
assert app.state.audit_logger is derived_audit
def test_factory_propagates_strict_security_setup_failure(monkeypatch) -> None:
monkeypatch.setattr(
"openjarvis.security.setup_security",
MagicMock(side_effect=RuntimeError("policy failed")),
)
with pytest.raises(RuntimeError, match="policy failed"):
create_app("raw", "model", config=_config())
def test_factory_synchronizes_prebuilt_rlm_lazy_executor_runtime(monkeypatch) -> None:
from openjarvis.agents.rlm import RLMAgent
from openjarvis.agents.rlm_repl import RLMRepl
engine = MagicMock()
engine.generate.side_effect = [
{"content": "```python\nsentinel = 42\n```", "finish_reason": "stop"},
{"content": "finished", "finish_reason": "stop"},
]
bus = EventBus(record_history=True)
policy = CapabilityPolicy(default_deny=True)
# Permit the top-level agent gate, but not the lazily-created REPL tool.
policy.grant("server-rlm", "code:execute", "agent_run")
class _Limiter:
def __init__(self):
self.keys = []
def check(self, key):
self.keys.append(key)
return True, 0.0
limiter = _Limiter()
agent = RLMAgent(engine, "model")
repl_execute = MagicMock(return_value="should not execute")
monkeypatch.setattr(RLMRepl, "execute", repl_execute)
app = create_app(
engine,
"model",
agent=agent,
agent_name="server-rlm",
bus=bus,
capability_policy=policy,
rate_limiter=limiter,
config=_runtime_config(),
)
result = app.state.agent.run("execute generated code")
assert result.content == "finished"
repl_execute.assert_not_called()
assert agent._runtime_bus is bus
assert agent._runtime_capability_policy is policy
assert agent._runtime_rate_limiter is limiter
assert agent._runtime_agent_id == "server-rlm"
assert limiter.keys == [
"server-rlm:agent_run",
"server-rlm:rlm_repl",
]
assert any(
event.event_type == EventType.CAPABILITY_DENIED
and event.data
== {
"agent_id": "server-rlm",
"capability": "code:execute",
"tool": "rlm_repl",
}
for event in bus.history
)
def test_factory_preserves_prebuilt_rlm_policy_and_limiter_while_reidentifying() -> (
None
):
from openjarvis.agents.rlm import RLMAgent
engine = MagicMock()
agent_policy = CapabilityPolicy(default_deny=True)
server_policy = CapabilityPolicy(default_deny=True)
agent_limiter = object()
server_limiter = object()
agent = RLMAgent(
engine,
"model",
capability_policy=agent_policy,
rate_limiter=agent_limiter,
agent_id="prebuilt-id",
)
create_app(
engine,
"model",
agent=agent,
agent_name="server-id",
capability_policy=server_policy,
rate_limiter=server_limiter,
config=_runtime_config(),
)
assert agent._capability_policy is agent_policy
assert agent._runtime_capability_policy is agent_policy
assert agent._rate_limiter is agent_limiter
assert agent._runtime_rate_limiter is agent_limiter
assert agent._runtime_agent_id == "server-id"
def test_factory_overrides_prebuilt_executor_identity_at_server_boundary() -> None:
from openjarvis.agents.orchestrator import OrchestratorAgent
from openjarvis.core.types import ToolCall, ToolResult
from openjarvis.tools._stubs import BaseTool, ToolSpec
class _AdminTool(BaseTool):
@property
def spec(self) -> ToolSpec:
return ToolSpec(
name="tenant_admin_probe",
description="Identity regression probe.",
required_capabilities=["system:admin"],
)
def execute(self, **params) -> ToolResult:
return ToolResult(tool_name=self.spec.name, content="executed")
engine = MagicMock()
bus = EventBus(record_history=True)
policy = CapabilityPolicy(default_deny=True)
# This grant demonstrates the bypass: the prebuilt class-default identity
# is privileged, while the identity assigned by the server is not.
policy.grant("orchestrator", "system:admin", "tenant_admin_probe")
agent = OrchestratorAgent(engine, "model", tools=[_AdminTool()])
assert agent._executor._agent_id == "orchestrator"
create_app(
engine,
"model",
agent=agent,
agent_name="tenant-denied",
bus=bus,
capability_policy=policy,
config=_runtime_config(),
)
result = agent._executor.execute(
ToolCall(id="identity-probe", name="tenant_admin_probe", arguments="{}")
)
assert not result.success
assert "system:admin" in result.content
assert agent._runtime_agent_id == "tenant-denied"
assert agent._executor._agent_id == "tenant-denied"
assert any(
event.event_type == EventType.CAPABILITY_DENIED
and event.data
== {
"agent_id": "tenant-denied",
"capability": "system:admin",
"tool": "tenant_admin_probe",
}
for event in bus.history
)
@pytest.mark.parametrize("profile", ["", "personal", "shared", "server"])
def test_factory_rejects_invalid_enabled_policy_in_every_profile(tmp_path, profile):
config = _config()
config.security.profile = profile
config.security.capabilities.enabled = True
path = tmp_path / "invalid-policy.json"
path.write_text("{invalid}")
config.security.capabilities.policy_path = str(path)
with pytest.raises(RuntimeError, match="Capability policy initialization"):
create_app(MagicMock(), "model", config=config)