fortresscodeai 0.1.0__py3-none-any.whl

backend/Modules/autobuilder_orchestration/backend/models/autobuilder.py

@@ -0,0 +1,28 @@
+from typing import Any, Dict, List, Optional
+from pydantic import BaseModel
+from datetime import datetime
+from enum import Enum
+
+
+class BuildStatus(str, Enum):
+    PENDING = "pending"
+    RUNNING = "running"
+    FAILED = "failed"
+    COMPLETED = "completed"
+    BLOCKED_HITL = "blocked_hitl"
+
+
+class BuildRequest(BaseModel):
+    id: str
+    created_at: datetime
+    requested_by: str
+    blueprint: Dict[str, Any]
+    correlation_id: str
+
+
+class BuildArtifact(BaseModel):
+    id: str
+    build_id: str
+    created_at: datetime
+    artifact_type: str  # e.g. "agent", "workflow", "test_suite"
+    content: Dict[str, Any]

backend/Modules/autobuilder_orchestration/backend/services/autobuilder_service.py

@@ -0,0 +1,76 @@
+from typing import Dict, Any
+from datetime import datetime
+import uuid
+
+from backend.Modules.autobuilder_orchestration.backend.models.autobuilder import BuildRequest, BuildArtifact, BuildStatus
+from backend.models.policy import PolicyViolation
+from backend.services.policy.policy_engine import PolicyEngine
+from backend.services.hitl_service import HITLService
+from backend.Modules.audit_logging_engine import AuditService
+
+
+
+class AutobuilderService:
+    def __init__(self, store, policy_engine: PolicyEngine, hitl: HITLService, audit: AuditService):
+        self.store = store
+        self.policy_engine = policy_engine
+        self.hitl = hitl
+        self.audit = audit
+
+    def submit_build(self, requested_by: str, blueprint: Dict[str, Any]) -> BuildRequest:
+        correlation_id = str(uuid.uuid4())
+        build_request = BuildRequest(
+            id=str(uuid.uuid4()),
+            created_at=datetime.utcnow(),
+            requested_by=requested_by,
+            blueprint=blueprint,
+            correlation_id=correlation_id,
+        )
+        self.store.save_build_request(build_request)
+        self.audit.log_event(
+            actor=requested_by,
+            action="build_submitted",
+            resource=f"build:{build_request.id}",
+            details={"blueprint": blueprint},
+            correlation_id=correlation_id,
+        )
+        return build_request
+
+    def run_build(self, build_request: BuildRequest) -> BuildArtifact:
+        context = {"blueprint": build_request.blueprint, "requested_by": build_request.requested_by}
+        violations = self.policy_engine.evaluate(context)
+
+        if any(v.severity in ("high", "critical") for v in violations):
+            # create HITL task and block
+            self.hitl.create_review_task(
+                correlation_id=build_request.correlation_id,
+                actor="autobuilder",
+                payload={"build_request_id": build_request.id, "violations": [v.dict() for v in violations]},
+            )
+            self.audit.log_event(
+                actor="autobuilder",
+                action="build_blocked_hitl",
+                resource=f"build:{build_request.id}",
+                details={"violations": [v.dict() for v in violations]},
+                correlation_id=build_request.correlation_id,
+            )
+            # you might persist status as BLOCKED_HITL here
+            raise RuntimeError("Build blocked pending human review")
+
+        # TODO: actual generation logic
+        artifact = BuildArtifact(
+            id=str(uuid.uuid4()),
+            build_id=build_request.id,
+            created_at=datetime.utcnow(),
+            artifact_type="agent",
+            content={"generated": True, "blueprint": build_request.blueprint},
+        )
+        self.store.save_build_artifact(artifact)
+        self.audit.log_event(
+            actor="autobuilder",
+            action="build_completed",
+            resource=f"build:{build_request.id}",
+            details={"artifact_id": artifact.id},
+            correlation_id=build_request.correlation_id,
+        )
+        return artifact

backend/Modules/dispute_resolution_system/backend/models/audit.py

@@ -0,0 +1,21 @@
+from typing import Any, Dict, Optional, List
+from pydantic import BaseModel
+from datetime import datetime
+
+
+class AuditLogEntry(BaseModel):
+    id: str
+    timestamp: datetime
+    actor: str
+    action: str
+    resource: Optional[str] = None
+    details: Dict[str, Any]
+    correlation_id: Optional[str] = None
+    tags: List[str] = []
+
+
+class AuditBundle(BaseModel):
+    bundle_id: str
+    created_at: datetime
+    correlation_id: str
+    entries: List[AuditLogEntry]

backend/Modules/dispute_resolution_system/backend/pipelines/governance_pipeline.py

@@ -0,0 +1,32 @@
+from typing import Dict, Any
+
+from backend.services.audit_service import AuditService
+from backend.services.policy.policy_engine import PolicyEngine
+from backend.services.hitl_service import HITLService
+from backend.Modules.dispute_resolution_system.backend.services.disputes_service import DisputesService
+
+
+class GovernancePipeline:
+    def __init__(
+        self,
+        audit: AuditService,
+        policy: PolicyEngine,
+        hitl: HITLService,
+        disputes: DisputesService,
+    ):
+        self.audit = audit
+        self.policy = policy
+        self.hitl = hitl
+        self.disputes = disputes
+
+    def process_action(self, actor: str, action: str, context: Dict[str, Any], correlation_id: str):
+        self.audit.log_event(
+            actor=actor,
+            action=action,
+            details=context,
+            correlation_id=correlation_id,
+        )
+
+        violations = self.policy.evaluate(context)
+        # you can route violations to HITL, autobuilder, etc. here
+        return violations

backend/Modules/dispute_resolution_system/backend/services/audit_service.py

@@ -0,0 +1,46 @@
+from typing import List, Dict, Any, Optional
+from datetime import datetime
+import uuid
+
+from backend.models.audit import AuditLogEntry, AuditBundle
+
+
+class AuditService:
+    def __init__(self, store):
+        self.store = store  # e.g. DB adapter, message bus, etc.
+
+    def log_event(
+        self,
+        actor: str,
+        action: str,
+        resource: Optional[str] = None,
+        details: Optional[Dict[str, Any]] = None,
+        correlation_id: Optional[str] = None,
+        tags: Optional[List[str]] = None,
+    ) -> AuditLogEntry:
+        entry = AuditLogEntry(
+            id=str(uuid.uuid4()),
+            timestamp=datetime.utcnow(),
+            actor=actor,
+            action=action,
+            resource=resource,
+            details=details or {},
+            correlation_id=correlation_id,
+            tags=tags or [],
+        )
+        self.store.save_audit_entry(entry)
+        return entry
+
+    def get_entries_by_correlation(self, correlation_id: str) -> List[AuditLogEntry]:
+        return self.store.get_entries_by_correlation(correlation_id)
+
+    def create_bundle(self, correlation_id: str) -> AuditBundle:
+        entries = self.get_entries_by_correlation(correlation_id)
+        bundle = AuditBundle(
+            bundle_id=str(uuid.uuid4()),
+            created_at=datetime.utcnow(),
+            correlation_id=correlation_id,
+            entries=entries,
+        )
+        self.store.save_audit_bundle(bundle)
+        return bundle

backend/Modules/dispute_resolution_system/backend/services/disputes_service.py

@@ -0,0 +1,65 @@
+from typing import Optional
+from datetime import datetime
+import uuid
+
+from backend.models.disputes import DisputeCase, DisputeStatus
+from backend.Modules.audit_logging_engine import AuditService
+
+
+class DisputesService:
+    def __init__(self, store, audit: AuditService):
+        self.store = store
+        self.audit = audit
+
+    def open_dispute(
+        self,
+        opened_by: str,
+        correlation_id: str,
+        subject: str,
+        description: str,
+    ) -> DisputeCase:
+        case = DisputeCase(
+            id=str(uuid.uuid4()),
+            created_at=datetime.utcnow(),
+            opened_by=opened_by,
+            correlation_id=correlation_id,
+            subject=subject,
+            description=description,
+        )
+        self.store.save_dispute_case(case)
+        self.audit.log_event(
+            actor=opened_by,
+            action="dispute_opened",
+            resource=f"dispute:{case.id}",
+            details={"subject": subject},
+            correlation_id=correlation_id,
+        )
+        return case
+
+    def attach_evidence_bundle(self, case_id: str, bundle_id: str) -> DisputeCase:
+        case = self.store.get_dispute_case(case_id)
+        case.evidence_bundle_id = bundle_id
+        self.store.update_dispute_case(case)
+        self.audit.log_event(
+            actor="system",
+            action="dispute_evidence_attached",
+            resource=f"dispute:{case.id}",
+            details={"bundle_id": bundle_id},
+            correlation_id=case.correlation_id,
+        )
+        return case
+
+    def resolve_dispute(self, case_id: str, resolution: str) -> DisputeCase:
+        case = self.store.get_dispute_case(case_id)
+        case.status = DisputeStatus.RESOLVED
+        case.resolution = resolution
+        case.resolved_at = datetime.utcnow()
+        self.store.update_dispute_case(case)
+        self.audit.log_event(
+            actor="system",
+            action="dispute_resolved",
+            resource=f"dispute:{case.id}",
+            details={"resolution": resolution},
+            correlation_id=case.correlation_id,
+        )
+        return case

backend/app/agent_runtime.py

@@ -0,0 +1,274 @@
+"""
+agent_runtime.py
+
+Secure, policy-driven agent runtime for FortressCodeAI.
+
+Responsibilities:
+- Enforce tenant isolation and sandboxing
+- Load and apply agent policies (tools, limits, network)
+- Build a controlled toolset for the agent
+- Orchestrate LLM calls (currently via a pluggable client)
+- Log all significant actions for auditability
+
+This runtime is the core of your "agent sandboxing" story for pen-tests.
+"""
+
+from __future__ import annotations
+
+import uuid
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Callable
+
+from .dependencies import get_settings
+from .storage import Storage
+from .tools import build_tools, ToolError, ToolSecurityError
+
+
+# ------------------------------------------------------------
+# Agent policy and definition
+# ------------------------------------------------------------
+
+@dataclass
+class AgentPolicy:
+    """
+    Policy envelope for an agent.
+
+    Controls:
+    - Which tools are allowed
+    - Max tokens per call
+    - Max steps per run
+    - Whether network access is allowed
+    - Optional network allowlist
+    """
+
+    allowed_tools: List[str] = field(default_factory=list)
+    max_tokens: int = 4096
+    max_steps: int = 4
+    allow_network: bool = False
+    network_allowlist: List[str] = field(default_factory=list)
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "AgentPolicy":
+        return cls(
+            allowed_tools=data.get("allowed_tools", []),
+            max_tokens=int(data.get("max_tokens", 4096)),
+            max_steps=int(data.get("max_steps", 4)),
+            allow_network=bool(data.get("allow_network", False)),
+            network_allowlist=list(data.get("network_allowlist", [])),
+        )
+
+
+@dataclass
+class AgentDefinition:
+    """
+    Canonical agent definition.
+
+    Expected shape of your "agents" table / config:
+    - id: unique identifier
+    - name: human-readable name
+    - prompt: system prompt / instructions
+    - policy: dict -> AgentPolicy
+    """
+
+    id: str
+    name: str
+    prompt: str
+    policy: AgentPolicy
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "AgentDefinition":
+        policy = AgentPolicy.from_dict(data.get("policy", {}))
+        return cls(
+            id=data.get("id", ""),
+            name=data.get("name", ""),
+            prompt=data.get("prompt", "You are an agent."),
+            policy=policy,
+        )
+
+
+# ------------------------------------------------------------
+# LLM client abstraction (fake implementation for now)
+# ------------------------------------------------------------
+
+class LLMClient:
+    """
+    Pluggable LLM client abstraction.
+
+    For now, this is a fake implementation that echoes back the payload.
+    Later, you can replace this with a real provider (OpenAI, Azure, etc.)
+    without changing the AgentRuntime.
+    """
+
+    def __init__(self, logger: Callable[[str], None]):
+        self.logger = logger
+
+    def call(
+        self,
+        system_prompt: str,
+        task_payload: Dict[str, Any],
+        tools: Dict[str, Callable],
+        max_tokens: int,
+    ) -> Dict[str, Any]:
+        """
+        Fake LLM call.
+
+        A real implementation would:
+        - Serialize tools as function definitions
+        - Call the provider with tool support
+        - Execute tool calls as requested
+        - Return the final structured result
+        """
+        self.logger("[llm] fake call invoked (replace with real provider)")
+
+        # For now, just echo back the payload and list tools.
+        return {
+            "summary": "Fake LLM response. Replace LLMClient.call() with a real implementation.",
+            "task_payload": task_payload,
+            "available_tools": list(tools.keys()),
+            "max_tokens_used": min(max_tokens, 512),
+        }
+
+
+# ------------------------------------------------------------
+# Agent runtime
+# ------------------------------------------------------------
+
+class AgentRuntime:
+    """
+    Secure execution environment for a single agent run.
+
+    Lifecycle:
+    - Initialize with tenant_id, agent_def, workflow context, storage, logger
+    - Create a per-run sandbox directory
+    - Build a policy-bound toolset
+    - Call the LLM client with the system prompt + task payload + tools
+    - Return a structured result
+
+    This class is the core of your "agent sandboxing" story.
+    """
+
+    def __init__(
+        self,
+        tenant_id: str,
+        agent_def: Dict[str, Any],
+        workflow_ctx: Dict[str, Any],
+        storage: Storage,
+        logger: Callable[[str], None],
+    ):
+        self.tenant_id = tenant_id
+        self.agent = AgentDefinition.from_dict(agent_def)
+        self.workflow_ctx = workflow_ctx
+        self.storage = storage
+        self.logger = logger
+
+        settings = get_settings()
+        self.sandbox_root = Path(getattr(settings, "AGENT_SANDBOX_PATH", "./workspaces")).resolve()
+
+        self.policy = self.agent.policy
+        self.sandbox_path = self._init_sandbox()
+        self.tools = self._build_tools()
+        self.llm_client = LLMClient(logger=self._log)
+
+    # --------------------------------------------------------
+    # Internal helpers
+    # --------------------------------------------------------
+
+    def _log(self, message: str) -> None:
+        self.logger(f"[agent:{self.agent.id}] {message}")
+
+    def _init_sandbox(self) -> Path:
+        """
+        Create a per-run sandbox directory for this agent execution.
+        """
+        run_id = str(uuid.uuid4())
+        path = self.sandbox_root / self.tenant_id / run_id
+        path.mkdir(parents=True, exist_ok=True)
+        self._log(f"sandbox created at {path}")
+        return path.resolve()
+
+    def _build_tools(self) -> Dict[str, Callable]:
+        """
+        Build the policy-bound toolset for this agent.
+        """
+        network_allowlist: Optional[List[str]] = None
+        if self.policy.allow_network:
+            network_allowlist = self.policy.network_allowlist
+
+        tools = build_tools(
+            tenant_id=self.tenant_id,
+            sandbox_path=self.sandbox_path,
+            storage=self.storage,
+            logger=self._log,
+            allowed_tools=self.policy.allowed_tools,
+            network_allowlist=network_allowlist,
+        )
+
+        self._log(f"tools enabled: {list(tools.keys())}")
+        return tools
+
+    def _build_system_prompt(self) -> str:
+        """
+        Build the final system prompt for the agent.
+        You can enrich this with tenant/workflow context if desired.
+        """
+        base = self.agent.prompt
+        # You can inject governance / safety instructions here if you want.
+        safety_suffix = (
+            "\n\n"
+            "You must strictly follow the provided tools and never attempt to access resources "
+            "outside the sandbox or tenant context. If a requested action is not possible with "
+            "the available tools, explain that clearly."
+        )
+        return base + safety_suffix
+
+    # --------------------------------------------------------
+    # Public API
+    # --------------------------------------------------------
+
+    def run(self, task_payload: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Execute the agent with the given task payload.
+
+        Returns a structured result that can be stored in workflow context.
+        """
+        self._log(
+            f"run started for tenant={self.tenant_id}, "
+            f"agent={self.agent.name}, "
+            f"max_tokens={self.policy.max_tokens}, "
+            f"max_steps={self.policy.max_steps}"
+        )
+
+        system_prompt = self._build_system_prompt()
+
+        try:
+            result = self.llm_client.call(
+                system_prompt=system_prompt,
+                task_payload=task_payload,
+                tools=self.tools,
+                max_tokens=self.policy.max_tokens,
+            )
+        except (ToolError, ToolSecurityError) as e:
+            self._log(f"tool error: {e}")
+            return {
+                "status": "error",
+                "error_type": "tool_error",
+                "message": str(e),
+            }
+        except Exception as e:
+            self._log(f"runtime error: {e}")
+            return {
+                "status": "error",
+                "error_type": "runtime_error",
+                "message": str(e),
+            }
+
+        self._log("run completed successfully")
+
+        return {
+            "status": "ok",
+            "agent_id": self.agent.id,
+            "agent_name": self.agent.name,
+            "sandbox_path": str(self.sandbox_path),
+            "result": result,
+        }

backend/app/api/__init__.py

@@ -0,0 +1,17 @@
+from fastapi import APIRouter
+
+from .routes_health import router as health_router
+from .routes_plugins import router as plugins_router
+from .routes_workflows import router as workflows_router
+from .routes_devtools import router as devtools_router
+from .routes_metrics import router as metrics_router
+
+api_router = APIRouter()
+
+api_router.include_router(health_router, prefix="/health")
+api_router.include_router(plugins_router, prefix="/plugins")
+api_router.include_router(workflows_router, prefix="/workflows")
+api_router.include_router(devtools_router, prefix="/devtools")
+api_router.include_router(metrics_router, prefix="/metrics")
+
+__all__ = ["api_router"]

backend/app/api/governance.py

@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+from typing import Dict, Any
+
+from backend.app.governance.policies.evaluator import PolicyEvaluator
+
+router = APIRouter(prefix="/governance", tags=["governance"])
+
+evaluator: PolicyEvaluator = None  # injected in main.py
+
+
+@router.post("/evaluate/{trigger}")
+def evaluate(trigger: str, context: Dict[str, Any]):
+    results = evaluator.evaluate(trigger, context)
+    return {"results": results}

backend/app/api/main.py

@@ -0,0 +1,18 @@
+import uvicorn
+from backend.app.create_app import create_api_app
+
+
+def main():
+    app = create_api_app()
+    uvicorn.run(
+        app,
+        host="0.0.0.0",
+        port=8000,
+        log_level="info",
+        proxy_headers=True,
+        forwarded_allow_ips="*",
+    )
+
+
+if __name__ == "__main__":
+    main()

backend/app/api/policies.py

@@ -0,0 +1,54 @@
+from fastapi import APIRouter, HTTPException
+from typing import Dict, Any
+
+from backend.app.governance.policies.registry import PolicyRegistry
+from backend.app.governance.policies.loader import PolicyLoader
+from backend.app.governance.policies.evaluator import PolicyEvaluator
+from backend.app.governance.policies.versioning import PolicyVersionStore
+
+router = APIRouter(prefix="/policies", tags=["policies"])
+
+# Injected singletons (you will initialize these in main.py)
+registry: PolicyRegistry = None
+loader: PolicyLoader = None
+evaluator: PolicyEvaluator = None
+versions: PolicyVersionStore = None
+
+
+@router.get("/")
+def list_policies():
+    return {
+        "active": list(registry.active.values()),
+        "disabled": list(registry.disabled.values()),
+    }
+
+
+@router.get("/{policy_id}")
+def get_policy(policy_id: str):
+    policy = registry.get_policy(policy_id)
+    if not policy:
+        raise HTTPException(404, "Policy not found")
+    return policy
+
+
+@router.post("/reload")
+def reload_policies():
+    registry.active.clear()
+    registry.disabled.clear()
+    loader.load_all()
+    return {"status": "reloaded", "count": len(registry.active)}
+
+
+@router.post("/{policy_id}/simulate")
+def simulate_policy(policy_id: str, context: Dict[str, Any]):
+    policy = registry.get_policy(policy_id)
+    if not policy:
+        raise HTTPException(404, "Policy not found")
+
+    results = evaluator.evaluate(policy.trigger, context)
+    return {"results": results}
+
+
+@router.get("/{policy_id}/versions")
+def get_policy_versions(policy_id: str):
+    return versions.get_versions(policy_id)