mcp-souschef 3.2.0__py3-none-any.whl → 3.5.2__py3-none-any.whl

souschef/ui/pages/chef_server_settings.py

@@ -0,0 +1,300 @@
+"""
+Chef Server Settings Page for SousChef UI.
+
+Configure and validate Chef Server connectivity for dynamic inventory and node queries.
+"""
+
+import os
+
+import streamlit as st
+
+from souschef.core.url_validation import validate_user_provided_url
+
+try:
+    import requests
+    from requests.exceptions import (
+        ConnectionError,  # noqa: A004
+        Timeout,
+    )
+except ImportError:
+    requests = None  # type: ignore[assignment]
+    ConnectionError = Exception  # type: ignore[assignment,misc]  # noqa: A001
+    Timeout = Exception  # type: ignore[assignment,misc]
+
+
+def _handle_chef_server_response(
+    response: "requests.Response", server_url: str
+) -> tuple[bool, str]:
+    """
+    Handle Chef Server search response.
+
+    Args:
+        response: HTTP response from Chef Server
+        server_url: The Chef Server URL that was queried
+
+    Returns:
+        Tuple of (success: bool, message: str)
+
+    """
+    if response.status_code == 200:
+        return True, f"✅ Successfully connected to Chef Server at {server_url}"
+    if response.status_code == 401:
+        return (
+            False,
+            "❌ Authentication failed - check your Chef Server credentials",
+        )
+    if response.status_code == 404:
+        return False, "❌ Chef Server search endpoint not found"
+    return (
+        False,
+        f"❌ Connection failed with status code {response.status_code}",
+    )
+
+
+def _validate_chef_server_connection(
+    server_url: str, node_name: str
+) -> tuple[bool, str]:
+    """
+    Validate Chef Server connection by testing the search endpoint.
+
+    Args:
+        server_url: Base URL of the Chef Server
+        node_name: Chef node name for authentication
+
+    Returns:
+        Tuple of (success: bool, message: str)
+
+    """
+    if not requests:
+        return False, "requests library not installed"
+
+    if not server_url:
+        return False, "Server URL is required"
+
+    try:
+        server_url = validate_user_provided_url(server_url)
+    except ValueError as exc:
+        return False, f"Invalid server URL: {exc}"
+
+    if not node_name:
+        return False, "Node name is required for authentication"
+
+    # Test the search endpoint
+    try:
+        search_url = f"{server_url.rstrip('/')}/search/node"
+        response = requests.get(
+            search_url,
+            params={"q": "*:*"},
+            timeout=5,
+            headers={"Accept": "application/json"},
+        )
+        return _handle_chef_server_response(response, server_url)
+
+    except Timeout:
+        return False, f"❌ Connection timeout - could not reach {server_url}"
+    except ConnectionError:
+        return False, f"❌ Connection error - Chef Server not reachable at {server_url}"
+    except Exception as e:
+        return False, f"❌ Unexpected error: {e}"
+
+
+def _render_chef_server_configuration() -> tuple[str, str]:
+    """
+    Render Chef Server configuration UI and return config values.
+
+    Returns:
+        Tuple of (server_url, node_name)
+
+    """
+    st.subheader("Chef Server Configuration")
+
+    st.markdown("""
+    Configure your Chef Server connection for dynamic inventory generation
+    and node queries. This allows SousChef to retrieve live node data from
+    your Chef infrastructure.
+    """)
+
+    col1, col2 = st.columns(2)
+
+    with col1:
+        server_url = st.text_input(
+            "Chef Server URL",
+            help="Full URL of your Chef Server (e.g., https://chef.example.com)",
+            key="chef_server_url_input",
+            placeholder="https://chef.example.com",
+            value=os.environ.get("CHEF_SERVER_URL", ""),
+        )
+
+    with col2:
+        node_name = st.text_input(
+            "Chef Node Name",
+            help="Node name for authentication with Chef Server",
+            key="chef_node_name_input",
+            placeholder="my-node",
+            value=os.environ.get("CHEF_NODE_NAME", ""),
+        )
+
+    return server_url, node_name
+
+
+def _render_test_connection_button(server_url: str, node_name: str) -> None:
+    """
+    Render the test connection button and display results.
+
+    Args:
+        server_url: Chef Server URL to test
+        node_name: Chef node name for authentication
+
+    """
+    st.markdown("---")
+    st.subheader("Test Connection")
+
+    col1, col2 = st.columns([1, 3])
+
+    with col1:
+        test_button = st.button(
+            "Test Chef Server Connection",
+            type="primary",
+            help="Verify connectivity to Chef Server",
+        )
+
+    if test_button:
+        with col2, st.spinner("Testing Chef Server connection..."):
+            success, message = _validate_chef_server_connection(server_url, node_name)
+
+            if success:
+                st.success(message)
+            else:
+                st.error(message)
+
+
+def _render_usage_examples() -> None:
+    """Render usage examples for Chef Server integration."""
+    st.markdown("---")
+    st.subheader("Usage Examples")
+
+    with st.expander("Dynamic Inventory from Chef Searches"):
+        st.markdown("""
+        Once configured, SousChef can query your Chef Server to generate dynamic
+        Ansible inventories based on Chef node searches:
+
+        ```python
+        # Example Chef search query
+        search_query = "role:webserver AND chef_environment:production"
+
+        # SousChef will convert this to an Ansible dynamic inventory
+        # that queries your Chef Server in real-time
+        ```
+
+        Benefits:
+        - Real-time node discovery
+        - No manual inventory maintenance
+        - Leverage existing Chef infrastructure
+        - Seamless migration path
+        """)
+
+    with st.expander("Environment Variables"):
+        st.markdown("""
+        You can also configure Chef Server settings via environment variables:
+
+        ```bash
+        export CHEF_SERVER_URL="https://chef.example.com"
+        export CHEF_NODE_NAME="my-node"
+        ```
+
+        These will be automatically detected by SousChef.
+        """)
+
+
+def _render_save_settings_section(server_url: str, node_name: str) -> None:
+    """
+    Render the save settings section.
+
+    Args:
+        server_url: Chef Server URL to save
+        node_name: Chef node name to save
+
+    """
+    st.markdown("---")
+    st.subheader("Save Settings")
+
+    col1, col2 = st.columns([1, 3])
+
+    with col1:
+        save_button = st.button(
+            "Save Configuration",
+            type="primary",
+            help="Save Chef Server settings to session",
+        )
+
+    if save_button:
+        with col2:
+            # Save to session state
+            st.session_state.chef_server_url = server_url
+            st.session_state.chef_node_name = node_name
+
+            st.success("""
+            ✅ Chef Server configuration saved to session!
+
+            **Note:** For persistent configuration across sessions,
+            set environment variables:
+            - `CHEF_SERVER_URL`
+            - `CHEF_NODE_NAME`
+            """)
+
+
+def _render_current_configuration() -> None:
+    """Display current Chef Server configuration from environment or session."""
+    current_url = os.environ.get("CHEF_SERVER_URL") or st.session_state.get(
+        "chef_server_url", "Not configured"
+    )
+    current_node = os.environ.get("CHEF_NODE_NAME") or st.session_state.get(
+        "chef_node_name", "Not configured"
+    )
+
+    st.info(f"""
+    **Current Configuration:**
+    - Server URL: `{current_url}`
+    - Node Name: `{current_node}`
+    """)
+
+
+def show_chef_server_settings_page() -> None:
+    """Display Chef Server settings and configuration page."""
+    st.title("🔧 Chef Server Settings")
+
+    st.markdown("""
+    Configure your Chef Server connection to enable dynamic inventory generation
+    and live node queries. This allows SousChef to integrate with your existing
+    Chef infrastructure during the migration process.
+    """)
+
+    # Display current configuration
+    _render_current_configuration()
+
+    st.markdown("---")
+
+    # Configuration inputs
+    server_url, node_name = _render_chef_server_configuration()
+
+    # Test connection
+    _render_test_connection_button(server_url, node_name)
+
+    # Save settings
+    _render_save_settings_section(server_url, node_name)
+
+    # Usage examples
+    _render_usage_examples()
+
+    # Additional information
+    st.markdown("---")
+    st.markdown("""
+    ### Security Note
+
+    Chef Server authentication typically requires:
+    - Client key file for API authentication
+    - Proper permissions on the Chef Server
+
+    For production use, ensure your Chef Server credentials are properly secured
+    and not committed to version control.
+    """)

souschef/ui/pages/cookbook_analysis.py

@@ -522,6 +522,9 @@ def _extract_tar_securely(
             # Use 'data' filter to prevent extraction of special files and symlinks
             open_kwargs["filter"] = "data"
 
+        # Resource consumption controls (S5042): Pre-scan validates all members for
+        # size limits (MAX_ARCHIVE_SIZE, MAX_FILE_SIZE), file count (MAX_FILES),
+        # depth (MAX_DEPTH), and blocks malicious files before extraction.
         with tarfile.open(**open_kwargs) as tar_ref:
             members = tar_ref.getmembers()
             # Pre-validate all members before allowing extraction
@@ -665,6 +668,11 @@ def create_results_archive(results: list, cookbook_path: str) -> bytes:
         # Add individual cookbook reports
         for result in results:
             if result["status"] == ANALYSIS_STATUS_ANALYSED:
+                manual_hours = result["estimated_hours"]
+                souschef_hours = result.get(
+                    "estimated_hours_with_souschef", manual_hours * 0.5
+                )
+                time_saved = manual_hours - souschef_hours
                 report_content = f"""# Cookbook Analysis Report: {result["name"]}
 
 ## Metadata
@@ -672,7 +680,14 @@ def create_results_archive(results: list, cookbook_path: str) -> bytes:
 - **Maintainer**: {result["maintainer"]}
 - **Dependencies**: {result["dependencies"]}
 - **Complexity**: {result["complexity"]}
-- **Estimated Hours**: {result["estimated_hours"]:.1f}
+
+## Effort Estimates
+### Manual Migration (Without SousChef):
+- **Estimated Hours**: {manual_hours:.1f}
+
+### AI-Assisted (With SousChef):
+- **Estimated Hours**: {souschef_hours:.1f}
+- **Time Saved**: {time_saved:.1f} hours (50% faster)
 
 ## Recommendations
 {result["recommendations"]}
@@ -686,16 +701,27 @@ def create_results_archive(results: list, cookbook_path: str) -> bytes:
         successful = len(
             [r for r in results if r["status"] == ANALYSIS_STATUS_ANALYSED]
         )
-        total_hours = sum(r.get("estimated_hours", 0) for r in results)
+        total_hours_manual = sum(r.get("estimated_hours", 0) for r in results)
+        total_hours_souschef = sum(
+            r.get("estimated_hours_with_souschef", r.get("estimated_hours", 0) * 0.5)
+            for r in results
+        )
+        time_saved_total = total_hours_manual - total_hours_souschef
 
         summary_content = f"""# SousChef Cookbook Analysis Summary
 
 ## Overview
 - **Cookbooks Analysed**: {len(results)}
-
 - **Successfully Analysed**: {successful}
 
-- **Total Estimated Hours**: {total_hours:.1f}
+## Effort Estimates
+### Manual Migration (Without AI):
+- **Total Estimated Hours**: {total_hours_manual:.1f}
+
+### AI-Assisted (With SousChef):
+- **Total Estimated Hours**: {total_hours_souschef:.1f}
+- **Time Saved**: {time_saved_total:.1f} hours (50% faster)
+
 - **Source**: {cookbook_path}  # deepcode ignore PT: used for display only
 
 ## Results Summary
@@ -704,10 +730,15 @@ def create_results_archive(results: list, cookbook_path: str) -> bytes:
             status_icon = (
                 "PASS" if result["status"] == ANALYSIS_STATUS_ANALYSED else "FAIL"
             )
+            manual_hours = result.get("estimated_hours", 0)
+            souschef_hours = result.get(
+                "estimated_hours_with_souschef", manual_hours * 0.5
+            )
             summary_content += f"- {status_icon} {result['name']}: {result['status']}"
             if result["status"] == ANALYSIS_STATUS_ANALYSED:
                 summary_content += (
-                    f" ({result['estimated_hours']:.1f} hours, "
+                    f" (Manual: {manual_hours:.1f}h, "
+                    f"With SousChef: {souschef_hours:.1f}h, "
                     f"{result['complexity']} complexity)"
                 )
             summary_content += "\n"
@@ -1415,6 +1446,9 @@ def _build_assessment_result(
         "dependencies": int(cookbook_assessment.get("dependencies", 0) or 0),
         "complexity": cookbook_assessment.get("migration_priority", "Unknown").title(),
         "estimated_hours": effort_metrics.estimated_hours,
+        "estimated_hours_with_souschef": effort_metrics.estimated_hours_with_souschef,
+        "time_saved_hours": effort_metrics.time_saved * 8,
+        "efficiency_gain_percent": effort_metrics.efficiency_gain_percent,
         "recommendations": recommendations,
         "status": ANALYSIS_STATUS_ANALYSED,
     }
@@ -3404,8 +3438,18 @@ def _display_analysis_summary(results, total_cookbooks):
         st.metric("Successfully Analysed", f"{successful}/{total_cookbooks}")
 
     with col2:
-        total_hours = sum(r.get("estimated_hours", 0) for r in results)
-        st.metric("Total Estimated Hours", f"{total_hours:.1f}")
+        total_hours_manual = sum(r.get("estimated_hours", 0) for r in results)
+        total_hours_souschef = sum(
+            r.get("estimated_hours_with_souschef", r.get("estimated_hours", 0) * 0.5)
+            for r in results
+        )
+        time_saved = total_hours_manual - total_hours_souschef
+        st.metric(
+            "Manual Effort (hrs)",
+            f"{total_hours_manual:.1f}",
+            delta=f"With AI: {total_hours_souschef:.1f}h (save {time_saved:.1f}h)",
+            delta_color="inverse",
+        )
 
     with col3:
         complexities = [r.get("complexity", "Unknown") for r in results]
@@ -3491,7 +3535,7 @@ def _display_single_cookbook_details(result):
             st.metric("Dependencies", result.get("dependencies", 0))
 
         # Complexity and effort
-        col1, col2 = st.columns(2)
+        col1, col2, col3 = st.columns(3)
         with col1:
             complexity = result.get("complexity", "Unknown")
             if complexity == "High":
@@ -3501,8 +3545,20 @@ def _display_single_cookbook_details(result):
             else:
                 st.metric("Complexity", complexity, delta="Low")
         with col2:
-            hours = result.get("estimated_hours", 0)
-            st.metric("Estimated Hours", f"{hours:.1f}")
+            hours_manual = result.get("estimated_hours", 0)
+            st.metric("Manual Effort (hrs)", f"{hours_manual:.1f}")
+        with col3:
+            hours_souschef = result.get(
+                "estimated_hours_with_souschef", hours_manual * 0.5
+            )
+            time_saved = hours_manual - hours_souschef
+            savings_pct = int((time_saved / hours_manual) * 100)
+            st.metric(
+                "With SousChef (hrs)",
+                f"{hours_souschef:.1f}",
+                delta=f"Save {time_saved:.1f}h ({savings_pct}%)",
+                delta_color="inverse",
+            )
 
         # Path
         st.write(f"**Cookbook Path:** {result['path']}")