flock-core 0.4.0b43__py3-none-any.whl → 0.4.0b44__py3-none-any.whl

flock/webapp/run.py

@@ -1,4 +1,4 @@
-import os  # For environment variable
+# src/flock/webapp/run.py
 import sys
 from collections.abc import Callable, Sequence
 from pathlib import Path
@@ -6,132 +6,208 @@ from typing import TYPE_CHECKING, Any
 
 import uvicorn
 
-from flock.core.api.custom_endpoint import FlockEndpoint
-
+# Import core Flock components
 if TYPE_CHECKING:
-    from flock.core import Flock
+    from flock.core.api.custom_endpoint import FlockEndpoint
+    from flock.core.flock import Flock
 
-# --- Integrated Server Function ---
+# --- Ensure src is in path for imports ---
+current_file_path = Path(__file__).resolve()
+flock_webapp_dir = current_file_path.parent
+flock_dir = flock_webapp_dir.parent
+src_dir = flock_dir.parent # Assuming `flock` is a package within `src`
 
+if str(src_dir) not in sys.path:
+    sys.path.insert(0, str(src_dir))
 
-def start_integrated_server(
+# --- Main Server Startup Function ---
+def start_unified_server(
     flock_instance: "Flock",
     host: str,
     port: int,
-    server_name: str,  # Currently unused as UI sets its own title
-    theme_name: str | None = None,
-    custom_endpoints: Sequence[FlockEndpoint] | dict[tuple[str, list[str] | None], Callable[..., Any]] | None = None,
+    server_title: str,
+    enable_ui_routes: bool,
+    enable_chat_routes: bool = False,
+    ui_theme: str | None = None,
+    custom_endpoints: Sequence["FlockEndpoint"] | dict[tuple[str, list[str] | None], Callable[..., Any]] | None = None,
 ):
-    """Starts the webapp, preloads flock & theme, includes API routes (TODO)."""
-    print(
-        f"Starting integrated server for Flock '{flock_instance.name}' on {host}:{port}"
-    )
+    """Starts the unified FastAPI server for Flock.
+    - Initializes the web application (imported from webapp.app.main).
+    - Sets the provided Flock instance and a RunStore for dependency injection
+      and makes them available via app.state.
+    - Configures the UI theme.
+    - Stores custom API endpoints for registration during app lifespan startup.
+    - Optionally registers chat routes.
+    - Runs Uvicorn.
+    """
+    print(f"Attempting to start unified server for Flock '{flock_instance.name}' on http://{host}:{port}")
+    print(f"UI Routes Enabled: {enable_ui_routes}, Theme: {ui_theme or 'Default'}")
+
     try:
-        # Ensure src is in path (important if called from core)
-        src_dir = Path(__file__).resolve().parent.parent
-        if str(src_dir) not in sys.path:
-            sys.path.insert(0, str(src_dir))
-
-        # Import necessary webapp components *after* path setup
-        from flock.core.api.endpoints import (
-            create_api_router,  # Need to adapt this later
-        )
-        from flock.core.api.main import FlockAPI
-        from flock.core.api.run_store import (
-            RunStore,  # Needed for API routes later
-        )
-        from flock.webapp.app.config import (
+        # Import necessary webapp components HERE, after path setup.
+        from flock.core.api.run_store import RunStore
+        from flock.core.logging.logging import get_logger  # For logging
+        from flock.webapp.app.config import (  # For logging resolved theme
             get_current_theme_name,
             set_current_theme_name,
         )
-        from flock.webapp.app.main import app as webapp_fastapi_app
-        from flock.webapp.app.services.flock_service import (
-            set_current_flock_instance_programmatically,
+        from flock.webapp.app.dependencies import (
+            add_pending_custom_endpoints,
+            set_global_flock_services,
         )
-
-        # 1. Set Theme (use provided or default)
-        set_current_theme_name(
-            theme_name
-        )  # Uses default from config if theme_name is None
-        print(f"Integrated server using theme: {get_current_theme_name()}")
-
-        # 2. Set Flock Instance
-        set_current_flock_instance_programmatically(
-            flock_instance,
-            f"{flock_instance.name.replace(' ', '_').lower()}_integrated.flock",
+        from flock.webapp.app.main import (
+            app as fastapi_app,  # The single FastAPI app instance
         )
-        print(f"Flock '{flock_instance.name}' preloaded.")
-
-        flock_api = FlockAPI(flock_instance, custom_endpoints)
-        webapp_fastapi_app.include_router(flock_api.app.router, prefix="/api")
-        print("API routes included.")
 
-        # 4. Run Uvicorn - STILL PASSING INSTANCE here because we need to modify it (add routes)
-        #    and set state BEFORE running. Reload won't work well here.
+        logger = get_logger("webapp.run") # Use a logger
+
+        # 1. Set UI Theme globally for the webapp
+        set_current_theme_name(ui_theme)
+        logger.info(f"Unified server configured to use theme: {get_current_theme_name()}")
+
+        # 2. Create RunStore & Set Global Services for Dependency Injection
+        run_store_instance = RunStore()
+        set_global_flock_services(flock_instance, run_store_instance)
+        logger.info("Global Flock instance and RunStore set for dependency injection.")
+
+        # 3. Make Flock instance and filename available on app.state
+        fastapi_app.state.flock_instance = flock_instance
+        source_file_attr = "_source_file_path" # Attribute where Flock might store its load path
+        fastapi_app.state.flock_filename = getattr(flock_instance, source_file_attr, None) or \
+                                           f"{flock_instance.name.replace(' ', '_').lower()}.flock.yaml"
+        fastapi_app.state.run_store = run_store_instance
+        fastapi_app.state.chat_enabled = enable_chat_routes
+
+        logger.info(f"Flock '{flock_instance.name}' (from '{fastapi_app.state.flock_filename}') made available via app.state.")
+
+        # 4. Store Custom Endpoints for registration by the lifespan manager in app.main
+        processed_custom_endpoints = []
+        if custom_endpoints:
+            from flock.core.api.custom_endpoint import (
+                FlockEndpoint,  # Ensure it's imported
+            )
+            if isinstance(custom_endpoints, dict):
+                for (path_val, methods_val), cb_val in custom_endpoints.items():
+                    processed_custom_endpoints.append(
+                        FlockEndpoint(path=path_val, methods=list(methods_val) if methods_val else ["GET"], callback=cb_val)
+                    )
+            else: # Assumed Sequence[FlockEndpoint]
+                processed_custom_endpoints.extend(list(custom_endpoints))
+
+        if processed_custom_endpoints:
+            add_pending_custom_endpoints(processed_custom_endpoints)
+            logger.info(f"{len(processed_custom_endpoints)} custom endpoints stored for registration by app lifespan.")
+
+        # 5. Update FastAPI app title (FastAPI app instance is now imported from main)
+        fastapi_app.title = server_title
+
+        # 5a. Optionally strip UI routes if UI is disabled
+        if not enable_ui_routes:
+            from fastapi.routing import APIRoute
+
+            allowed_tags = {"Flock API Core", "Flock API Custom Endpoints", "Chat"}
+
+            def _route_is_allowed(route: APIRoute) -> bool:  # type: ignore
+                # Keep documentation and non-API utility routes (no tags)
+                if not hasattr(route, "tags") or not route.tags:
+                    return True
+                # Keep if any tag is in the allowed list
+                return any(tag in allowed_tags for tag in route.tags)  # type: ignore
+
+            original_count = len(fastapi_app.router.routes)
+            fastapi_app.router.routes = [r for r in fastapi_app.router.routes if _route_is_allowed(r)]
+
+            # Clear cached OpenAPI schema so FastAPI regenerates it with the reduced route set
+            if hasattr(fastapi_app, "openapi_schema"):
+                fastapi_app.openapi_schema = None  # type: ignore
+
+            logger.info(
+                f"UI disabled: removed {original_count - len(fastapi_app.router.routes)} UI routes. Remaining routes: {len(fastapi_app.router.routes)}"
+            )
+
+        # 5b. Include Chat routes if requested
+        if enable_chat_routes:
+            try:
+                from flock.webapp.app.chat import (
+                    router as chat_router,  # type: ignore
+                )
+                fastapi_app.include_router(chat_router, tags=["Chat"])
+                logger.info("Chat routes enabled and registered.")
+            except Exception as e:
+                logger.error(f"Failed to include chat routes: {e}")
+
+        # 6. Run Uvicorn
+        logger.info(f"Running Uvicorn with application: flock.webapp.app.main:app")
         uvicorn.run(
-            webapp_fastapi_app, host=host, port=port, reload=False
-        )  # Ensure reload=False
+            "flock.webapp.app.main:app",
+            host=host,
+            port=port,
+            reload=False # Critical for programmatically set state like flock_instance
+        )
 
     except ImportError as e:
-        print(
-            f"Error importing components for integrated server: {e}",
-            file=sys.stderr,
-        )
-        print(
-            "Ensure all dependencies are installed and paths are correct.",
-            file=sys.stderr,
-        )
+        # More specific error logging
+        print(f"CRITICAL: Error importing components for unified server: {e}", file=sys.stderr)
+        print(f"Module not found: {e.name}", file=sys.stderr)
+        print("This usually means a problem with sys.path or missing dependencies.", file=sys.stderr)
+        print(f"Current sys.path: {sys.path}", file=sys.stderr)
         sys.exit(1)
     except Exception as e:
-        print(f"Error starting integrated server: {e}", file=sys.stderr)
+        print(f"CRITICAL: Error starting unified server: {e}", file=sys.stderr)
+        # Consider logging the full traceback for easier debugging
+        import traceback
+        traceback.print_exc(file=sys.stderr)
         sys.exit(1)
 
 
-# --- Standalone Webapp Runner (for `flock --web`) ---
+# --- Standalone Webapp Runner (for `flock --web` or direct execution `python -m flock.webapp.run`) ---
+def main():
+    """Runs the Flock web application in standalone mode.
+    In this mode, no specific Flock is pre-loaded by the startup script;
+    the user will load or create one via the UI.
+    The FastAPI app (`webapp.app.main:app`) will initialize with DI services
+    set to None for Flock, and a new RunStore.
+    """
+    print("Starting Flock web application in standalone mode...")
+
+    from flock.core.api.run_store import RunStore
+    from flock.webapp.app.config import (
+        get_current_theme_name,  # To log the theme being used
+    )
+    from flock.webapp.app.dependencies import set_global_flock_services
 
+    # No pre-loaded Flock instance; create a RunStore so API calls can still function
+    standalone_run_store = RunStore()
+    set_global_flock_services(None, standalone_run_store)
 
-def main():
-    """Run the Flock web application standalone."""
-    # Theme is now set via environment variable read by config.py on import
-    # No need to explicitly set it here anymore.
-    print(f"Starting standalone webapp...")
-    # Ensure src is in path
-    src_dir = Path(__file__).resolve().parent.parent
-    if str(src_dir) not in sys.path:
-        sys.path.insert(0, str(src_dir))
+    print(
+        f"Standalone mode: Initialized global services. Flock: None, RunStore: {type(standalone_run_store)}"
+    )
+    print(f"Standalone webapp using theme: {get_current_theme_name()}")
 
+    host = "127.0.0.1"
+    port = 8344
     try:
-        # Determine host, port, and reload settings
-        host = os.environ.get("FLOCK_WEB_HOST", "127.0.0.1")
-        port = int(os.environ.get("FLOCK_WEB_PORT", "8344"))
-        reload = os.environ.get("FLOCK_WEB_RELOAD", "true").lower() == "true"
-        # Use import string for app path
-        app_import_string = "flock.webapp.app.main:app"
-
-        # No need to import app instance here anymore for standalone mode
-        # from flock.webapp.app.main import app as webapp_fastapi_app
-        # from flock.webapp.app.config import get_current_theme_name
-        # print(f"Standalone webapp using theme: {get_current_theme_name()}") # Config now logs this on load
+        import os
 
-        uvicorn.run(
-            app_import_string,  # Use import string for reload capability
-            host=host,
-            port=port,
-            reload=reload,
-        )
-    except ImportError as e:
-        # Catch potential import error during uvicorn startup if path is wrong
-        print(f"Error loading webapp modules via Uvicorn: {e}", file=sys.stderr)
-        print(
-            "Make sure all required packages are installed and src path is correct.",
-            file=sys.stderr,
-        )
-        sys.exit(1)
-    except Exception as e:
-        print(f"Error starting standalone webapp: {e}", file=sys.stderr)
-        sys.exit(1)
+        host = os.environ.get("FLOCK_WEB_HOST", host)
+        port = int(os.environ.get("FLOCK_WEB_PORT", port))
+        webapp_reload = os.environ.get("FLOCK_WEB_RELOAD", "true").lower() == "true"
+    except Exception:
+        webapp_reload = True
+
+    app_import_string = "flock.webapp.app.main:app"
+    print(
+        f"Running Uvicorn: app='{app_import_string}', host='{host}', port={port}, reload={webapp_reload}"
+    )
+
+    uvicorn.run(
+        app_import_string,
+        host=host,
+        port=port,
+        reload=webapp_reload,
+    )
 
 
-# Note: The `if __name__ == "__main__":` block is removed as this module
-# is now primarily meant to be called via `main()` or `start_integrated_server()`
-# The CLI entry point will call `main()` after potentially calling `set_initial_theme()`.
+if __name__ == "__main__":
+    main()

flock/webapp/static/css/chat.css

@@ -0,0 +1,227 @@
+/* --- Enhanced Chat Styles --- */
+body.chat-page {
+    display: block;
+    padding: 0;
+    margin: 0;
+    height: 100vh;
+    width: 100vw;
+    overflow: hidden;
+    background-color: var(--pico-background-color);
+}
+
+#chat-container {
+    /* Allow the chat container to grow to full width on small screens,
+       but cap it at 80% of the viewport on larger displays and
+       center it horizontally. */
+    width: 100%;
+    max-width: 80%;
+    margin: 0 auto;
+    display: flex;
+    flex-direction: column;
+    height: 100vh;
+    background-color: var(--pico-background-color);
+    overflow: hidden;
+}
+
+#chat-log { 
+    flex: 1; 
+    overflow-y: auto; 
+    padding: 1rem 1.5rem; 
+    display: flex;
+    flex-direction: column;
+    min-height: 60vh;
+    gap: 1rem;
+    background-color: rgba(0, 0, 0, 0.05);
+    background-image: 
+        radial-gradient(rgba(255, 255, 255, 0.03) 1px, transparent 1px),
+        radial-gradient(rgba(255, 255, 255, 0.03) 1px, transparent 1px);
+    background-size: 20px 20px;
+    background-position: 0 0, 10px 10px;
+}
+
+.bubble { 
+    position: relative;
+    padding: 0.75rem 1rem; 
+    border-radius: 1.2rem; 
+    max-width: 80%; 
+    margin: 0.25rem 0; 
+    box-shadow: 0 1px 2px rgba(0, 0, 0, 0.1);
+    animation: fadeIn 0.3s ease-out;
+    word-break: break-word;
+    line-height: 1.4;
+}
+
+@keyframes fadeIn {
+    from { opacity: 0; transform: translateY(10px); }
+    to { opacity: 1; transform: translateY(0); }
+}
+
+.bubble.user { 
+    background: var(--pico-primary); 
+    color: var(--pico-button-base-color); 
+    margin-left: auto; 
+    border-bottom-right-radius: 0.3rem;
+    text-align: right;
+}
+
+.bubble.user::after {
+    content: '';
+    position: absolute;
+    bottom: 0;
+    right: -0.5rem;
+    width: 1rem;
+    height: 1rem;
+    background: var(--pico-primary-hover, var(--pico-primary));
+    clip-path: polygon(0 0, 0% 100%, 100% 100%);
+}
+
+.bubble.bot { 
+    background: var(--pico-code-background-color); 
+    color: var(--pico-code-color); 
+    margin-right: auto; 
+    border-bottom-left-radius: 0.3rem;
+}
+
+.bubble.bot::after {
+    content: '';
+    position: absolute;
+    bottom: 0;
+    left: -0.5rem;
+    width: 1rem;
+    height: 1rem;
+    background: var(--pico-code-background-color);
+    clip-path: polygon(100% 0, 0% 100%, 100% 100%);
+}
+
+#chat-container form { 
+    display: flex; 
+    gap: 0.5rem; 
+    margin: 0;
+    padding: 1rem;
+    background-color: var(--pico-card-background-color);
+    border-top: 1px solid var(--pico-muted-border-color);
+}
+
+#chat-container form input[type="text"] { 
+    flex: 1; 
+    border-radius: 2rem;
+    padding-left: 1.25rem;
+    background-color: var(--pico-background-color);
+    border: 1px solid var(--pico-muted-border-color);
+    transition: all 0.2s ease;
+    height: 3rem;
+    font-size: 1rem;
+}
+
+#chat-container form input[type="text"]:focus {
+    border-color: var(--pico-primary);
+    box-shadow: 0 0 0 2px rgba(var(--pico-primary-rgb, 0, 123, 255), 0.25);
+}
+
+#chat-form button { 
+    flex: 0 0 auto; 
+    min-width: auto;
+    width: 150px; /* Wider send button */
+    padding: 0 1rem;
+    border-radius: 2rem;
+    background: var(--pico-primary);
+    color: var(--pico-button-base-color);
+    font-weight: 600;
+    transition: all 0.2s ease;
+    margin-left: 0.5rem;
+    height: 3rem;
+}
+
+#chat-form button:hover {
+    background: var(--pico-primary-hover, var(--pico-primary));
+    transform: translateY(-2px);
+    box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
+}
+
+.chat-header {
+    padding: 1rem 1.5rem;
+    background-color: var(--pico-card-background-color);
+    border-bottom: 1px solid var(--pico-muted-border-color);
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    flex-shrink: 0;
+}
+
+.chat-header h2 {
+    margin: 0;
+    font-size: 1.5rem;
+    color: var(--pico-color);
+}
+
+.chat-header h3 {
+    margin: 0;
+    font-size: 0.9rem;
+    color: var(--pico-muted-color);
+    font-weight: normal;
+}
+
+.chat-timestamp {
+    display: block;
+    font-size: 0.7rem;
+    color: var(--pico-button-base-color);
+    margin-top: 0.25rem;
+    opacity: 0.8;
+}
+
+.chat-footer {
+    padding: 0.5rem 1rem;
+    text-align: center;
+    font-size: 0.8rem;
+    color: var(--pico-muted-color);
+    background-color: var(--pico-card-background-color);
+    border-top: 1px solid var(--pico-muted-border-color);
+    flex-shrink: 0;
+}
+/* --- End Enhanced Chat Styles --- */
+
+/* -------------------------------------------------------------------------
+   Chat container tweaks when embedded in the main UI (non-standalone mode)
+   ------------------------------------------------------------------------- */
+body:not(.chat-page) #chat-container,
+body:not(.chat-page) .chat-container {
+    height: auto;
+    min-height: 60vh;
+    /* share same centering rules */
+    width: 100%;
+    max-width: 80%;
+    margin: 0 auto;
+}
+
+/* Settings form inside chat container should stack vertically */
+.chat-settings-form {
+    display: flex;
+    flex-direction: column;
+    min-height: 60vh;
+    min-width: 100%;
+}
+
+.chat-settings-form label,
+.chat-settings-form input,
+.chat-settings-form select {
+    display: block;
+    width: 100%;
+    margin-bottom: 0.75rem;
+}
+
+.chat-settings-form .grid {
+    display: flex;
+    gap: 0.5rem;
+}
+
+/* Button sizing for Save Settings */
+.chat-settings-form .grid button:first-child {
+    flex: 1 1 auto; /* expand in standalone */
+    width: 50%;
+}
+
+/* In integrated UI (non chat-page) keep natural size */
+body:not(.chat-page) .chat-settings-form .grid button:first-child {
+    flex: 0 0 auto;
+    width: auto;
+}