Personal AI, On Personal Devices
Python
chore: remove spec and plan docs from PR
Jon Saad-Falcon096b718417ba
diff --git a/docs/superpowers/plans/2026-03-28-security-hardening.md b/docs/superpowers/plans/2026-03-28-security-hardening.mddeleted file mode 100644index 30c039e2..00000000--- a/docs/superpowers/plans/2026-03-28-security-hardening.md+++ /dev/null@@ -1,2027 +0,0 @@-# Security Hardening Implementation Plan--> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.--**Goal:** Harden OpenJarvis against network exposure, data leakage to cloud providers, local data exposure, and webhook spoofing — using layered boundary enforcement at device exit points.--**Architecture:** A `BoundaryGuard` wraps all exit points (cloud engines, external tools, webhooks). Config defaults change to secure values (`127.0.0.1` binding, `redact` mode, rate limiting on). File permissions enforced via shared helpers. Security profiles provide convenience shorthand. Each section is implemented and tested independently in severity order.--**Tech Stack:** Python 3.10+, FastAPI/Starlette, SQLite, pytest, existing Rust-backed SecretScanner/PIIScanner.--**Spec:** `docs/superpowers/specs/2026-03-28-security-hardening-design.md`-------## File Structure--### New Files-| File | Responsibility |-|------|---------------|-| `src/openjarvis/security/boundary.py` | BoundaryGuard — scans content at device exit points |-| `src/openjarvis/security/file_utils.py` | `secure_mkdir()` and `secure_create()` helpers |-| `tests/security/test_network_defaults.py` | Tests for Section 1 (binding, CORS, auth enforcement) |-| `tests/security/test_boundary_guard.py` | Tests for Section 2 (scan/redact, engine/tool tagging) |-| `tests/security/test_webhook_validation.py` | Tests for Section 3 (fail-closed, secret enforcement) |-| `tests/security/test_file_permissions.py` | Tests for Section 4 (secure_mkdir, secure_create, DB paths) |-| `tests/security/test_log_sanitization.py` | Tests for Section 5 (SanitizingFormatter, scoped credentials) |-| `tests/security/test_security_profiles.py` | Tests for Section 7 (profile field expansion, overrides) |--### Modified Files-| File | Change |-|------|--------|-| `src/openjarvis/core/config.py` | ServerConfig defaults, SecurityConfig defaults, new fields, profile expansion |-| `src/openjarvis/server/app.py` | CORS from config, startup guards |-| `src/openjarvis/server/auth_middleware.py` | Non-loopback auth enforcement |-| `src/openjarvis/server/webhook_routes.py` | Fail-closed validation |-| `src/openjarvis/server/middleware.py` | CSP header |-| `src/openjarvis/engine/_stubs.py` | `is_cloud` attribute on InferenceEngine |-| `src/openjarvis/engine/cloud.py` | `is_cloud = True` |-| `src/openjarvis/engine/litellm.py` | `is_cloud = True` |-| `src/openjarvis/tools/_stubs.py` | `is_local` attribute on BaseTool, BoundaryGuard in ToolExecutor |-| `src/openjarvis/tools/web_search.py` | `is_local = False` |-| `src/openjarvis/tools/http_request.py` | `is_local = False` |-| `src/openjarvis/tools/browser.py` | `is_local = False` on all browser tools |-| `src/openjarvis/tools/browser_axtree.py` | `is_local = False` |-| `src/openjarvis/tools/channel_tools.py` | `is_local = False` on ChannelSendTool |-| `src/openjarvis/tools/image_tool.py` | `is_local = False` |-| `src/openjarvis/tools/audio_tool.py` | `is_local = False` |-| `src/openjarvis/security/guardrails.py` | Delegate to BoundaryGuard |-| `src/openjarvis/tools/storage/sqlite.py` | secure_create for memory.db |-| `src/openjarvis/server/session_store.py` | secure_create for sessions.db |-| `src/openjarvis/traces/store.py` | secure_create for traces.db |-| `src/openjarvis/security/audit.py` | secure_create for audit.db |-| `src/openjarvis/connectors/store.py` | secure_create for knowledge.db |-| `src/openjarvis/connectors/attachment_store.py` | secure_mkdir/secure_create for blobs |-| `src/openjarvis/core/credentials.py` | `get_tool_credential()`, deprecate `inject_credentials()` |-| `src/openjarvis/cli/log_config.py` | SanitizingFormatter |-| `src/openjarvis/cli/serve.py` | Startup guards, credential audit log |-| `src/openjarvis/cli/doctor_cmd.py` | Security profile check |-| `src/openjarvis/system.py` | BoundaryGuard wiring |-------## Task 1: Network Exposure — Secure Server Defaults--**Files:**-- Modify: `src/openjarvis/core/config.py:759-767` (ServerConfig)-- Modify: `src/openjarvis/core/config.py:968-986` (SecurityConfig)-- Test: `tests/security/test_network_defaults.py`--- [ ] **Step 1: Write failing tests for secure defaults**--```python-# tests/security/test_network_defaults.py-"""Tests for secure network defaults (Section 1 of security hardening)."""--from __future__ import annotations---class TestServerConfigDefaults:- """ServerConfig should bind to loopback by default."""-- def test_default_host_is_loopback(self) -> None:- from openjarvis.core.config import ServerConfig-- cfg = ServerConfig()- assert cfg.host == "127.0.0.1"-- def test_default_port_unchanged(self) -> None:- from openjarvis.core.config import ServerConfig-- cfg = ServerConfig()- assert cfg.port == 8000-- def test_cors_origins_default(self) -> None:- from openjarvis.core.config import ServerConfig-- cfg = ServerConfig()- assert isinstance(cfg.cors_origins, list)- assert "http://localhost:3000" in cfg.cors_origins- assert "http://localhost:5173" in cfg.cors_origins- assert "tauri://localhost" in cfg.cors_origins- assert "*" not in cfg.cors_origins---class TestSecurityConfigDefaults:- """SecurityConfig should default to redact mode with rate limiting."""-- def test_default_mode_is_redact(self) -> None:- from openjarvis.core.config import SecurityConfig-- cfg = SecurityConfig()- assert cfg.mode == "redact"-- def test_rate_limiting_enabled_by_default(self) -> None:- from openjarvis.core.config import SecurityConfig-- cfg = SecurityConfig()- assert cfg.rate_limit_enabled is True-- def test_bypass_defaults_conservative(self) -> None:- from openjarvis.core.config import SecurityConfig-- cfg = SecurityConfig()- assert cfg.local_engine_bypass is False- assert cfg.local_tool_bypass is False-- def test_profile_default_empty(self) -> None:- from openjarvis.core.config import SecurityConfig-- cfg = SecurityConfig()- assert cfg.profile == ""-```--- [ ] **Step 2: Run tests to verify they fail**--Run: `uv run pytest tests/security/test_network_defaults.py -v`-Expected: FAIL — `ServerConfig` has `host="0.0.0.0"`, no `cors_origins` field, `SecurityConfig` has `mode="warn"`, `rate_limit_enabled=False`, no `local_engine_bypass`/`local_tool_bypass`/`profile` fields.--- [ ] **Step 3: Update ServerConfig defaults**--In `src/openjarvis/core/config.py`, replace the `ServerConfig` dataclass (lines 759-767):--```python-@dataclass(slots=True)-class ServerConfig:- """API server settings."""-- host: str = "127.0.0.1"- port: int = 8000- agent: str = "orchestrator"- model: str = ""- workers: int = 1- cors_origins: list = field(- default_factory=lambda: [- "http://localhost:3000",- "http://localhost:5173",- "http://127.0.0.1:3000",- "http://127.0.0.1:5173",- "tauri://localhost",- ]- )-```--- [ ] **Step 4: Update SecurityConfig defaults**--In `src/openjarvis/core/config.py`, replace the `SecurityConfig` dataclass (lines 968-986):--```python-@dataclass(slots=True)-class SecurityConfig:- """Security guardrails settings."""-- enabled: bool = True- scan_input: bool = True- scan_output: bool = True- mode: str = "redact" # "redact" | "warn" | "block"- secret_scanner: bool = True- pii_scanner: bool = True- audit_log_path: str = str(DEFAULT_CONFIG_DIR / "audit.db")- enforce_tool_confirmation: bool = True- merkle_audit: bool = True- signing_key_path: str = ""- ssrf_protection: bool = True- rate_limit_enabled: bool = True- rate_limit_rpm: int = 60- rate_limit_burst: int = 10- local_engine_bypass: bool = False- local_tool_bypass: bool = False- profile: str = ""- vault_key_path: str = str(DEFAULT_CONFIG_DIR / ".vault_key")- capabilities: CapabilitiesConfig = field(default_factory=CapabilitiesConfig)-```--- [ ] **Step 5: Run tests to verify they pass**--Run: `uv run pytest tests/security/test_network_defaults.py -v`-Expected: All 7 tests PASS.--- [ ] **Step 6: Commit**--```bash-git add tests/security/test_network_defaults.py src/openjarvis/core/config.py-git commit -m "feat: secure server defaults — loopback binding, redact mode, rate limiting"-```-------## Task 2: Network Exposure — Non-Loopback Auth Enforcement & CORS--**Files:**-- Modify: `src/openjarvis/cli/serve.py:68-69` (bind resolution) and `337-352` (API key loading)-- Modify: `src/openjarvis/server/app.py:182-188` (CORS)-- Test: `tests/security/test_network_defaults.py` (add more tests)--- [ ] **Step 1: Write failing tests for non-loopback auth and CORS**--Append to `tests/security/test_network_defaults.py`:--```python-import ipaddress---def _is_loopback(host: str) -> bool:- """Check if a host string is a loopback address."""- try:- return ipaddress.ip_address(host).is_loopback- except ValueError:- return host in ("localhost", "")---class TestNonLoopbackAuthEnforcement:- """Server must require API key when binding non-loopback."""-- def test_loopback_allows_no_key(self) -> None:- """127.0.0.1 should not require an API key."""- assert _is_loopback("127.0.0.1")-- def test_wildcard_is_not_loopback(self) -> None:- """0.0.0.0 should be treated as non-loopback."""- assert not _is_loopback("0.0.0.0")-- def test_non_loopback_requires_key(self) -> None:- """Binding to 0.0.0.0 without API key should raise."""- from openjarvis.server.auth_middleware import check_bind_safety-- try:- check_bind_safety("0.0.0.0", api_key="")- assert False, "Should have raised"- except SystemExit:- pass-- def test_non_loopback_with_key_ok(self) -> None:- """Binding to 0.0.0.0 with API key should succeed."""- from openjarvis.server.auth_middleware import check_bind_safety-- # Should not raise- check_bind_safety("0.0.0.0", api_key="oj_sk_test123")---class TestCORSConfiguration:- """CORS should use configured origins, not wildcard."""-- def test_create_app_uses_configured_origins(self) -> None:- """create_app should pass cors_origins from config, not '*'."""- # This test verifies the integration — we check that the app- # responds with the correct Access-Control-Allow-Origin.- from unittest.mock import MagicMock-- from fastapi.testclient import TestClient-- from openjarvis.server.app import create_app-- mock_engine = MagicMock()- mock_engine.health.return_value = True- mock_engine.list_models.return_value = ["test-model"]-- app = create_app(- mock_engine,- "test-model",- cors_origins=["http://localhost:3000"],- )- client = TestClient(app)-- # Request from allowed origin- resp = client.options(- "/health",- headers={- "Origin": "http://localhost:3000",- "Access-Control-Request-Method": "GET",- },- )- assert resp.headers.get("access-control-allow-origin") == "http://localhost:3000"-- # Request from disallowed origin should not get CORS header- resp2 = client.options(- "/health",- headers={- "Origin": "http://evil.com",- "Access-Control-Request-Method": "GET",- },- )- assert resp2.headers.get("access-control-allow-origin") != "http://evil.com"-```--- [ ] **Step 2: Run tests to verify they fail**--Run: `uv run pytest tests/security/test_network_defaults.py::TestNonLoopbackAuthEnforcement -v`-Expected: FAIL — `check_bind_safety` does not exist yet.--Run: `uv run pytest tests/security/test_network_defaults.py::TestCORSConfiguration -v`-Expected: FAIL — `create_app` does not accept `cors_origins` parameter.--- [ ] **Step 3: Add `check_bind_safety` to auth_middleware.py**--In `src/openjarvis/server/auth_middleware.py`, add after the `generate_api_key()` function (after line 58):--```python-def check_bind_safety(host: str, *, api_key: str) -> None:- """Refuse to bind non-loopback without an API key.-- Raises ``SystemExit`` if *host* is not a loopback address and- *api_key* is empty.- """- import ipaddress- import sys-- try:- is_loop = ipaddress.ip_address(host).is_loopback- except ValueError:- is_loop = host in ("localhost", "")-- if not is_loop and not api_key:- logger.error(- "Binding to %s requires OPENJARVIS_API_KEY to be set. "- "Run: jarvis auth generate-key",- host,- )- sys.exit(1)-```--- [ ] **Step 4: Update `create_app` to accept and use `cors_origins`**--In `src/openjarvis/server/app.py`, add `cors_origins: list[str] | None = None` to the `create_app()` signature (line 140).--Replace the CORS middleware block (lines 182-188):--```python- from fastapi.middleware.cors import CORSMiddleware-- _origins = cors_origins if cors_origins is not None else ["*"]- app.add_middleware(- CORSMiddleware,- allow_origins=_origins,- allow_credentials=True,- allow_methods=["*"],- allow_headers=["*"],- )-```--- [ ] **Step 5: Wire `check_bind_safety` and `cors_origins` in `serve.py`**--In `src/openjarvis/cli/serve.py`, after API key resolution (around line 352), add:--```python- from openjarvis.server.auth_middleware import check_bind_safety-- check_bind_safety(bind_host, api_key=api_key)-```--In the `create_app()` call (around line 383), add the `cors_origins` kwarg:--```python- app = create_app(- engine,- model_name,- # ... existing kwargs ...- cors_origins=config.server.cors_origins,- )-```--- [ ] **Step 6: Run tests to verify they pass**--Run: `uv run pytest tests/security/test_network_defaults.py -v`-Expected: All tests PASS.--- [ ] **Step 7: Commit**--```bash-git add src/openjarvis/server/auth_middleware.py src/openjarvis/server/app.py src/openjarvis/cli/serve.py tests/security/test_network_defaults.py-git commit -m "feat: enforce API key for non-loopback binding, restrict CORS origins"-```-------## Task 3: Boundary Guard — Core Module--**Files:**-- Create: `src/openjarvis/security/boundary.py`-- Test: `tests/security/test_boundary_guard.py`--- [ ] **Step 1: Write failing tests for BoundaryGuard**--```python-# tests/security/test_boundary_guard.py-"""Tests for BoundaryGuard — scanning at device exit points."""--from __future__ import annotations--import pytest--from openjarvis.core.types import ToolCall---class TestBoundaryGuardScanOutbound:- """scan_outbound should detect and redact secrets/PII."""-- def test_redacts_openai_key(self) -> None:- from openjarvis.security.boundary import BoundaryGuard-- guard = BoundaryGuard(mode="redact")- text = "Use this key: sk-proj-abc123def456ghi789jkl012mno345pqr678stu"- result = guard.scan_outbound(text, destination="openai")- assert "sk-proj-" not in result- assert "[REDACTED" in result-- def test_redacts_aws_key(self) -> None:- from openjarvis.security.boundary import BoundaryGuard-- guard = BoundaryGuard(mode="redact")- text = "AWS key: AKIAIOSFODNN7EXAMPLE"- result = guard.scan_outbound(text, destination="openai")- assert "AKIAIOSFODNN7EXAMPLE" not in result-- def test_warn_mode_does_not_alter_text(self) -> None:- from openjarvis.security.boundary import BoundaryGuard-- guard = BoundaryGuard(mode="warn")- text = "Use this key: sk-proj-abc123def456ghi789jkl012mno345pqr678stu"- result = guard.scan_outbound(text, destination="openai")- assert result == text-- def test_block_mode_raises(self) -> None:- from openjarvis.security.boundary import BoundaryGuard, SecurityBlockError-- guard = BoundaryGuard(mode="block")- text = "Use this key: sk-proj-abc123def456ghi789jkl012mno345pqr678stu"- with pytest.raises(SecurityBlockError):- guard.scan_outbound(text, destination="openai")-- def test_clean_text_passes_through(self) -> None:- from openjarvis.security.boundary import BoundaryGuard-- guard = BoundaryGuard(mode="redact")- text = "Hello, how are you?"- result = guard.scan_outbound(text, destination="openai")- assert result == text---class TestBoundaryGuardCheckOutbound:- """check_outbound should redact secrets in tool call arguments."""-- def test_redacts_tool_call_arguments(self) -> None:- from openjarvis.security.boundary import BoundaryGuard-- guard = BoundaryGuard(mode="redact")- tc = ToolCall(- id="test_1",- name="web_search",- arguments='{"query": "my key is sk-proj-abc123def456ghi789jkl012mno345pqr678stu"}',- )- result = guard.check_outbound(tc)- assert "sk-proj-" not in result.arguments- assert result.id == "test_1"- assert result.name == "web_search"-- def test_clean_args_pass_through(self) -> None:- from openjarvis.security.boundary import BoundaryGuard-- guard = BoundaryGuard(mode="redact")- tc = ToolCall(id="test_2", name="web_search", arguments='{"query": "weather"}')- result = guard.check_outbound(tc)- assert result.arguments == tc.arguments-- def test_block_mode_raises_on_tool_call(self) -> None:- from openjarvis.security.boundary import BoundaryGuard, SecurityBlockError-- guard = BoundaryGuard(mode="block")- tc = ToolCall(- id="test_3",- name="web_search",- arguments='{"query": "AKIAIOSFODNN7EXAMPLE"}',- )- with pytest.raises(SecurityBlockError):- guard.check_outbound(tc)---class TestBoundaryGuardDisabled:- """When disabled, BoundaryGuard should pass everything through."""-- def test_disabled_passes_secrets_through(self) -> None:- from openjarvis.security.boundary import BoundaryGuard-- guard = BoundaryGuard(mode="redact", enabled=False)- text = "sk-proj-abc123def456ghi789jkl012mno345pqr678stu"- result = guard.scan_outbound(text, destination="openai")- assert result == text-```--- [ ] **Step 2: Run tests to verify they fail**--Run: `uv run pytest tests/security/test_boundary_guard.py -v`-Expected: FAIL — `openjarvis.security.boundary` does not exist.--- [ ] **Step 3: Implement BoundaryGuard**--```python-# src/openjarvis/security/boundary.py-"""BoundaryGuard — scans content at device exit points.--Wraps SecretScanner and PIIScanner to redact, warn, or block-secrets and PII before data leaves the device via cloud engines-or external tool calls.-"""--from __future__ import annotations--import logging-from dataclasses import dataclass, replace-from typing import TYPE_CHECKING, List, Optional--from openjarvis.core.types import ToolCall--if TYPE_CHECKING:- from openjarvis.core.events import EventBus- from openjarvis.security.scanner import BaseScanner--logger = logging.getLogger(__name__)---class SecurityBlockError(Exception):- """Raised when mode='block' and secrets/PII are detected."""---@dataclass(slots=True)-class ScanFinding:- """A single finding from a boundary scan."""-- pattern_name: str- destination: str---class BoundaryGuard:- """Scans outbound content for secrets and PII at device boundaries.-- Parameters- ----------- mode:- Action on findings: ``"redact"`` replaces matches,- ``"warn"`` logs but passes through, ``"block"`` raises.- enabled:- Master switch. When ``False``, all content passes through.- bus:- Optional event bus for publishing SECURITY_ALERT events.- scanners:- Custom scanners. Defaults to SecretScanner + PIIScanner.- """-- def __init__(- self,- mode: str = "redact",- *,- enabled: bool = True,- bus: Optional["EventBus"] = None,- scanners: Optional[List["BaseScanner"]] = None,- ) -> None:- self._mode = mode- self._enabled = enabled- self._bus = bus- if scanners is not None:- self._scanners = scanners- else:- self._scanners = self._default_scanners()-- @staticmethod- def _default_scanners() -> List["BaseScanner"]:- from openjarvis.security.scanner import PIIScanner, SecretScanner-- return [SecretScanner(), PIIScanner()]-- def scan_outbound(self, content: str, destination: str) -> str:- """Scan text before it leaves the device.-- Returns redacted text in ``"redact"`` mode, original text in- ``"warn"`` mode, or raises ``SecurityBlockError`` in ``"block"``- mode when findings are detected.- """- if not self._enabled or not content:- return content-- has_findings = False- redacted = content- for scanner in self._scanners:- result = scanner.scan(content)- if result.findings:- has_findings = True- if self._mode == "redact":- redacted = scanner.redact(redacted)-- if has_findings:- self._emit_alert(destination, content)- if self._mode == "block":- raise SecurityBlockError(- f"Secrets/PII detected in outbound content to {destination}"- )- if self._mode == "warn":- logger.warning(- "Secrets/PII detected in outbound content to %s", destination- )- return content- return redacted-- return content-- def check_outbound(self, tool_call: ToolCall) -> ToolCall:- """Scan tool call arguments before execution.-- Returns a new ToolCall with redacted arguments if needed.- """- if not self._enabled or not tool_call.arguments:- return tool_call-- redacted_args = self.scan_outbound(- tool_call.arguments, destination=f"tool:{tool_call.name}"- )- if redacted_args != tool_call.arguments:- return replace(tool_call, arguments=redacted_args)- return tool_call-- def _emit_alert(self, destination: str, content: str) -> None:- if self._bus is None:- return- try:- from openjarvis.core.events import EventType-- self._bus.publish(- EventType.SECURITY_ALERT,- {- "source": "boundary_guard",- "destination": destination,- "mode": self._mode,- "content_preview": content[:80],- },- )- except Exception:- logger.debug("Failed to emit security alert event", exc_info=True)-```--- [ ] **Step 4: Run tests to verify they pass**--Run: `uv run pytest tests/security/test_boundary_guard.py -v`-Expected: All 9 tests PASS.--- [ ] **Step 5: Commit**--```bash-git add src/openjarvis/security/boundary.py tests/security/test_boundary_guard.py-git commit -m "feat: BoundaryGuard module — scan/redact/block at device exit points"-```-------## Task 4: Boundary Guard — Engine & Tool Tagging--**Files:**-- Modify: `src/openjarvis/engine/_stubs.py:48-120` (InferenceEngine ABC)-- Modify: `src/openjarvis/engine/cloud.py:211` (CloudEngine)-- Modify: `src/openjarvis/engine/litellm.py:16` (LiteLLMEngine)-- Modify: `src/openjarvis/tools/_stubs.py:46-74` (BaseTool ABC)-- Modify: `src/openjarvis/tools/web_search.py` (WebSearchTool)-- Modify: `src/openjarvis/tools/http_request.py` (HttpRequestTool)-- Modify: `src/openjarvis/tools/browser.py` (BrowserNavigateTool and others)-- Modify: `src/openjarvis/tools/browser_axtree.py` (BrowserAXTreeTool)-- Modify: `src/openjarvis/tools/channel_tools.py` (ChannelSendTool)-- Modify: `src/openjarvis/tools/image_tool.py` (ImageGenerateTool)-- Modify: `src/openjarvis/tools/audio_tool.py` (AudioTranscribeTool)-- Test: `tests/security/test_boundary_guard.py` (extend)--- [ ] **Step 1: Write failing tests for engine and tool tagging**--Append to `tests/security/test_boundary_guard.py`:--```python-class TestEngineTagging:- """Cloud engines must have is_cloud=True, local engines is_cloud=False."""-- def test_inference_engine_default_is_local(self) -> None:- from openjarvis.engine._stubs import InferenceEngine-- assert InferenceEngine.is_cloud is False-- def test_cloud_engine_is_cloud(self) -> None:- from openjarvis.engine.cloud import CloudEngine-- assert CloudEngine.is_cloud is True-- def test_litellm_engine_is_cloud(self) -> None:- from openjarvis.engine.litellm import LiteLLMEngine-- assert LiteLLMEngine.is_cloud is True-- def test_ollama_engine_is_local(self) -> None:- from openjarvis.engine.ollama import OllamaEngine-- assert OllamaEngine.is_cloud is False---class TestToolTagging:- """External tools must have is_local=False, local tools is_local=True."""-- def test_base_tool_default_is_local(self) -> None:- from openjarvis.tools._stubs import BaseTool-- assert BaseTool.is_local is True-- def test_web_search_is_external(self) -> None:- from openjarvis.tools.web_search import WebSearchTool-- assert WebSearchTool.is_local is False-- def test_http_request_is_external(self) -> None:- from openjarvis.tools.http_request import HttpRequestTool-- assert HttpRequestTool.is_local is False-- def test_channel_send_is_external(self) -> None:- from openjarvis.tools.channel_tools import ChannelSendTool-- assert ChannelSendTool.is_local is False-- def test_think_tool_is_local(self) -> None:- from openjarvis.tools.think import ThinkTool-- assert ThinkTool.is_local is True-- def test_calculator_is_local(self) -> None:- from openjarvis.tools.calculator import CalculatorTool-- assert CalculatorTool.is_local is True-```--- [ ] **Step 2: Run tests to verify they fail**--Run: `uv run pytest tests/security/test_boundary_guard.py::TestEngineTagging -v`-Expected: FAIL — `InferenceEngine` has no `is_cloud` attribute.--Run: `uv run pytest tests/security/test_boundary_guard.py::TestToolTagging -v`-Expected: FAIL — `BaseTool` has no `is_local` attribute.--- [ ] **Step 3: Add `is_cloud` to InferenceEngine ABC**--In `src/openjarvis/engine/_stubs.py`, add to the `InferenceEngine` class body (after `engine_id: str`, around line 55):--```python- is_cloud: bool = False-```--- [ ] **Step 4: Set `is_cloud = True` on cloud engines**--In `src/openjarvis/engine/cloud.py`, add to the `CloudEngine` class body (after `engine_id = "cloud"`, around line 216):--```python- is_cloud = True-```--In `src/openjarvis/engine/litellm.py`, add to the `LiteLLMEngine` class body (after `engine_id = "litellm"`, around line 30):--```python- is_cloud = True-```--- [ ] **Step 5: Add `is_local` to BaseTool ABC**--In `src/openjarvis/tools/_stubs.py`, add to the `BaseTool` class body (after `tool_id: str`, around line 53):--```python- is_local: bool = True-```--- [ ] **Step 6: Set `is_local = False` on external tools**--In each of these files, add `is_local = False` to the class body (after `tool_id = "..."`):--- `src/openjarvis/tools/web_search.py` — `WebSearchTool`-- `src/openjarvis/tools/http_request.py` — `HttpRequestTool`-- `src/openjarvis/tools/browser.py` — `BrowserNavigateTool`, `BrowserClickTool`, `BrowserTypeTool`, `BrowserScreenshotTool`, `BrowserExtractTool`-- `src/openjarvis/tools/browser_axtree.py` — `BrowserAXTreeTool`-- `src/openjarvis/tools/channel_tools.py` — `ChannelSendTool`-- `src/openjarvis/tools/image_tool.py` — `ImageGenerateTool`-- `src/openjarvis/tools/audio_tool.py` — `AudioTranscribeTool`--Example for `WebSearchTool`:-```python[email protected]("web_search")-class WebSearchTool(BaseTool):- tool_id = "web_search"- is_local = False- # ... rest unchanged-```--- [ ] **Step 7: Run tests to verify they pass**--Run: `uv run pytest tests/security/test_boundary_guard.py -v`-Expected: All tests PASS.--- [ ] **Step 8: Commit**--```bash-git add src/openjarvis/engine/_stubs.py src/openjarvis/engine/cloud.py src/openjarvis/engine/litellm.py src/openjarvis/tools/_stubs.py src/openjarvis/tools/web_search.py src/openjarvis/tools/http_request.py src/openjarvis/tools/browser.py src/openjarvis/tools/browser_axtree.py src/openjarvis/tools/channel_tools.py src/openjarvis/tools/image_tool.py src/openjarvis/tools/audio_tool.py tests/security/test_boundary_guard.py-git commit -m "feat: tag engines with is_cloud and tools with is_local for boundary scanning"-```-------## Task 5: Boundary Guard — Wire into ToolExecutor and GuardrailsEngine--**Files:**-- Modify: `src/openjarvis/tools/_stubs.py:112-266` (ToolExecutor.execute)-- Modify: `src/openjarvis/security/guardrails.py:20-70` (GuardrailsEngine)-- Modify: `src/openjarvis/system.py:18-52` (JarvisSystem)-- Test: `tests/security/test_boundary_guard.py` (extend)--- [ ] **Step 1: Write failing tests for ToolExecutor integration**--Append to `tests/security/test_boundary_guard.py`:--```python-from unittest.mock import MagicMock---class TestToolExecutorBoundaryIntegration:- """ToolExecutor should use BoundaryGuard for external tool calls."""-- def _make_executor(self, boundary_guard=None):- from openjarvis.tools._stubs import BaseTool, ToolExecutor, ToolSpec-- class FakeExternalTool(BaseTool):- tool_id = "fake_external"- is_local = False-- @property- def spec(self):- return ToolSpec(- name="fake_external",- description="test",- parameters={"type": "object", "properties": {"q": {"type": "string"}}},- )-- def execute(self, **params):- from openjarvis.core.types import ToolResult-- return ToolResult(- tool_name="fake_external",- content=f"result for {params.get('q', '')}",- success=True,- )-- return ToolExecutor(- tools=[FakeExternalTool()],- boundary_guard=boundary_guard,- )-- def test_external_tool_args_scanned(self) -> None:- from openjarvis.core.types import ToolCall- from openjarvis.security.boundary import BoundaryGuard-- guard = BoundaryGuard(mode="redact")- executor = self._make_executor(boundary_guard=guard)-- tc = ToolCall(- id="t1",- name="fake_external",- arguments='{"q": "my key is sk-proj-abc123def456ghi789jkl012mno345pqr678stu"}',- )- result = executor.execute(tc)- # The tool should have received redacted args- assert "sk-proj-" not in result.content-- def test_no_guard_passes_through(self) -> None:- from openjarvis.core.types import ToolCall-- executor = self._make_executor(boundary_guard=None)- tc = ToolCall(- id="t2",- name="fake_external",- arguments='{"q": "sk-proj-abc123def456ghi789jkl012mno345pqr678stu"}',- )- result = executor.execute(tc)- assert "sk-proj-" in result.content-```--- [ ] **Step 2: Run tests to verify they fail**--Run: `uv run pytest tests/security/test_boundary_guard.py::TestToolExecutorBoundaryIntegration -v`-Expected: FAIL — `ToolExecutor.__init__` does not accept `boundary_guard`.--- [ ] **Step 3: Add BoundaryGuard to ToolExecutor**--In `src/openjarvis/tools/_stubs.py`, modify the `ToolExecutor.__init__` method to accept a `boundary_guard` parameter. Add it as `self._boundary_guard = boundary_guard`.--In the `execute()` method, after argument parsing succeeds (around where params are parsed from JSON, before the tool.execute call), add boundary checking for non-local tools:--```python- # Boundary guard: scan external tool arguments- if (- self._boundary_guard is not None- and not getattr(tool, "is_local", True)- ):- try:- tool_call = self._boundary_guard.check_outbound(tool_call)- # Re-parse arguments after potential redaction- params = json.loads(tool_call.arguments) if tool_call.arguments else {}- except Exception as exc:- return ToolResult(- tool_name=tool_call.name,- content=f"Security block: {exc}",- success=False,- )-```--- [ ] **Step 4: Add BoundaryGuard to JarvisSystem**--In `src/openjarvis/system.py`, add to the `JarvisSystem` dataclass (after `audit_logger`):--```python- boundary_guard: Optional[Any] = None # BoundaryGuard-```--- [ ] **Step 5: Run tests to verify they pass**--Run: `uv run pytest tests/security/test_boundary_guard.py -v`-Expected: All tests PASS.--- [ ] **Step 6: Commit**--```bash-git add src/openjarvis/tools/_stubs.py src/openjarvis/system.py tests/security/test_boundary_guard.py-git commit -m "feat: wire BoundaryGuard into ToolExecutor for external tool scanning"-```-------## Task 6: Webhook Fail-Closed Validation--**Files:**-- Modify: `src/openjarvis/server/webhook_routes.py:31-45` (_validate_twilio_signature)-- Test: `tests/security/test_webhook_validation.py`--- [ ] **Step 1: Write failing tests for fail-closed webhooks**--```python-# tests/security/test_webhook_validation.py-"""Tests for webhook fail-closed validation (Section 3)."""--from __future__ import annotations--from unittest.mock import patch---class TestTwilioValidationFailClosed:- """Twilio validation must reject when SDK is unavailable."""-- def test_missing_sdk_returns_false(self) -> None:- """When twilio is not installed, validation returns False."""- from openjarvis.server.webhook_routes import _validate_twilio_signature-- with patch.dict("sys.modules", {"twilio": None, "twilio.request_validator": None}):- # Force re-import to hit the ImportError path- result = _validate_twilio_signature(- auth_token="test_token",- url="https://example.com/webhooks/twilio",- params={"Body": "hello"},- signature="invalid",- )- assert result is False-- def test_empty_auth_token_returns_false(self) -> None:- """When no auth token is configured, validation returns False."""- from openjarvis.server.webhook_routes import _validate_twilio_signature-- result = _validate_twilio_signature(- auth_token="",- url="https://example.com/webhooks/twilio",- params={},- signature="",- )- assert result is False---class TestWebhookSecretEnforcement:- """Webhooks must return 503 when secrets are not configured."""-- def test_twilio_webhook_503_without_token(self) -> None:- """POST /webhooks/twilio should return 503 if no auth_token configured."""- from unittest.mock import MagicMock-- from fastapi.testclient import TestClient-- from openjarvis.server.app import create_app-- mock_engine = MagicMock()- mock_engine.health.return_value = True- mock_engine.list_models.return_value = ["test"]-- app = create_app(- mock_engine,- "test",- webhook_config={"twilio_auth_token": ""},- )- client = TestClient(app)- resp = client.post(- "/webhooks/twilio",- data={"From": "+1234567890", "Body": "hello"},- )- assert resp.status_code == 503-```--- [ ] **Step 2: Run tests to verify they fail**--Run: `uv run pytest tests/security/test_webhook_validation.py -v`-Expected: FAIL — `_validate_twilio_signature` returns `True` when SDK missing (not `False`). The 503 test may also fail since the current code doesn't enforce secret presence.--- [ ] **Step 3: Fix `_validate_twilio_signature` to fail-closed**--In `src/openjarvis/server/webhook_routes.py`, replace lines 31-45:--```python-def _validate_twilio_signature(- auth_token: str,- url: str,- params: dict,- signature: str,-) -> bool:- """Validate Twilio webhook signature using the SDK.-- Fails closed: returns ``False`` if the SDK is not installed or- if no auth_token is configured.- """- if not auth_token:- logger.error("Twilio auth token not configured — rejecting webhook")- return False- try:- from twilio.request_validator import RequestValidator-- validator = RequestValidator(auth_token)- return validator.validate(url, params, signature)- except ImportError:- logger.error(- "twilio SDK not installed — rejecting webhook. "- "Install it: pip install twilio"- )- return False-```--- [ ] **Step 4: Add 503 response for unconfigured webhook secrets**--In `src/openjarvis/server/webhook_routes.py`, in the Twilio webhook route handler, add an early check at the top of the handler (before signature validation):--```python- if not twilio_auth_token:- return Response(- '{"detail": "Webhook not configured — set TWILIO_AUTH_TOKEN"}',- status_code=503,- media_type="application/json",- )-```--- [ ] **Step 5: Run tests to verify they pass**--Run: `uv run pytest tests/security/test_webhook_validation.py -v`-Expected: All tests PASS.--- [ ] **Step 6: Apply SendBlue HMAC enforcement**--In `src/openjarvis/server/webhook_routes.py`, in the SendBlue webhook handler, update the secret validation block. The current code (around lines 234-238) only checks if `sb and sb.webhook_secret` — if no secret is configured, it accepts everything silently. Add a warning log when no secret is configured:--```python- if sb and sb.webhook_secret:- header_secret = request.headers.get("x-sendblue-secret", "")- if header_secret != sb.webhook_secret:- return Response("Invalid secret", status_code=403)- elif sb:- logger.warning(- "SendBlue webhook received without secret verification. "- "Set webhook_secret for HMAC validation."- )-```--- [ ] **Step 7: Commit**--```bash-git add src/openjarvis/server/webhook_routes.py tests/security/test_webhook_validation.py-git commit -m "fix: fail-closed webhook validation — reject when SDK missing or secret unconfigured"-```-------## Task 7: File Permissions — Secure Helpers--**Files:**-- Create: `src/openjarvis/security/file_utils.py`-- Test: `tests/security/test_file_permissions.py`--- [ ] **Step 1: Write failing tests for secure file helpers**--```python-# tests/security/test_file_permissions.py-"""Tests for secure file creation helpers (Section 4)."""--from __future__ import annotations--import os-import stat-import tempfile-from pathlib import Path---class TestSecureMkdir:- """secure_mkdir should create directories with 0o700."""-- def test_creates_directory_with_700(self) -> None:- from openjarvis.security.file_utils import secure_mkdir-- with tempfile.TemporaryDirectory() as tmp:- target = Path(tmp) / "secure_dir"- result = secure_mkdir(target)- assert result.is_dir()- mode = stat.S_IMODE(os.stat(target).st_mode)- assert mode == 0o700-- def test_creates_parent_directories(self) -> None:- from openjarvis.security.file_utils import secure_mkdir-- with tempfile.TemporaryDirectory() as tmp:- target = Path(tmp) / "a" / "b" / "c"- result = secure_mkdir(target)- assert result.is_dir()-- def test_existing_directory_gets_permission_fix(self) -> None:- from openjarvis.security.file_utils import secure_mkdir-- with tempfile.TemporaryDirectory() as tmp:- target = Path(tmp) / "existing"- target.mkdir(mode=0o755)- secure_mkdir(target)- mode = stat.S_IMODE(os.stat(target).st_mode)- assert mode == 0o700---class TestSecureCreate:- """secure_create should create files with 0o600."""-- def test_creates_file_with_600(self) -> None:- from openjarvis.security.file_utils import secure_create-- with tempfile.TemporaryDirectory() as tmp:- target = Path(tmp) / "secure_file.db"- result = secure_create(target)- assert result.exists()- mode = stat.S_IMODE(os.stat(target).st_mode)- assert mode == 0o600-- def test_existing_file_gets_permission_fix(self) -> None:- from openjarvis.security.file_utils import secure_create-- with tempfile.TemporaryDirectory() as tmp:- target = Path(tmp) / "existing.db"- target.write_text("data")- os.chmod(target, 0o644)- secure_create(target)- mode = stat.S_IMODE(os.stat(target).st_mode)- assert mode == 0o600-- def test_creates_parent_directory_with_700(self) -> None:- from openjarvis.security.file_utils import secure_create-- with tempfile.TemporaryDirectory() as tmp:- target = Path(tmp) / "sub" / "file.db"- secure_create(target)- parent_mode = stat.S_IMODE(os.stat(target.parent).st_mode)- assert parent_mode == 0o700-```--- [ ] **Step 2: Run tests to verify they fail**--Run: `uv run pytest tests/security/test_file_permissions.py -v`-Expected: FAIL — `openjarvis.security.file_utils` does not exist.--- [ ] **Step 3: Implement file_utils.py**--```python-# src/openjarvis/security/file_utils.py-"""Secure file and directory creation helpers.--All OpenJarvis data files under ``~/.openjarvis/`` should be created-through these helpers to ensure consistent, restrictive permissions.-"""--from __future__ import annotations--import os-from pathlib import Path---def secure_mkdir(path: Path, mode: int = 0o700) -> Path:- """Create a directory with restrictive permissions.-- Creates parent directories as needed, then sets *mode* on the- target directory (even if it already exists).- """- path.mkdir(parents=True, exist_ok=True)- os.chmod(path, mode)- return path---def secure_create(path: Path, mode: int = 0o600) -> Path:- """Ensure a file exists with restrictive permissions.-- Creates the parent directory with ``0o700`` if needed, touches the- file if it doesn't exist, and sets *mode* on it.- """- secure_mkdir(path.parent, mode=0o700)- if not path.exists():- path.touch()- os.chmod(path, mode)- return path-```--- [ ] **Step 4: Run tests to verify they pass**--Run: `uv run pytest tests/security/test_file_permissions.py -v`-Expected: All 6 tests PASS.--- [ ] **Step 5: Commit**--```bash-git add src/openjarvis/security/file_utils.py tests/security/test_file_permissions.py-git commit -m "feat: secure_mkdir and secure_create helpers for restrictive file permissions"-```-------## Task 8: File Permissions — Apply to All Database Paths--**Files:**-- Modify: `src/openjarvis/tools/storage/sqlite.py:33-45`-- Modify: `src/openjarvis/server/session_store.py:23-29`-- Modify: `src/openjarvis/traces/store.py:82-94`-- Modify: `src/openjarvis/security/audit.py:33-56`-- Modify: `src/openjarvis/connectors/store.py:118-131`-- Modify: `src/openjarvis/connectors/attachment_store.py:50-72`-- Modify: `src/openjarvis/cli/log_config.py:57-59`--- [ ] **Step 1: Protect ~/.openjarvis/ parent directory in config.py**--In `src/openjarvis/core/config.py`, after the `DEFAULT_CONFIG_DIR` definition (line 28), add:--```python-# Ensure the config directory exists with restrictive permissions on first access.-# This is the single biggest protection — even if individual files miss chmod,-# the 0o700 parent blocks other users.-def _ensure_config_dir() -> Path:- from openjarvis.security.file_utils import secure_mkdir- return secure_mkdir(DEFAULT_CONFIG_DIR)-```--Then call `_ensure_config_dir()` at the start of `load_config()` (around line 1310):--```python- _ensure_config_dir()- hw = detect_hardware()-```--- [ ] **Step 2: Update tools/storage/sqlite.py**--In `src/openjarvis/tools/storage/sqlite.py`, in the `__init__` method (around line 33), after resolving `db_path`, add:--```python- if self._db_path != ":memory:":- from openjarvis.security.file_utils import secure_create- secure_create(Path(self._db_path))-```--- [ ] **Step 3: Update session_store.py**--In `src/openjarvis/server/session_store.py`, replace the directory creation (line 26):--```python- # Before:- # Path(db_path).parent.mkdir(parents=True, exist_ok=True)-- # After:- from openjarvis.security.file_utils import secure_create- secure_create(Path(db_path))-```--- [ ] **Step 4: Update traces/store.py**--In `src/openjarvis/traces/store.py`, add before the `sqlite3.connect` call (around line 88):--```python- from openjarvis.security.file_utils import secure_create- if self._db_path != ":memory:":- secure_create(Path(self._db_path))-```--- [ ] **Step 5: Update security/audit.py**--In `src/openjarvis/security/audit.py`, replace the directory creation (line 39):--```python- # Before:- # self._db_path.parent.mkdir(parents=True, exist_ok=True)-- # After:- from openjarvis.security.file_utils import secure_create- secure_create(self._db_path)-```--- [ ] **Step 6: Update connectors/store.py**--In `src/openjarvis/connectors/store.py`, replace the directory creation (lines 127-128):--```python- # Before:- # if self._db_path != ":memory:":- # Path(self._db_path).parent.mkdir(parents=True, exist_ok=True)-- # After:- if self._db_path != ":memory:":- from openjarvis.security.file_utils import secure_create- secure_create(Path(self._db_path))-```--- [ ] **Step 7: Update connectors/attachment_store.py**--In `src/openjarvis/connectors/attachment_store.py`, replace directory creation (line 57-58):--```python- # Before:- # self._base_dir.mkdir(parents=True, exist_ok=True)-- # After:- from openjarvis.security.file_utils import secure_mkdir- secure_mkdir(self._base_dir)-```--And in the `store()` method, after writing blob files (around line 97):--```python- blob_path.write_bytes(content)- os.chmod(blob_path, 0o600)-```--- [ ] **Step 8: Update cli/log_config.py**--In `src/openjarvis/cli/log_config.py`, replace directory creation (lines 57-58):--```python- # Before:- # log_dir = Path.home() / ".openjarvis"- # log_dir.mkdir(parents=True, exist_ok=True)-- # After:- from openjarvis.security.file_utils import secure_mkdir- log_dir = Path.home() / ".openjarvis"- secure_mkdir(log_dir)-```--- [ ] **Step 9: Run existing tests to check for regressions**--Run: `uv run pytest tests/ -v -m "not live and not cloud" --timeout=30 -x`-Expected: No regressions. File creation still works, just with tighter permissions.--- [ ] **Step 10: Commit**--```bash-git add src/openjarvis/core/config.py src/openjarvis/tools/storage/sqlite.py src/openjarvis/server/session_store.py src/openjarvis/traces/store.py src/openjarvis/security/audit.py src/openjarvis/connectors/store.py src/openjarvis/connectors/attachment_store.py src/openjarvis/cli/log_config.py-git commit -m "fix: enforce 0o600/0o700 permissions on all database and data files"-```-------> **Deferred to follow-up:** Section 4.4 (Optional SQLCipher encryption) and Section 5.4 (vault promotion tip in auth setup wizard) are lower-priority items that can be implemented in a subsequent PR without blocking the core hardening.-------## Task 9: Log Sanitization — SanitizingFormatter--**Files:**-- Modify: `src/openjarvis/cli/log_config.py`-- Test: `tests/security/test_log_sanitization.py`--- [ ] **Step 1: Write failing tests for SanitizingFormatter**--```python-# tests/security/test_log_sanitization.py-"""Tests for log sanitization (Section 5)."""--from __future__ import annotations--import logging---class TestSanitizingFormatter:- """SanitizingFormatter should redact secrets in log messages."""-- def test_redacts_openai_key(self) -> None:- from openjarvis.cli.log_config import SanitizingFormatter-- fmt = SanitizingFormatter("%(message)s")- record = logging.LogRecord(- name="test",- level=logging.INFO,- pathname="",- lineno=0,- msg="Key is sk-proj-abc123def456ghi789jkl012mno345pqr678stu",- args=(),- exc_info=None,- )- result = fmt.format(record)- assert "sk-proj-" not in result- assert "[REDACTED" in result-- def test_redacts_aws_key(self) -> None:- from openjarvis.cli.log_config import SanitizingFormatter-- fmt = SanitizingFormatter("%(message)s")- record = logging.LogRecord(- name="test",- level=logging.INFO,- pathname="",- lineno=0,- msg="AWS: AKIAIOSFODNN7EXAMPLE",- args=(),- exc_info=None,- )- result = fmt.format(record)- assert "AKIAIOSFODNN7EXAMPLE" not in result-- def test_clean_message_unchanged(self) -> None:- from openjarvis.cli.log_config import SanitizingFormatter-- fmt = SanitizingFormatter("%(message)s")- record = logging.LogRecord(- name="test",- level=logging.INFO,- pathname="",- lineno=0,- msg="Server started on port 8000",- args=(),- exc_info=None,- )- result = fmt.format(record)- assert result == "Server started on port 8000"-- def test_redacts_slack_token(self) -> None:- from openjarvis.cli.log_config import SanitizingFormatter-- fmt = SanitizingFormatter("%(message)s")- record = logging.LogRecord(- name="test",- level=logging.INFO,- pathname="",- lineno=0,- msg="Token: xoxb-1234-5678-abcdefghij",- args=(),- exc_info=None,- )- result = fmt.format(record)- assert "xoxb-" not in result-```--- [ ] **Step 2: Run tests to verify they fail**--Run: `uv run pytest tests/security/test_log_sanitization.py -v`-Expected: FAIL — `SanitizingFormatter` does not exist in `log_config.py`.--- [ ] **Step 3: Implement SanitizingFormatter**--In `src/openjarvis/cli/log_config.py`, add at the top of the file (after imports):--```python-from openjarvis.security.credential_stripper import CredentialStripper--_stripper = CredentialStripper()---class SanitizingFormatter(logging.Formatter):- """Formatter that redacts credentials from log messages."""-- def format(self, record: logging.LogRecord) -> str:- msg = super().format(record)- return _stripper.strip(msg)-```--Then update `setup_logging()` to use `SanitizingFormatter` instead of `logging.Formatter` for both the console handler and file handler.--Replace the console formatter line:-```python- # Before:- # fmt = logging.Formatter("%(levelname)s %(name)s: %(message)s")-- # After:- fmt = SanitizingFormatter("%(levelname)s %(name)s: %(message)s")-```--Replace the file formatter line:-```python- # Before:- # file_fmt = logging.Formatter("%(asctime)s %(levelname)s %(name)s: %(message)s")-- # After:- file_fmt = SanitizingFormatter("%(asctime)s %(levelname)s %(name)s: %(message)s")-```--- [ ] **Step 4: Run tests to verify they pass**--Run: `uv run pytest tests/security/test_log_sanitization.py -v`-Expected: All 4 tests PASS.--- [ ] **Step 5: Commit**--```bash-git add src/openjarvis/cli/log_config.py tests/security/test_log_sanitization.py-git commit -m "feat: SanitizingFormatter — auto-redact credentials in all log output"-```-------## Task 10: Scoped Credential Access--**Files:**-- Modify: `src/openjarvis/core/credentials.py`-- Test: `tests/security/test_log_sanitization.py` (extend)--- [ ] **Step 1: Write failing tests for scoped credential access**--Append to `tests/security/test_log_sanitization.py`:--```python-import os-import tempfile-from pathlib import Path---class TestScopedCredentialAccess:- """get_tool_credential should return values without polluting os.environ."""-- def test_returns_credential_value(self) -> None:- from openjarvis.core.credentials import get_tool_credential-- with tempfile.NamedTemporaryFile(mode="w", suffix=".toml", delete=False) as f:- f.write('[slack]\nSLACK_BOT_TOKEN = "xoxb-test-token"\n')- f.flush()- result = get_tool_credential(- "slack", "SLACK_BOT_TOKEN", path=Path(f.name)- )- assert result == "xoxb-test-token"- # Must NOT have polluted os.environ- assert os.environ.get("SLACK_BOT_TOKEN") != "xoxb-test-token"- os.unlink(f.name)-- def test_returns_none_for_missing(self) -> None:- from openjarvis.core.credentials import get_tool_credential-- with tempfile.NamedTemporaryFile(mode="w", suffix=".toml", delete=False) as f:- f.write("[slack]\n")- f.flush()- result = get_tool_credential(- "slack", "SLACK_BOT_TOKEN", path=Path(f.name)- )- assert result is None- os.unlink(f.name)-- def test_returns_none_for_missing_file(self) -> None:- from openjarvis.core.credentials import get_tool_credential-- result = get_tool_credential(- "slack", "SLACK_BOT_TOKEN", path=Path("/nonexistent/file.toml")- )- assert result is None-```--- [ ] **Step 2: Run tests to verify they fail**--Run: `uv run pytest tests/security/test_log_sanitization.py::TestScopedCredentialAccess -v`-Expected: FAIL — `get_tool_credential` does not exist.--- [ ] **Step 3: Implement `get_tool_credential`**--In `src/openjarvis/core/credentials.py`, add after `inject_credentials()`:--```python-def get_tool_credential(- tool_name: str,- key: str,- *,- path: Path | None = None,-) -> str | None:- """Read a single credential without polluting ``os.environ``.-- Falls back to ``os.environ`` if the key is not in credentials.toml,- for backward compatibility with Docker env var workflows.- """- creds = load_credentials(path=path)- tool_creds = creds.get(tool_name, {})- value = tool_creds.get(key)- if value is not None:- return value- # Fallback to env var for backward compat- return os.environ.get(key) or None-```--- [ ] **Step 4: Run tests to verify they pass**--Run: `uv run pytest tests/security/test_log_sanitization.py -v`-Expected: All tests PASS.--- [ ] **Step 5: Commit**--```bash-git add src/openjarvis/core/credentials.py tests/security/test_log_sanitization.py-git commit -m "feat: get_tool_credential — scoped credential access without env pollution"-```-------## Task 11: Startup Credential Audit & Non-Loopback CORS Warning--**Files:**-- Modify: `src/openjarvis/cli/serve.py`--- [ ] **Step 1: Add startup credential audit log**--In `src/openjarvis/cli/serve.py`, after credential injection (after the `inject_credentials()` call if present, or after API key resolution around line 352), add:--```python- # Log credential status at startup- from openjarvis.core.credentials import get_credential_status, TOOL_CREDENTIALS-- _cred_parts = []- for _tool_name in sorted(TOOL_CREDENTIALS):- _status = get_credential_status(_tool_name)- _set = sum(1 for v in _status.values() if v)- _total = len(_status)- if _set > 0:- _cred_parts.append(f"{_tool_name}: {_set}/{_total} keys")- if _cred_parts:- logger.info("Credentials loaded — %s", ", ".join(_cred_parts))-```--- [ ] **Step 2: Add non-loopback CORS wildcard warning**--In `src/openjarvis/cli/serve.py`, before the `uvicorn.run()` call (around line 408), add:--```python- # Warn about wildcard CORS on non-loopback- import ipaddress as _ipa-- try:- _is_loop = _ipa.ip_address(bind_host).is_loopback- except ValueError:- _is_loop = bind_host in ("localhost", "")-- if not _is_loop and "*" in config.server.cors_origins:- console.print(- "[yellow bold]WARNING:[/yellow bold] Wildcard CORS with credentials "- "enabled on non-loopback interface. This allows any website to make "- "authenticated requests to your instance."- )-```--- [ ] **Step 3: Run full test suite to check for regressions**--Run: `uv run pytest tests/ -v -m "not live and not cloud" --timeout=30 -x`-Expected: No regressions.--- [ ] **Step 4: Commit**--```bash-git add src/openjarvis/cli/serve.py-git commit -m "feat: startup credential audit log and CORS wildcard warning"-```-------## Task 12: Security Headers — CSP for Docs--**Files:**-- Modify: `src/openjarvis/server/middleware.py:33-51`--- [ ] **Step 1: Add CSP header to SecurityHeadersMiddleware**--In `src/openjarvis/server/middleware.py`, add the CSP header inside the `dispatch` method, after the existing headers (around line 50):--```python- response.headers["Content-Security-Policy"] = "default-src 'self'"-```--Also add it to the `SECURITY_HEADERS` dict:--```python-SECURITY_HEADERS = {- "X-Content-Type-Options": "nosniff",- "X-Frame-Options": "DENY",- "X-XSS-Protection": "1; mode=block",- "Strict-Transport-Security": "max-age=31536000; includeSubDomains",- "Referrer-Policy": "strict-origin-when-cross-origin",- "Permissions-Policy": "camera=(), microphone=(), geolocation=()",- "Content-Security-Policy": "default-src 'self'",-}-```--- [ ] **Step 2: Run existing middleware tests**--Run: `uv run pytest tests/server/test_middleware.py -v`-Expected: May need to update `test_headers_dict` to include the new CSP header. If it fails, update the test's `expected_keys` set to include `"Content-Security-Policy"`.--- [ ] **Step 3: Commit**--```bash-git add src/openjarvis/server/middleware.py-git commit -m "feat: add Content-Security-Policy header to API responses"-```-------## Task 13: Security Profiles--**Files:**-- Modify: `src/openjarvis/core/config.py:1308-1368` (load_config)-- Test: `tests/security/test_security_profiles.py`--- [ ] **Step 1: Write failing tests for security profiles**--```python-# tests/security/test_security_profiles.py-"""Tests for security profile expansion (Section 7)."""--from __future__ import annotations---# Profile definitions — must match the implementation-_PROFILES = {- "personal": {- "host": "127.0.0.1",- "mode": "redact",- "rate_limit_enabled": True,- "local_engine_bypass": False,- "local_tool_bypass": False,- },- "shared": {- "host": "127.0.0.1",- "mode": "redact",- "rate_limit_enabled": True,- "local_engine_bypass": False,- "local_tool_bypass": False,- },- "server": {- "host": "0.0.0.0",- "mode": "block",- "rate_limit_enabled": True,- "rate_limit_rpm": 30,- "rate_limit_burst": 5,- "local_engine_bypass": False,- "local_tool_bypass": False,- },-}---class TestProfileExpansion:- """Profiles should pre-fill security and server config fields."""-- def test_personal_profile_sets_redact(self) -> None:- from openjarvis.core.config import SecurityConfig, apply_security_profile-- cfg = SecurityConfig(profile="personal")- server_cfg = None- apply_security_profile(cfg, server_cfg)- assert cfg.mode == "redact"- assert cfg.rate_limit_enabled is True-- def test_server_profile_sets_block(self) -> None:- from openjarvis.core.config import SecurityConfig, ServerConfig, apply_security_profile-- cfg = SecurityConfig(profile="server")- server_cfg = ServerConfig()- apply_security_profile(cfg, server_cfg)- assert cfg.mode == "block"- assert cfg.rate_limit_rpm == 30- assert cfg.rate_limit_burst == 5- assert server_cfg.host == "0.0.0.0"-- def test_explicit_override_beats_profile(self) -> None:- """User-set values in config.toml should override profile defaults."""- from openjarvis.core.config import SecurityConfig, apply_security_profile-- # Simulate: user set profile=server but also mode=warn- cfg = SecurityConfig(profile="server", mode="warn")- apply_security_profile(cfg, None, overrides={"mode"})- # mode should stay "warn" because user explicitly set it- assert cfg.mode == "warn"-- def test_empty_profile_is_noop(self) -> None:- from openjarvis.core.config import SecurityConfig, apply_security_profile-- cfg = SecurityConfig()- original_mode = cfg.mode- apply_security_profile(cfg, None)- assert cfg.mode == original_mode-- def test_unknown_profile_raises(self) -> None:- import pytest-- from openjarvis.core.config import SecurityConfig, apply_security_profile-- cfg = SecurityConfig(profile="nonexistent")- with pytest.raises(ValueError, match="Unknown security profile"):- apply_security_profile(cfg, None)-```--- [ ] **Step 2: Run tests to verify they fail**--Run: `uv run pytest tests/security/test_security_profiles.py -v`-Expected: FAIL — `apply_security_profile` does not exist.--- [ ] **Step 3: Implement profile expansion**--In `src/openjarvis/core/config.py`, add the profile expansion function (after the `SecurityConfig` dataclass):--```python-_SECURITY_PROFILES: dict[str, dict[str, Any]] = {- "personal": {- "security": {- "mode": "redact",- "rate_limit_enabled": True,- "local_engine_bypass": False,- "local_tool_bypass": False,- },- "server": {- "host": "127.0.0.1",- },- },- "shared": {- "security": {- "mode": "redact",- "rate_limit_enabled": True,- "local_engine_bypass": False,- "local_tool_bypass": False,- },- "server": {- "host": "127.0.0.1",- },- },- "server": {- "security": {- "mode": "block",- "rate_limit_enabled": True,- "rate_limit_rpm": 30,- "rate_limit_burst": 5,- "local_engine_bypass": False,- "local_tool_bypass": False,- },- "server": {- "host": "0.0.0.0",- },- },-}---def apply_security_profile(- security_cfg: SecurityConfig,- server_cfg: ServerConfig | None,- *,- overrides: set[str] | None = None,-) -> None:- """Expand a named security profile into config fields.-- Fields in *overrides* (explicitly set by the user in TOML) are- not overwritten by the profile.- """- profile = security_cfg.profile- if not profile:- return-- if profile not in _SECURITY_PROFILES:- raise ValueError(- f"Unknown security profile '{profile}'. "- f"Valid profiles: {', '.join(_SECURITY_PROFILES)}"- )-- _overrides = overrides or set()- pdef = _SECURITY_PROFILES[profile]-- for key, value in pdef.get("security", {}).items():- if key not in _overrides and hasattr(security_cfg, key):- setattr(security_cfg, key, value)-- if server_cfg is not None:- for key, value in pdef.get("server", {}).items():- if key not in _overrides and hasattr(server_cfg, key):- setattr(server_cfg, key, value)-```--- [ ] **Step 4: Hook profile expansion into load_config()**--In `src/openjarvis/core/config.py`, in the `load_config()` function, after all TOML sections have been applied (after the `for section_name in top_sections` loop, around line 1362), add:--```python- # Expand security profile (user TOML overrides take precedence)- _user_security_keys = set(data.get("security", {}).keys())- apply_security_profile(cfg.security, cfg.server, overrides=_user_security_keys)-```--- [ ] **Step 5: Run tests to verify they pass**--Run: `uv run pytest tests/security/test_security_profiles.py -v`-Expected: All 5 tests PASS.--- [ ] **Step 6: Commit**--```bash-git add src/openjarvis/core/config.py tests/security/test_security_profiles.py-git commit -m "feat: security profiles — personal, shared, server presets with user overrides"-```-------## Task 14: Doctor Security Check--**Files:**-- Modify: `src/openjarvis/cli/doctor_cmd.py:267-278` (_run_all_checks)--- [ ] **Step 1: Add security profile check to doctor**--In `src/openjarvis/cli/doctor_cmd.py`, add a new check function:--```python-def _check_security_profile() -> CheckResult:- """Check if a security profile is configured."""- try:- from openjarvis.core.config import load_config-- config = load_config()- if config.security.profile:- return CheckResult(- name="Security profile",- status="ok",- message=f"Profile '{config.security.profile}' active",- )- return CheckResult(- name="Security profile",- status="warn",- message="No security profile set",- details="Recommended: add security.profile = 'personal' to config.toml",- )- except Exception as exc:- return CheckResult(- name="Security profile",- status="fail",- message=f"Could not check: {exc}",- )-```--Add `checks.append(_check_security_profile())` to `_run_all_checks()`.--- [ ] **Step 2: Run doctor to verify**--Run: `uv run jarvis doctor`-Expected: Shows a "Security profile" row with a warning suggesting `security.profile = 'personal'`.--- [ ] **Step 3: Commit**--```bash-git add src/openjarvis/cli/doctor_cmd.py-git commit -m "feat: jarvis doctor checks for security profile configuration"-```-------## Task 15: Integration Verification--**Files:**-- All modified files from Tasks 1-14--- [ ] **Step 1: Run full test suite**--Run: `uv run pytest tests/ -v -m "not live and not cloud" --timeout=60`-Expected: All tests pass. No regressions.--- [ ] **Step 2: Run linting**--Run: `uv run ruff check src/ tests/`-Run: `uv run ruff format --check src/ tests/`-Expected: No lint errors, no format issues.--- [ ] **Step 3: Manual smoke test — server binding**--Run: `uv run jarvis serve --host 127.0.0.1 --port 8000`-Expected: Server starts on `127.0.0.1:8000`. Not accessible from other machines on the network.--- [ ] **Step 4: Manual smoke test — non-loopback rejection**--Run: `uv run jarvis serve --host 0.0.0.0`-Expected: Server refuses to start with error: `Binding to 0.0.0.0 requires OPENJARVIS_API_KEY to be set.`--- [ ] **Step 5: Manual smoke test — doctor**--Run: `uv run jarvis doctor`-Expected: Security profile check appears with a warning or OK status.--- [ ] **Step 6: Final commit (if any lint fixes needed)**--```bash-git add -u-git commit -m "fix: lint and format fixes for security hardening"-```diff --git a/docs/superpowers/specs/2026-03-28-security-hardening-design.md b/docs/superpowers/specs/2026-03-28-security-hardening-design.mddeleted file mode 100644index 700d14d3..00000000--- a/docs/superpowers/specs/2026-03-28-security-hardening-design.md+++ /dev/null@@ -1,362 +0,0 @@-# Security Hardening Design — Layered Boundary Enforcement--**Date**: 2026-03-28-**Status**: Approved-**Scope**: Network exposure, data scanning, webhook validation, file permissions, credential handling, security profiles--## Context--OpenJarvis stores and transmits sensitive data across messaging channels (Slack, WhatsApp, Gmail, Telegram, Discord, Twilio, SendBlue, iMessage, Signal) and cloud LLM providers (OpenAI, Anthropic, Google, OpenRouter, MiniMax). A security audit identified critical gaps:--- Server binds `0.0.0.0` with no auth, no TLS, wildcard CORS-- Security scanners exist but are off/warn-only by default-- Tool calls that send data externally are never scanned-- Webhook validation silently falls back to accepting all requests-- Databases created with default umask (world-readable on shared systems)-- Credentials in plaintext, injected into global `os.environ`-- Logs don't auto-redact secrets--**Primary deployment target**: Single user on personal Mac/laptop. Must also support multi-user shared machines and server deployments.--**Breaking changes**: Allowed, but migration must be straightforward with clear error messages.--## Approach--**Layered boundary enforcement** with security profile sugar.--One `BoundaryGuard` wraps all exit points from the device — cloud engines, external tools, webhooks. Config defaults are fixed directly in existing dataclasses. File permissions go through a shared helper. Security profiles provide a convenience shorthand for common deployment scenarios.-------## Section 1: Network Exposure Defaults--### 1.1 Server Binding--`ServerConfig.host` default changes from `"0.0.0.0"` to `"127.0.0.1"`.--**File**: `src/openjarvis/core/config.py:763`--Users who need network access explicitly set `host = "0.0.0.0"` in config.toml.--### 1.2 CORS Restriction--`server/app.py:182-188` changes from `allow_origins=["*"]` to a configurable list.--New field: `ServerConfig.cors_origins: list[str]`--Default: `["http://localhost:3000", "http://localhost:5173", "http://127.0.0.1:3000", "http://127.0.0.1:5173", "tauri://localhost"]`--### 1.3 Non-Loopback Auth Enforcement--If `host != 127.0.0.1` and no `OPENJARVIS_API_KEY` is set, the server refuses to start:--```-ERROR: Binding to 0.0.0.0 requires OPENJARVIS_API_KEY to be set. Run: jarvis auth generate-key-```--Loopback binding works without a key for local dev convenience.--### 1.4 Rate Limiting--`SecurityConfig.rate_limit_enabled` default changes from `False` to `True`. Existing values (60 rpm, 10 burst) stay the same.--### 1.5 TLS--Not adding TLS to the server. Better handled by reverse proxy (nginx, Caddy, Cloudflare Tunnel already supported).-------## Section 2: Boundary Guard — Scanning at Device Exit Points--### 2.1 New Module: `security/boundary.py`--`BoundaryGuard` class with two methods:--- `scan_outbound(content: str, destination: str) -> str` — scans text before it leaves the device, returns redacted text or raises `SecurityBlockError` in `"block"` mode-- `check_outbound(tool_call: ToolCall) -> ToolCall` — scans tool call arguments before execution, returns redacted tool call--Delegates to existing `SecretScanner` and `PIIScanner`. Publishes `SECURITY_ALERT` events to the audit system. One instance lives on `JarvisSystem`.--### 2.2 Engine Tagging--`InferenceEngine` ABC gets `is_cloud: bool = False`.--Cloud engines set `True`: `cloud.py`, `litellm.py`-Local engines keep `False`: `ollama.py`, `vllm.py`, `sglang.py`, `llamacpp.py`, `mlx.py`, `lmstudio.py`--### 2.3 Tool Tagging--`BaseTool` gets `is_local: bool = True` as default.--External tools override to `False`: `web_search`, `send_email`, `http_request`, and all channel `send()` methods (Slack, Discord, Telegram, WhatsApp, SendBlue, Twilio, Gmail, Signal). Any tool that makes an outbound network request is `is_local = False`.--File/shell/memory tools keep `True`: `file_read`, `file_write`, `shell_exec`, `memory_search`, `memory_index`, `calculator`, `code_interpreter`.--### 2.4 Integration Points--- `GuardrailsEngine` calls `BoundaryGuard.scan_outbound()` on messages before sending to cloud engines-- `ToolUsingAgent._execute_tool()` calls `BoundaryGuard.check_outbound()` on tool calls where `tool.is_local is False`-- Both paths always active by default (conservative)-- Config knobs `local_engine_bypass: bool = False` and `local_tool_bypass: bool = False` allow opt-out--### 2.5 Default Mode--`SecurityConfig.mode` changes from `"warn"` to `"redact"`.-------## Section 3: Webhook Fail-Closed & Inbound Validation--### 3.1 Fail-Closed Validation--`_validate_twilio_signature()` changes from `return True` to `return False` with `logger.error()` when SDK not installed. Same for all webhook validators.--Outbound sending still works. Only inbound webhook processing is blocked.--Response: HTTP 403 `{"detail": "Webhook signature validation unavailable — install the twilio package"}`--### 3.2 Webhook Secret Enforcement--If a channel's webhook route is registered but no secret/token is configured, return HTTP 503:--```json-{"detail": "Webhook not configured — set TWILIO_AUTH_TOKEN"}-```--### 3.3 SendBlue Exception--SendBlue doesn't always provide a signing secret. If `webhook_secret` is configured, HMAC is mandatory. If not configured, log a warning per webhook but still accept.--### 3.4 Webhook Auth Exemption--`_EXEMPT_PREFIXES` for `/webhooks/` stays — webhooks use per-platform signature verification (now actually enforced) instead of API key auth.-------## Section 4: File Permissions & Encryption at Rest--### 4.1 Shared Helper: `security/file_utils.py`--Two functions:--- `secure_mkdir(path: Path, mode: int = 0o700) -> Path`-- `secure_create(path: Path, mode: int = 0o600) -> Path`--Replaces scattered `p.parent.mkdir(parents=True, exist_ok=True)` calls.--### 4.2 Database Paths That Get `secure_create()`--- `tools/storage/sqlite.py` — `memory.db`-- `server/session_store.py` — `sessions.db`-- `traces/store.py` — `traces.db`-- `security/audit.py` — `audit.db`-- `connectors/store.py` — `knowledge.db`-- `connectors/attachment_store.py` — blob dir gets `secure_mkdir(0o700)`, blobs get `0o600`--### 4.3 Parent Directory Protection--`~/.openjarvis/` itself gets `secure_mkdir(0o700)` at first creation in `config.py`. This is the single biggest fix — even if individual files miss a chmod, the parent blocks access.--### 4.4 Optional SQLCipher--New `StorageConfig.encryption: bool = False`.--When `True`:-- SQLite connections use `sqlcipher` via `pysqlcipher3`-- Key derived from `~/.openjarvis/.vault_key`-- If `pysqlcipher3` not installed: `"storage.encryption requires pysqlcipher3 — run: pip install pysqlcipher3"`-- Migration: `jarvis db encrypt` CLI command copies plaintext DBs to encrypted ones--### 4.5 Vault Key Separation--New `SecurityConfig.vault_key_path` field (default: `~/.openjarvis/.vault_key`). Users in scenario B/C can point to a different location (mounted secrets volume, macOS Keychain wrapper). Default is fine for scenario A since `0o700` on parent protects it.-------## Section 5: Credential Handling & Log Sanitization--### 5.1 Log Sanitization--`cli/log_config.py` gets a `SanitizingFormatter` that runs `CredentialStripper.redact()` on every log message:--```python-class SanitizingFormatter(logging.Formatter):- def format(self, record):- msg = super().format(record)- return _stripper.redact(msg)-```--Applied to `cli.log` and the gateway log.--### 5.2 Scoped Credential Access--New function: `get_tool_credential(tool_name: str, key: str) -> str | None`--- Reads from `credentials.toml` (cached, thread-safe)-- Returns value without polluting global `os.environ`-- Channel/tool constructors updated to try `get_tool_credential()` first, fall back to `os.environ`-- `inject_credentials()` deprecated but still works for backward compat (Docker env var users)--### 5.3 Startup Credential Audit--Server startup logs which tools have credentials configured:--```-INFO: Credentials loaded — slack: 2/2 keys, telegram: 1/1 keys, whatsapp: 0/2 keys (not configured)-```--### 5.4 Vault Promotion--`jarvis auth setup` wizard gets a tip line: `"Tip: Use 'jarvis vault store' for encrypted credential storage"`-------## Section 6: CORS, Security Headers & Telegram Token--### 6.1 CORS--Covered in Section 1.2. Configurable origins, localhost defaults, `allow_credentials=True` safe with restricted origins.--### 6.2 Telegram Token in URL--Telegram API requires token in URL path — this is their design, not ours. Mitigations:-- `SanitizingFormatter` catches `bot[0-9]+:AA[a-zA-Z0-9_-]{33}` patterns in logs-- HTTPS required by Telegram (encrypted in transit)-- Code comment documenting the limitation--### 6.3 Non-Loopback CORS Warning--If server binds non-loopback and CORS origins contain `"*"` (user override), emit startup warning:--```-WARNING: Wildcard CORS with credentials enabled on non-loopback interface. This allows any website to make authenticated requests to your instance.-```--### 6.4 CSP Header--Add `Content-Security-Policy: default-src 'self'` for the `/docs` OpenAPI page.-------## Section 7: Security Profiles--### 7.1 Profile Field--New `SecurityConfig.profile: str = ""`. When set, pre-fills all security fields before user overrides.--### 7.2 Profile Definitions--**`personal`** (scenario A — single user, local hardware):-- `host = "127.0.0.1"`, `mode = "redact"`, `scan_input = True`, `scan_output = True`-- `rate_limit_enabled = True`, `storage.encryption = False`-- CORS: localhost origins only-- `local_engine_bypass = False`, `local_tool_bypass = False`--**`shared`** (scenario B — multi-user machine):-- Everything in `personal`, plus:-- `storage.encryption = True` (SQLCipher)-- API key required even on loopback-- `vault_key_path` recommended outside `~/.openjarvis/`--**`server`** (scenario C — network-facing):-- Everything in `shared`, plus:-- `host = "0.0.0.0"` (API key enforced by non-loopback guard)-- `rate_limit_rpm = 30`, `rate_limit_burst = 5`-- `mode = "block"` (reject rather than redact)-- CORS: must be explicitly configured--### 7.3 No Profile = Safe Defaults--If `profile` is empty, individual field defaults from Sections 1-6 apply. Profiles are convenience shorthand, not a separate system.--### 7.4 Startup Log--```-INFO: Security profile 'personal' active. Override individual settings in [security] section.-```--### 7.5 Config Migration via `jarvis doctor`--Health check CLI reports: `"Your config doesn't set a security profile. Recommended: security.profile = 'personal'"` with a diff of what would change.-------## Section 8: Verification & Testing--### 8.1 Unit Tests--One test file per section in `tests/security/`:--| File | Covers |-|------|--------|-| `test_network_defaults.py` | ServerConfig defaults, non-loopback auth enforcement, CORS origins |-| `test_boundary_guard.py` | `scan_outbound()` redaction, `check_outbound()` tool args, `is_cloud`/`is_local` tags, audit events |-| `test_webhook_validation.py` | Fail-closed when SDK missing, 503 when secret missing, outbound unaffected |-| `test_file_permissions.py` | `secure_mkdir` 0o700, `secure_create` 0o600, all DB paths use helper |-| `test_log_sanitization.py` | `SanitizingFormatter` redacts secrets, `get_tool_credential()` doesn't pollute env |-| `test_security_profiles.py` | Profile field values, individual overrides take precedence |--### 8.2 Integration Test--`test_boundary_integration.py` (marked `cloud`):-- Mock cloud engine receives redacted content-- Mock external tool receives redacted args-- Local tool receives unredacted args (when bypass enabled)--### 8.3 Implementation Order (by severity)--1. Network exposure defaults (Section 1)-2. Boundary guard (Section 2)-3. Webhook fail-closed (Section 3)-4. File permissions (Section 4)-5. Credential handling & logs (Section 5)-6. CORS & headers (Section 6)-7. Security profiles (Section 7)--Each section implemented and tests passing before moving to the next.--### 8.4 Manual Smoke Test--After all sections:-- `jarvis serve` binds `127.0.0.1` only-- `/health` accessible, `/v1/chat/completions` requires auth when non-loopback-- Message with `"my key is sk-abc123..."` through cloud engine shows `[REDACTED]` outbound-------## Files Modified (Summary)--**New files**:-- `src/openjarvis/security/boundary.py`-- `src/openjarvis/security/file_utils.py`-- `tests/security/test_network_defaults.py`-- `tests/security/test_boundary_guard.py`-- `tests/security/test_webhook_validation.py`-- `tests/security/test_file_permissions.py`-- `tests/security/test_log_sanitization.py`-- `tests/security/test_security_profiles.py`-- `tests/security/test_boundary_integration.py`--**Modified files**:-- `src/openjarvis/core/config.py` — ServerConfig, SecurityConfig, StorageConfig defaults-- `src/openjarvis/server/app.py` — CORS configuration-- `src/openjarvis/server/auth_middleware.py` — non-loopback enforcement-- `src/openjarvis/server/webhook_routes.py` — fail-closed validation-- `src/openjarvis/server/middleware.py` — CSP header-- `src/openjarvis/engine/base.py` — `is_cloud` attribute-- `src/openjarvis/engine/cloud.py`, `litellm.py` — `is_cloud = True`-- `src/openjarvis/tools/base.py` — `is_local` attribute-- External tool classes — `is_local = False`-- `src/openjarvis/agents/tool_using.py` — boundary guard integration-- `src/openjarvis/security/guardrails.py` — boundary guard integration-- `src/openjarvis/tools/storage/sqlite.py` — secure file creation-- `src/openjarvis/server/session_store.py` — secure file creation-- `src/openjarvis/traces/store.py` — secure file creation-- `src/openjarvis/security/audit.py` — secure file creation-- `src/openjarvis/connectors/store.py` — secure file creation-- `src/openjarvis/connectors/attachment_store.py` — secure file/dir creation-- `src/openjarvis/core/credentials.py` — scoped access, deprecate inject-- `src/openjarvis/cli/log_config.py` — SanitizingFormatter-- `src/openjarvis/cli/serve.py` — startup checks, profile logging-- `src/openjarvis/channels/sendblue.py` — webhook HMAC enforcement-- `src/openjarvis/system.py` — BoundaryGuard wiring