radsimcli 1.2.1__py3-none-any.whl

radsim/__init__.py

@@ -0,0 +1,127 @@
+# RadSim - AI Coding Agent
+# Copyright (c) 2024-2026 Matthew Bright
+# Licensed under the MIT License. See LICENSE file for details.
+
+"""RadSim Agent Framework - Radically Simple Code Generation."""
+
+__version__ = "1.2.1"
+__author__ = "Emera Digital Tools"
+
+# Core exports
+from .health import (
+    HealthChecker,
+    HealthStatus,
+    SecretExpirationMonitor,
+    check_health,
+    check_secret_expirations,
+    get_expiration_monitor,
+    get_health_checker,
+    validate_startup,
+)
+from .hooks import (
+    HookContext,
+    HooksManager,
+    HookType,
+    get_hooks_manager,
+    on_error,
+    post_api,
+    post_tool,
+    pre_api,
+    pre_tool,
+)
+from .model_router import (
+    ModelRouter,
+    TaskComplexity,
+    get_router,
+    select_model_for_task,
+)
+from .skill_registry import (
+    SkillRegistry,
+    get_skill_registry,
+    load_skill,
+    load_skill_for_tool,
+)
+from .sub_agent import (
+    SubAgentResult,
+    SubAgentTask,
+    delegate_task,
+    execute_subagent_task,
+    list_available_models,
+    quick_task,
+    resolve_model_name,
+)
+from .task_logger import (
+    TaskLogger,
+    get_logger,
+    log_api,
+    log_error,
+    log_tool,
+)
+from .tool_result import ToolResult, wrap_tool_call
+from .vector_memory import (
+    VectorMemory,
+    get_context,
+    get_memory_backend,
+    is_vector_memory_available,
+    recall,
+    remember,
+)
+
+__all__ = [
+    # Version
+    "__version__",
+    "__author__",
+    # Tool Results
+    "ToolResult",
+    "wrap_tool_call",
+    # Skill Registry
+    "SkillRegistry",
+    "get_skill_registry",
+    "load_skill",
+    "load_skill_for_tool",
+    # Hooks
+    "HookType",
+    "HookContext",
+    "HooksManager",
+    "get_hooks_manager",
+    "pre_tool",
+    "post_tool",
+    "pre_api",
+    "post_api",
+    "on_error",
+    # Logging
+    "TaskLogger",
+    "get_logger",
+    "log_tool",
+    "log_api",
+    "log_error",
+    # Model Routing
+    "ModelRouter",
+    "TaskComplexity",
+    "get_router",
+    "select_model_for_task",
+    # Vector Memory
+    "VectorMemory",
+    "remember",
+    "recall",
+    "get_context",
+    "is_vector_memory_available",
+    "get_memory_backend",
+    # Sub-Agent Delegation
+    "SubAgentTask",
+    "SubAgentResult",
+    "delegate_task",
+    "quick_task",
+    "execute_subagent_task",
+    "list_available_models",
+    "resolve_model_name",
+    # Health Checks
+    "HealthChecker",
+    "HealthStatus",
+    "SecretExpirationMonitor",
+    "check_health",
+    "check_secret_expirations",
+    "get_expiration_monitor",
+    "get_health_checker",
+    "validate_startup",
+]

radsim/__main__.py

@@ -0,0 +1,6 @@
+"""Allow running RadSim as a module: python -m radsim."""
+
+from .cli import main
+
+if __name__ == "__main__":
+    main()

radsim/access_control.py

@@ -0,0 +1,93 @@
+"""Secure Access Control - RadSim Principle: Defense in Depth.
+
+Access code security:
+1. Never logged to any file or database
+2. Never printed to console (uses getpass)
+3. Never committed to version control
+4. Loaded from environment variable only
+5. Uses constant-time comparison (prevents timing attacks)
+"""
+
+import hmac
+import os
+
+
+def _secure_compare(provided: str, stored: str) -> bool:
+    """Compare strings in constant time to prevent timing attacks.
+
+    RadSim Principle: Security by Default
+    Timing attacks can reveal password length/characters by measuring
+    comparison time. HMAC compare_digest prevents this.
+    """
+    return hmac.compare_digest(provided.encode("utf-8"), stored.encode("utf-8"))
+
+
+def get_access_code_from_env() -> str | None:
+    """Load access code from environment (never log this value)."""
+    # Check ~/.radsim/.env first, then system env
+    from .config import load_env_file
+
+    env_config = load_env_file()
+
+    # Look for RADSIM_ACCESS_CODE in .env keys
+    if "keys" in env_config and "RADSIM_ACCESS_CODE" in env_config["keys"]:
+        return env_config["keys"]["RADSIM_ACCESS_CODE"]
+
+    # Fall back to system environment
+    return os.getenv("RADSIM_ACCESS_CODE")
+
+
+def is_access_protected() -> bool:
+    """Check if access code protection is enabled."""
+    code = get_access_code_from_env()
+    return bool(code and code.strip())
+
+
+def verify_access_code(user_input: str) -> bool:
+    """Verify access code without logging.
+
+    SECURITY: This function never logs the input or stored code.
+    Returns True if code matches, False otherwise.
+    """
+    stored_code = get_access_code_from_env()
+
+    if not stored_code:
+        return True  # No code configured = no protection
+
+    return _secure_compare(user_input.strip(), stored_code.strip())
+
+
+def prompt_for_access() -> bool:
+    """Prompt user for access code in interactive mode.
+
+    Uses getpass to hide input from terminal.
+    Never logs or prints the entered code.
+    """
+    if not is_access_protected():
+        return True
+
+    import getpass
+
+    max_attempts = 3
+    for attempt in range(max_attempts):
+        try:
+            code = getpass.getpass("🔐 Enter access code: ")
+            if verify_access_code(code):
+                return True
+            remaining = max_attempts - attempt - 1
+            if remaining > 0:
+                print(f"  ❌ Invalid code. {remaining} attempts remaining.")
+        except (KeyboardInterrupt, EOFError):
+            print("\n  Access cancelled.")
+            return False
+
+    print("  ❌ Access denied.")
+    return False
+
+
+def check_access_on_startup() -> bool:
+    """Verify access code on startup if protection is enabled.
+
+    Call this from CLI before starting the agent.
+    """
+    return prompt_for_access()