flock-core 0.4.0b35__py3-none-any.whl → 0.4.0b36__py3-none-any.whl

flock/webapp/app/main.py

@@ -1,6 +1,8 @@
 # ... (keep existing imports and app setup) ...
 import json
+import os  # Needed for environment variable helpers
 import shutil
+import sys  # For path
 import urllib.parse
 from pathlib import Path
 
@@ -15,7 +17,15 @@ from flock.webapp.app.api import (
     flock_management,
     registry_viewer,
 )
-from flock.webapp.app.config import FLOCK_FILES_DIR
+
+# Import config functions
+from flock.webapp.app.config import (
+    DEFAULT_THEME_NAME,  # Import default for fallback
+    FLOCK_FILES_DIR,
+    THEMES_DIR,  # Import THEMES_DIR from config
+    get_current_theme_name,
+    # set_current_theme_name, # Not directly used in main.py, but available
+)
 from flock.webapp.app.services.flock_service import (
     clear_current_flock,
     create_new_flock_service,
@@ -25,6 +35,100 @@ from flock.webapp.app.services.flock_service import (
     get_flock_preview_service,
     load_flock_from_file_service,
 )
+from flock.webapp.app.theme_mapper import alacritty_to_pico
+
+# Helper for theme loading
+
+# Find the 'src/flock' directory - This can be removed if THEMES_DIR from config is sufficient
+# flock_base_dir = (
+#     Path(__file__).resolve().parent.parent.parent
+# )  # src/flock/webapp/app -> src/flock
+
+# Calculate themes directory relative to the flock base dir - This can be removed
+# themes_dir = flock_base_dir / "themes"
+
+# Ensure the parent ('src') is in the path for core imports
+# This path manipulation might still be needed if core imports are relative in a specific way
+flock_webapp_dir = Path(__file__).resolve().parent.parent # src/flock/webapp/
+flock_base_dir = flock_webapp_dir.parent # src/flock/
+src_dir = flock_base_dir.parent  # src/
+if str(src_dir) not in sys.path:
+    sys.path.insert(0, str(src_dir))
+
+try:
+    from flock.core.logging.formatters.themed_formatter import (
+        load_theme_from_file,
+    )
+
+    THEME_LOADER_AVAILABLE = True
+    # themes_dir is now imported from config
+except ImportError:
+    print(
+        "Warning: Could not import flock.core theme loading utilities.",
+        file=sys.stderr,
+    )
+    THEME_LOADER_AVAILABLE = False
+    # THEMES_DIR will be None if not imported, or its value from config
+
+# --- Lightweight .env helpers (self-contained, no external deps) ---
+ENV_FILE = ".env"
+SHOW_SECRETS_KEY = "SHOW_SECRETS"
+
+def load_env_file() -> dict[str, str]:
+    env_vars: dict[str, str] = {}
+    if not os.path.exists(ENV_FILE):
+        return env_vars
+    with open(ENV_FILE) as f:
+        lines = f.readlines()
+    for line in lines:
+        line = line.strip()
+        if not line:
+            env_vars[""] = ""
+            continue
+        if line.startswith("#"):
+            env_vars[line] = ""
+            continue
+        if "=" in line:
+            k, v = line.split("=", 1)
+            env_vars[k] = v
+        else:
+            env_vars[line] = ""
+    return env_vars
+
+def save_env_file(env_vars: dict[str, str]):
+    try:
+        with open(ENV_FILE, "w") as f:
+            for k, v in env_vars.items():
+                if k.startswith("#"):
+                    f.write(f"{k}\n")
+                elif not k:
+                    f.write("\n")
+                else:
+                    f.write(f"{k}={v}\n")
+    except Exception as e:
+        print(f"[Settings] Failed to save .env: {e}")
+
+def is_sensitive(key: str) -> bool:
+    patterns = ["key", "token", "secret", "password", "api", "pat"]
+    low = key.lower()
+    return any(p in low for p in patterns)
+
+def mask_sensitive_value(value: str) -> str:
+    if not value:
+        return value
+    if len(value) <= 4:
+        return "••••"
+    return value[:2] + "•" * (len(value) - 4) + value[-2:]
+
+def get_show_secrets_setting(env_vars: dict[str, str]) -> bool:
+    return env_vars.get(SHOW_SECRETS_KEY, "false").lower() == "true"
+
+def set_show_secrets_setting(show: bool):
+    env_vars = load_env_file()
+    env_vars[SHOW_SECRETS_KEY] = str(show)
+    save_env_file(env_vars)
+
+# -------------------------------------------------------------------
 
 app = FastAPI(title="Flock UI")
 
@@ -49,12 +153,163 @@ app.include_router(
 )
 
 
+def generate_theme_css(theme_name: str | None) -> str:
+    """Loads a theme TOML and generates CSS variable overrides."""
+    if not THEME_LOADER_AVAILABLE or THEMES_DIR is None: # Use imported THEMES_DIR
+        return ""  # Return empty if theme loading isn't possible
+
+    active_theme_name = theme_name or DEFAULT_THEME_NAME
+    theme_filename = f"{active_theme_name}.toml"
+    theme_path = THEMES_DIR / theme_filename # Use imported THEMES_DIR
+
+    if not theme_path.exists():
+        print(
+            f"Warning: Theme file not found: {theme_path}. Using default theme.",
+            file=sys.stderr,
+        )
+        # Optionally load the default theme file if the requested one isn't found
+        theme_filename = f"{DEFAULT_THEME_NAME}.toml"
+        theme_path = THEMES_DIR / theme_filename
+        if not theme_path.exists():
+            print(
+                f"Warning: Default theme file not found: {theme_path}. No theme CSS generated.",
+                file=sys.stderr,
+            )
+            return ""  # Return empty if even default isn't found
+        active_theme_name = (
+            DEFAULT_THEME_NAME  # Update active name if defaulted
+        )
+
+    try:
+        theme_dict = load_theme_from_file(str(theme_path))
+    except Exception as e:
+        print(f"Error loading theme file {theme_path}: {e}", file=sys.stderr)
+        return ""  # Return empty on error
+
+    # --- Define TOML Color -> CSS Variable Mapping ---
+    # This mapping is crucial and may need adjustment based on theme intent & Pico usage
+    css_vars = {}
+    try:
+        # Basic Colors
+        # Base colors
+        css_vars["--pico-background-color"] = theme_dict["colors"]["primary"].get("background")  # Main background
+        css_vars["--pico-color"] = theme_dict["colors"]["primary"].get("foreground")  # Main text
+
+        # Headings
+        css_vars["--pico-h1-color"] = theme_dict["colors"]["selection"].get("text")  # Primary heading
+        css_vars["--pico-h2-color"] = theme_dict["colors"]["selection"].get("text")  # Secondary heading
+        css_vars["--pico-h3-color"] = theme_dict["colors"]["primary"].get("foreground")  # Body heading
+        css_vars["--pico-muted-color"] = theme_dict["colors"]["selection"].get("text")  # Muted/subtext
+        css_vars["--pico-primary-inverse"] = theme_dict["colors"]["cursor"].get("text")  # Contrast on primary
+        css_vars["--pico-contrast"] = theme_dict["colors"]["primary"].get("background")  # Contrast text on dark
+        css_vars["--pico-contrast-inverse"] = theme_dict["colors"]["primary"].get("foreground")  # Contrast text on dark
+
+        # Primary interaction
+        css_vars["--pico-primary"] = theme_dict["colors"]["normal"].get("blue")
+        css_vars["--pico-primary-hover"] = theme_dict["colors"]["bright"].get("blue")
+        css_vars["--pico-primary-focus"] = f"rgba({theme_dict['colors']['bright'].get('blue')}, 0.25)"
+        css_vars["--pico-primary-active"] = theme_dict["colors"]["normal"].get("blue")
+
+
+
+        # Secondary interaction
+        css_vars["--pico-secondary"] = theme_dict["colors"]["normal"].get("magenta")
+        css_vars["--pico-secondary-hover"] = theme_dict["colors"]["bright"].get("magenta")
+        css_vars["--pico-secondary-focus"] = f"rgba({theme_dict['colors']['bright'].get('magenta')}, 0.25)"
+        css_vars["--pico-secondary-active"] = theme_dict["colors"]["normal"].get("magenta")
+
+        # Cards and containers
+        css_vars["--pico-card-background-color"] = theme_dict["colors"]["primary"].get("background")
+        css_vars["--pico-card-border-color"] = theme_dict["colors"]["bright"].get("black")  # Mid-tone, visible on bright bg
+        css_vars["--pico-card-sectioning-background-color"] = theme_dict["colors"]["selection"].get("background")  # Subtle contrast
+        css_vars["--pico-border-color"] = theme_dict["colors"]["bright"].get("black")
+        css_vars["--pico-muted-border-color"] = theme_dict["colors"]["normal"].get("black")  # More subtle than main border
+
+        # Forms
+        css_vars["--pico-form-element-background-color"] = theme_dict["colors"]["primary"].get("background")
+        css_vars["--pico-form-element-border-color"] = theme_dict["colors"]["bright"].get("black")
+        css_vars["--pico-form-element-color"] = theme_dict["colors"]["primary"].get("foreground")
+        css_vars["--pico-form-element-focus-color"] = theme_dict["colors"]["bright"].get("blue")
+        css_vars["--pico-form-element-placeholder-color"] = theme_dict["colors"]["bright"].get("black")
+        css_vars["--pico-form-element-active-border-color"] = theme_dict["colors"]["bright"].get("blue")
+        css_vars["--pico-form-element-active-background-color"] = theme_dict["colors"]["selection"].get("background")
+        css_vars["--pico-form-element-disabled-background-color"] = theme_dict["colors"]["normal"].get("black")
+        css_vars["--pico-form-element-disabled-border-color"] = theme_dict["colors"]["bright"].get("black")
+        css_vars["--pico-form-element-invalid-border-color"] = theme_dict["colors"]["normal"].get("red")
+        css_vars["--pico-form-element-invalid-focus-color"] = theme_dict["colors"]["bright"].get("red")
+
+        # Buttons
+        css_vars["--pico-button-base-background-color"] = theme_dict["colors"]["primary"].get("background")
+        css_vars["--pico-button-base-color"] = theme_dict["colors"]["primary"].get("foreground")
+        css_vars["--pico-button-hover-background-color"] = theme_dict["colors"]["selection"].get("background")
+        css_vars["--pico-button-hover-color"] = theme_dict["colors"]["selection"].get("text")
+
+        # Code blocks
+        css_vars["--pico-code-background-color"] = theme_dict["colors"]["cursor"].get("text")  # Background behind code
+        css_vars["--pico-code-color"] = theme_dict["colors"]["primary"].get("foreground")  # Code text
+        css_vars["--pico-code-kbd-background-color"] = theme_dict["colors"]["selection"].get("background")
+        css_vars["--pico-code-kbd-color"] = theme_dict["colors"]["selection"].get("text")
+        css_vars["--pico-code-tag-color"] = theme_dict["colors"]["normal"].get("blue")  # Tag elements
+        css_vars["--pico-code-property-color"] = theme_dict["colors"]["normal"].get("green")  # CSS property names
+        css_vars["--pico-code-value-color"] = theme_dict["colors"]["normal"].get("red")  # Values and literals
+        css_vars["--pico-code-comment-color"] = theme_dict["colors"]["bright"].get("black")  # Dim comment color
+
+
+        # Semantic markup
+        css_vars["--pico-mark-background-color"] = theme_dict["colors"]["normal"].get("yellow") + "33"
+        css_vars["--pico-mark-color"] = theme_dict["colors"]["primary"].get("foreground")
+        css_vars["--pico-ins-color"] = theme_dict["colors"]["normal"].get("green")
+        css_vars["--pico-del-color"] = theme_dict["colors"]["normal"].get("red")
+# Deleted content - red
+        # Custom flock vars (mapped previously, ensure they are kept)
+        css_vars["--flock-sidebar-background"] = theme_dict["colors"]["primary"].get("background")# css_vars["--pico-card-background-color"] # Example: Link sidebar to card background
+        css_vars["--flock-header-background"] = theme_dict["colors"]["selection"].get("background") # Example: Link header to card background
+        css_vars["--flock-error-color"] = theme_dict["colors"]["normal"].get("red", "#dc3545")
+        css_vars["--flock-success-color"] = theme_dict["colors"]["normal"].get("green", "#28a745")
+
+
+
+        #css_vars.update(pico_vars)
+
+    except KeyError as e:
+        print(
+            f"Warning: Missing expected key in theme '{active_theme_name}': {e}. CSS may be incomplete.",
+            file=sys.stderr,
+        )
+
+    if not css_vars:
+        return ""  # Return empty if no variables were mapped
+
+    pico_vars = alacritty_to_pico(theme_dict)
+    css_rules = [f"    {name}: {value};" for name, value in pico_vars.items()]
+
+    # Apply overrides within the currently active theme selector for better specificity
+    # We could get the theme name passed in, or maybe check the <html> tag attribute?
+    # For simplicity, let's assume we want to override Pico's dark theme vars when a theme is loaded.
+    # A better approach might involve removing data-theme="dark" and applying theme to :root
+    # or having specific data-theme selectors for each flock theme.
+    # Let's try applying to [data-theme="dark"] first.
+    selector = '[data-theme="dark"]'
+    css_string = ":root {\n" + "\n".join(css_rules) + "\n}"
+
+    print(
+        f"--- Generated CSS for theme '{active_theme_name}' ---"
+    )  # Debugging print
+    print(css_string)  # Debugging print
+    print(
+        "----------------------------------------------------"
+    )  # Debugging print
+    return css_string
+
+
 def get_base_context(
     request: Request,
     error: str = None,
     success: str = None,
     ui_mode: str = "standalone",
 ) -> dict:
+    theme_name = get_current_theme_name()  # Get theme from config
+    theme_css = generate_theme_css(theme_name)
     return {
         "request": request,
         "current_flock": get_current_flock_instance(),
@@ -62,6 +317,8 @@ def get_base_context(
         "error_message": error,
         "success_message": success,
         "ui_mode": ui_mode,
+        "theme_css": theme_css,  # Add generated CSS to context
+        "active_theme_name": theme_name, # Added active theme name
     }
 
 
@@ -226,6 +483,21 @@ async def htmx_get_sidebar(
     )
 
 
+@app.get("/ui/htmx/header-flock-status", response_class=HTMLResponse)
+async def htmx_get_header_flock_status(
+    request: Request, ui_mode: str = Query("standalone")
+):
+    # ui_mode isn't strictly needed for this partial's content, but good to accept if passed by hx-get
+    return templates.TemplateResponse(
+        "partials/_header_flock_status.html",
+        {
+            "request": request,
+            "current_flock": get_current_flock_instance(),
+            "current_filename": get_current_flock_filename(),
+        },
+    )
+
+
 @app.get("/ui/htmx/load-flock-view", response_class=HTMLResponse)
 async def htmx_get_load_flock_view(
     request: Request,
@@ -237,7 +509,7 @@ async def htmx_get_load_flock_view(
     # This view is part of the "standalone" functionality.
     # If somehow accessed in scoped mode, it might be confusing, but let it render.
     return templates.TemplateResponse(
-        "partials/_load_manage_view.html",
+        "partials/_load_manager_view.html",
         {
             "request": request,
             "error_message": error,
@@ -459,7 +731,7 @@ async def ui_load_flock_by_name_action(
             {"notify": {"type": "error", "message": error_message}}
         )
         return templates.TemplateResponse(
-            "partials/_load_manage_view.html",
+            "partials/_load_manager_view.html",
             {"request": request, "error_message_inline": error_message},
             headers=response_headers,
         )
@@ -569,3 +841,234 @@ async def ui_create_flock_action(
         },
         headers=response_headers,
     )
+
+
+# --- Settings Page ---
+@app.get("/ui/settings", response_class=HTMLResponse)
+async def page_settings(
+    request: Request,
+    error: str = None,
+    success: str = None,
+    ui_mode: str = Query("standalone"),
+):
+    """Render the Settings top-level page which in turn loads the HTMX settings view."""
+    context = get_base_context(request, error, success, ui_mode)
+    context["initial_content_url"] = "/ui/htmx/settings-view"
+    return templates.TemplateResponse("base.html", context)
+
+
+# Helper to build env var list for templates
+
+def _prepare_env_vars_for_template():
+    env_vars_raw = load_env_file()
+    show_secrets = get_show_secrets_setting(env_vars_raw)
+    env_vars_list = []
+    for name, value in env_vars_raw.items():
+        if name.startswith("#") or name == "":
+            # skip comments/blank for table
+            continue
+        display_value = (
+            value
+            if (not is_sensitive(name) or show_secrets)
+            else mask_sensitive_value(value)
+        )
+        env_vars_list.append({"name": name, "value": display_value})
+    return env_vars_list, show_secrets
+
+
+@app.get("/ui/htmx/settings-view", response_class=HTMLResponse)
+async def htmx_get_settings_view(request: Request):
+    """Return the settings composite view (env vars + theme switcher)."""
+    env_vars_list, show_secrets = _prepare_env_vars_for_template()
+    theme_name = get_current_theme_name()
+    themes_available = []
+    if THEMES_DIR and THEMES_DIR.exists():
+        themes_available = [p.stem for p in THEMES_DIR.glob("*.toml")]
+    return templates.TemplateResponse(
+        "partials/_settings_view.html",
+        {
+            "request": request,
+            "env_vars": env_vars_list,
+            "show_secrets": show_secrets,
+            "themes": themes_available,
+            "current_theme": theme_name,
+        },
+    )
+
+
+# --- Env Var Manager Endpoints ---
+@app.post("/ui/htmx/toggle-show-secrets", response_class=HTMLResponse)
+async def htmx_toggle_show_secrets(request: Request):
+    # Toggle and return updated table
+    env_vars_raw = load_env_file()
+    current = get_show_secrets_setting(env_vars_raw)
+    set_show_secrets_setting(not current)
+    env_vars_list, show_secrets = _prepare_env_vars_for_template()
+    return templates.TemplateResponse(
+        "partials/_env_vars_table.html",
+        {
+            "request": request,
+            "env_vars": env_vars_list,
+            "show_secrets": show_secrets,
+        },
+    )
+
+
+@app.post("/ui/htmx/env-delete", response_class=HTMLResponse)
+async def htmx_env_delete(request: Request, var_name: str = Form(...)):
+    env_vars_raw = load_env_file()
+    if var_name in env_vars_raw:
+        del env_vars_raw[var_name]
+        save_env_file(env_vars_raw)
+    env_vars_list, show_secrets = _prepare_env_vars_for_template()
+    return templates.TemplateResponse(
+        "partials/_env_vars_table.html",
+        {
+            "request": request,
+            "env_vars": env_vars_list,
+            "show_secrets": show_secrets,
+        },
+    )
+
+
+@app.post("/ui/htmx/env-edit", response_class=HTMLResponse)
+async def htmx_env_edit(
+    request: Request,
+    var_name: str = Form(...),
+):
+    # New value is provided via HX-Prompt header
+    new_value = request.headers.get("HX-Prompt")
+    if new_value is None:
+        # Nothing entered; just return current table
+        env_vars_list, show_secrets = _prepare_env_vars_for_template()
+        return templates.TemplateResponse(
+            "partials/_env_vars_table.html",
+            {
+                "request": request,
+                "env_vars": env_vars_list,
+                "show_secrets": show_secrets,
+            },
+        )
+    env_vars_raw = load_env_file()
+    env_vars_raw[var_name] = new_value
+    save_env_file(env_vars_raw)
+    env_vars_list, show_secrets = _prepare_env_vars_for_template()
+    return templates.TemplateResponse(
+        "partials/_env_vars_table.html",
+        {
+            "request": request,
+            "env_vars": env_vars_list,
+            "show_secrets": show_secrets,
+        },
+    )
+
+
+@app.get("/ui/htmx/env-add-form", response_class=HTMLResponse)
+async def htmx_env_add_form(request: Request):
+    # Return simple form row at top of table
+    return HTMLResponse(
+        """
+        <form hx-post='/ui/htmx/env-add' hx-target='#env-vars-container' hx-swap='outerHTML' style='display:flex; gap:0.5rem; margin-bottom:0.5rem;'>
+            <input name='var_name' placeholder='NAME' required style='flex:2;'>
+            <input name='var_value' placeholder='VALUE' style='flex:3;'>
+            <button type='submit'>Add</button>
+        </form>
+        """
+    )
+
+
+@app.post("/ui/htmx/env-add", response_class=HTMLResponse)
+async def htmx_env_add(request: Request, var_name: str = Form(...), var_value: str = Form("")):
+    env_vars_raw = load_env_file()
+    env_vars_raw[var_name] = var_value
+    save_env_file(env_vars_raw)
+    env_vars_list, show_secrets = _prepare_env_vars_for_template()
+    return templates.TemplateResponse(
+        "partials/_env_vars_table.html",
+        {
+            "request": request,
+            "env_vars": env_vars_list,
+            "show_secrets": show_secrets,
+        },
+    )
+
+
+# --- Theme Preview and Apply Endpoints ---
+@app.get("/ui/htmx/theme-preview", response_class=HTMLResponse)
+async def htmx_theme_preview(request: Request, theme: str = Query(None)):
+    theme_name = theme or get_current_theme_name()
+    # Load theme data
+    try:
+        theme_path = THEMES_DIR / f"{theme_name}.toml" if THEMES_DIR else None
+        if not (theme_path and theme_path.exists()):
+            return HTMLResponse("<p>Theme not found.</p>")
+        from flock.core.logging.formatters.themed_formatter import (
+            load_theme_from_file,
+        )
+        theme_data = load_theme_from_file(str(theme_path))
+    except Exception as e:
+        return HTMLResponse(f"<p>Error loading theme: {e}</p>")
+
+    css_vars = alacritty_to_pico(theme_data)
+    css_vars_str = ":root {\n" + "\n".join([f"  {k}: {v};" for k, v in css_vars.items()]) + "\n}"
+
+    main_colors = [
+        ("Background", css_vars["--pico-background-color"]),
+        ("Text", css_vars["--pico-color"]),
+        ("Primary", css_vars["--pico-primary"]),
+        ("Secondary", css_vars["--pico-secondary"]),
+        ("Muted", css_vars["--pico-muted-color"]),
+    ]
+
+    return templates.TemplateResponse(
+        "partials/_theme_preview.html",
+        {
+            "request": request,
+            "theme_name": theme_name,
+            "css_vars_str": css_vars_str,
+            "main_colors": main_colors,
+        },
+    )
+
+
+@app.post("/ui/apply-theme")
+async def apply_theme(request: Request, theme: str = Form(...)):
+    try:
+        from flock.webapp.app.config import set_current_theme_name
+
+        set_current_theme_name(theme)
+        # Trigger full refresh via HTMX
+        headers = {"HX-Refresh": "true"}
+        return HTMLResponse("", headers=headers)
+    except Exception as e:
+        return HTMLResponse(f"Failed to apply theme: {e}", status_code=500)
+
+
+# --- Settings Content Endpoints (for tab navigation) ---
+@app.get("/ui/htmx/settings/env-vars", response_class=HTMLResponse)
+async def htmx_settings_env_vars(request: Request):
+    env_vars_list, show_secrets = _prepare_env_vars_for_template()
+    return templates.TemplateResponse(
+        "partials/_settings_env_content.html",
+        {
+            "request": request,
+            "env_vars": env_vars_list,
+            "show_secrets": show_secrets,
+        },
+    )
+
+
+@app.get("/ui/htmx/settings/theme", response_class=HTMLResponse)
+async def htmx_settings_theme(request: Request):
+    theme_name = get_current_theme_name()
+    themes_available = []
+    if THEMES_DIR and THEMES_DIR.exists():
+        themes_available = [p.stem for p in THEMES_DIR.glob("*.toml")]
+    return templates.TemplateResponse(
+        "partials/_settings_theme_content.html",
+        {
+            "request": request,
+            "themes": themes_available,
+            "current_theme": theme_name,
+        },
+    )