flock-core 0.4.540__py3-none-any.whl → 0.4.541__py3-none-any.whl

flock/core/logging/live_capture.py

@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+import io
+import re
+import sys
+import threading
+import time
+from collections import deque
+from typing import Deque, List, Literal, MutableMapping
+
+__all__ = [
+    "enable_live_log_capture",
+    "get_live_log_store",
+    "LiveLogStore",
+]
+
+AnsiSource = Literal["stdout", "stderr"]
+ANSI_ESCAPE_PATTERN = re.compile(r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])")
+
+
+class LiveLogStore:
+    """Thread-safe ring buffer that keeps recent CLI log lines."""
+
+    def __init__(self, max_lines: int = 800) -> None:
+        self._lines: Deque[dict[str, object]] = deque(maxlen=max_lines)
+        self._buffers: MutableMapping[AnsiSource, str] = {"stdout": "", "stderr": ""}
+        self._lock = threading.Lock()
+
+    def append_chunk(self, chunk: str, source: AnsiSource) -> None:
+        """Append raw stream data, splitting into sanitized log lines."""
+        if not chunk:
+            return
+        normalized = chunk.replace("\r\n", "\n").replace("\r", "\n")
+        with self._lock:
+            combined = self._buffers[source] + normalized
+            parts = combined.split("\n")
+            if combined.endswith("\n"):
+                complete, remainder = parts[:-1], ""
+            else:
+                complete, remainder = parts[:-1], parts[-1]
+            self._buffers[source] = remainder
+
+            timestamp = time.time()
+            for raw_line in complete:
+                cleaned = ANSI_ESCAPE_PATTERN.sub("", raw_line).rstrip("\r")
+                # Preserve deliberate blank lines but normalise whitespace-only strings
+                if cleaned and cleaned.strip() == "":
+                    cleaned = ""
+                self._lines.append(
+                    {
+                        "timestamp": timestamp,
+                        "stream": source,
+                        "text": cleaned,
+                    }
+                )
+                timestamp += 1e-6  # keep ordering stable for same chunk
+
+    def get_entries(self, *, limit: int | None = None) -> List[dict[str, object]]:
+        """Return a copy of the most recent log entries (oldest first)."""
+        with self._lock:
+            snapshot = list(self._lines)
+        if limit is None:
+            return snapshot
+        if limit <= 0:
+            return []
+        return snapshot[-limit:]
+
+    def clear(self) -> None:
+        """Clear buffered log lines and pending chunks."""
+        with self._lock:
+            self._lines.clear()
+            self._buffers = {"stdout": "", "stderr": ""}
+
+
+class _TeeStream(io.TextIOBase):
+    """Duplicate writes to the original stream and the live log store."""
+
+    def __init__(self, wrapped: io.TextIOBase, source: AnsiSource, store: LiveLogStore) -> None:
+        self._wrapped = wrapped
+        self._source = source
+        self._store = store
+
+    def write(self, data: str) -> int:  # type: ignore[override]
+        self._store.append_chunk(data, self._source)
+        return self._wrapped.write(data)
+
+    def flush(self) -> None:  # type: ignore[override]
+        self._wrapped.flush()
+
+    def isatty(self) -> bool:  # type: ignore[override]
+        return self._wrapped.isatty()
+
+    def fileno(self) -> int:  # type: ignore[override]
+        return self._wrapped.fileno()
+
+    def readable(self) -> bool:  # type: ignore[override]
+        return False
+
+    def writable(self) -> bool:  # type: ignore[override]
+        return True
+
+    def seekable(self) -> bool:  # type: ignore[override]
+        return False
+
+    def close(self) -> None:  # type: ignore[override]
+        self._wrapped.close()
+
+    @property
+    def closed(self) -> bool:  # type: ignore[override]
+        return self._wrapped.closed
+
+    @property
+    def encoding(self) -> str | None:  # type: ignore[override]
+        return getattr(self._wrapped, "encoding", None)
+
+    def __getattr__(self, item: str):
+        return getattr(self._wrapped, item)
+
+
+_live_log_store = LiveLogStore()
+_capture_enabled = False
+
+
+def enable_live_log_capture() -> None:
+    """Wrap stdout/stderr so CLI output is mirrored into the live log store."""
+    global _capture_enabled
+    if _capture_enabled:
+        return
+
+    sys.stdout = _TeeStream(sys.stdout, "stdout", _live_log_store)
+    sys.stderr = _TeeStream(sys.stderr, "stderr", _live_log_store)
+    _capture_enabled = True
+
+
+def get_live_log_store() -> LiveLogStore:
+    """Expose the singleton live log store for dependency injection."""
+    return _live_log_store

flock/webapp/app/api/agent_management.py

@@ -49,8 +49,7 @@ async def htmx_get_agent_list(
         # For a partial, returning an error or empty state is reasonable.
         return HTMLResponse("<div id='agent-list-container'><p class='error'>No Flock loaded to display agents.</p></div>", headers={"HX-Retarget": "#agent-list-container", "HX-Reswap": "innerHTML"})
 
-    return templates.TemplateResponse(
-        "partials/_agent_list.html",
+    return templates.TemplateResponse(request, "partials/_agent_list.html",
         {
             "request": request,
             "flock": current_flock, # Pass the injected flock instance
@@ -78,8 +77,7 @@ async def htmx_get_agent_details_form(
         [tool.__name__ for tool in agent.tools] if agent.tools else []
     )
 
-    return templates.TemplateResponse(
-        "partials/_agent_detail_form.html",
+    return templates.TemplateResponse(request, "partials/_agent_detail_form.html",
         {
             "request": request,
             "agent": agent,
@@ -97,8 +95,7 @@ async def htmx_get_new_agent_form(
 ):
     # current_flock is injected, primarily to ensure context if needed by template/tools list
     registered_tools = get_registered_items_service("tool")
-    return templates.TemplateResponse(
-        "partials/_agent_detail_form.html",
+    return templates.TemplateResponse(request, "partials/_agent_detail_form.html",
         {
             "request": request,
             "agent": None,
@@ -123,8 +120,7 @@ async def htmx_create_agent(
     # The service function add_agent_to_current_flock_service now takes app_state
     if (not agent_name.strip() or not input_signature.strip() or not output_signature.strip()):
         registered_tools = get_registered_items_service("tool")
-        return templates.TemplateResponse(
-            "partials/_agent_detail_form.html",
+        return templates.TemplateResponse(request, "partials/_agent_detail_form.html",
             {
                 "request": request, "agent": None, "is_new": True,
                 "error_message": "Name, Input Signature, and Output Signature are required.",
@@ -153,7 +149,7 @@ async def htmx_create_agent(
         "form_message": "Agent created successfully!" if success else "Failed to create agent. Check logs.",
         "success": success,
     }
-    return templates.TemplateResponse("partials/_agent_detail_form.html", new_form_context, headers=response_headers)
+    return templates.TemplateResponse(request, "partials/_agent_detail_form.html", new_form_context, headers=response_headers)
 
 
 @router.put("/htmx/agents/{original_agent_name}", response_class=HTMLResponse)
@@ -196,7 +192,7 @@ async def htmx_update_agent(
         "success": success,
         "registered_tools": registered_tools, "current_tools": current_agent_tools,
     }
-    return templates.TemplateResponse("partials/_agent_detail_form.html", updated_form_context, headers=response_headers)
+    return templates.TemplateResponse(request, "partials/_agent_detail_form.html", updated_form_context, headers=response_headers)
 
 
 @router.delete("/htmx/agents/{agent_name}", response_class=HTMLResponse)
@@ -219,7 +215,7 @@ async def htmx_delete_agent(
             # "form_message": f"Agent '{agent_name}' removed.", # Message handled by notify
             # "success": True, # Not strictly needed if form is cleared
         }
-        return templates.TemplateResponse("partials/_agent_detail_form.html", empty_form_context, headers=response_headers)
+        return templates.TemplateResponse(request, "partials/_agent_detail_form.html", empty_form_context, headers=response_headers)
     else:
         # Deletion failed, re-render the form for the agent that failed to delete (if it still exists)
         flock_instance_from_state: Flock | None = getattr(request.app.state, 'flock_instance', None)
@@ -238,4 +234,4 @@ async def htmx_delete_agent(
         }
         # Trigger a notification for the error as well
         response_headers["HX-Trigger"] = json.dumps({"notify": {"type":"error", "message": f"Failed to remove agent '{agent_name}'."}})
-        return templates.TemplateResponse("partials/_agent_detail_form.html", error_form_context, headers=response_headers)
+        return templates.TemplateResponse(request, "partials/_agent_detail_form.html", error_form_context, headers=response_headers)

flock/webapp/app/api/execution.py

@@ -67,8 +67,7 @@ async def htmx_get_execution_form_content(
     ),  # Use optional if form can show 'no flock'
 ):
     # flock instance is injected
-    return templates.TemplateResponse(
-        "partials/_execution_form.html",
+    return templates.TemplateResponse(request, "partials/_execution_form.html",
         {
             "request": request,
             "flock": current_flock,  # Pass the injected flock instance
@@ -123,8 +122,7 @@ async def htmx_get_agent_input_form(
             return HTMLResponse(
                 f"<p class='error'>Error parsing input signature for {agent_name}: {e}</p>"
             )
-    return templates.TemplateResponse(
-        "partials/_dynamic_input_form_content.html",
+    return templates.TemplateResponse(request, "partials/_dynamic_input_form_content.html",
         {"request": request, "input_fields": input_fields},
     )
 
@@ -223,8 +221,7 @@ async def htmx_run_flock(
     # Unescape newlines for proper display in HTML <pre> tag
     result_data_raw_json_str = raw_json_for_template.replace("\\n", "\n")
     root_path = request.scope.get("root_path", "")
-    return templates.TemplateResponse(
-        "partials/_results_display.html",
+    return templates.TemplateResponse(request, "partials/_results_display.html",
         {
             "request": request,
             "result": result_data,
@@ -344,8 +341,7 @@ async def htmx_run_shared_flock(
         )
     root_path = request.scope.get("root_path", "")
 
-    return templates.TemplateResponse(
-        "partials/_results_display.html",
+    return templates.TemplateResponse(request, "partials/_results_display.html",
         {
             "request": request,
             "result": result_data,

flock/webapp/app/api/flock_management.py

@@ -42,8 +42,7 @@ async def htmx_get_flock_properties_form(
         return HTMLResponse(
             "<div class='error'>Error: No flock loaded. Please load or create one first.</div>"
         )
-    return templates.TemplateResponse(
-        "partials/_flock_properties_form.html",
+    return templates.TemplateResponse(request, "partials/_flock_properties_form.html",
         {
             "request": request,
             "flock": current_flock,
@@ -71,8 +70,7 @@ async def htmx_update_flock_properties(
     updated_flock: Flock | None = getattr(request.app.state, 'flock_instance', None)
     updated_filename: str | None = getattr(request.app.state, 'flock_filename', None)
 
-    return templates.TemplateResponse(
-        "partials/_flock_properties_form.html",
+    return templates.TemplateResponse(request, "partials/_flock_properties_form.html",
         {
             "request": request,
             "flock": updated_flock,
@@ -95,8 +93,7 @@ async def htmx_save_flock(
     current_filename_from_state: str | None = getattr(request.app.state, 'flock_filename', None)
 
     if not save_filename.strip():
-        return templates.TemplateResponse(
-            "partials/_flock_properties_form.html",
+        return templates.TemplateResponse(request, "partials/_flock_properties_form.html",
             {
                 "request": request,
                 "flock": current_flock_from_state,
@@ -117,8 +114,7 @@ async def htmx_save_flock(
     saved_filename: str | None = getattr(request.app.state, 'flock_filename', None)
 
 
-    return templates.TemplateResponse(
-        "partials/_flock_properties_form.html",
+    return templates.TemplateResponse(request, "partials/_flock_properties_form.html",
         {
             "request": request,
             "flock": saved_flock, # Use the instance from app_state

flock/webapp/app/api/registry_viewer.py

@@ -20,8 +20,7 @@ async def htmx_get_registry_table(request: Request, item_type: str):
         )
 
     items = get_registered_items_service(item_type)
-    return templates.TemplateResponse(
-        "partials/_registry_table.html",
+    return templates.TemplateResponse(request, "partials/_registry_table.html",
         {
             "request": request,
             "item_type_display": item_type.capitalize() + "s",

flock/webapp/app/chat.py

@@ -140,7 +140,7 @@ async def chat_page(request: Request):
     cfg = get_chat_config(request)
     context = get_base_context_web(request, ui_mode="standalone")
     context.update({"history": history, "chat_cfg": cfg, "chat_subtitle": f"Agent: {cfg.agent_name}" if cfg.agent_name else "Echo demo", "is_shared_chat": False, "share_id": None})
-    response = templates.TemplateResponse("chat.html", context)
+    response = templates.TemplateResponse(request, "chat.html", context)
     # Set cookie if not already present
     if COOKIE_NAME not in request.cookies:
         response.set_cookie(COOKIE_NAME, sid, max_age=60 * 60 * 24 * 7)
@@ -152,6 +152,7 @@ async def chat_history_partial(request: Request):
     """HTMX endpoint that returns the rendered message list."""
     _, history = _ensure_session(request)
     return templates.TemplateResponse(
+        request,
         "partials/_chat_messages.html",
         {"request": request, "history": history, "now": datetime.now}
     )
@@ -244,8 +245,7 @@ async def chat_send(request: Request, message: str = Form(...)):
         "flock_yaml": getattr(flock_inst, 'to_yaml', lambda: "")()
     })
     # Return updated history partial
-    return templates.TemplateResponse(
-        "partials/_chat_messages.html",
+    return templates.TemplateResponse(request, "partials/_chat_messages.html",
         {"request": request, "history": history, "now": datetime.now}
     )
 
@@ -253,7 +253,7 @@ async def chat_send(request: Request, message: str = Form(...)):
 @router.get("/ui/htmx/chat-view", response_class=HTMLResponse, tags=["Chat"], include_in_schema=False)
 async def chat_container_partial(request: Request):
     _ensure_session(request)
-    return templates.TemplateResponse("partials/_chat_container.html", {"request": request})
+    return templates.TemplateResponse(request, "partials/_chat_container.html", {"request": request})
 
 
 # ---------------------------------------------------------------------------
@@ -287,7 +287,7 @@ async def chat_settings_form(request: Request):
         "input_fields": input_fields,
         "output_fields": output_fields,
     })
-    return templates.TemplateResponse("partials/_chat_settings_form.html", context)
+    return templates.TemplateResponse(request, "partials/_chat_settings_form.html", context)
 
 
 @router.post("/chat/settings", include_in_schema=False)
@@ -329,7 +329,7 @@ async def chat_settings_standalone(request: Request):
         "chat_cfg": cfg,
         "current_flock": getattr(request.app.state, "flock_instance", None),
     })
-    return templates.TemplateResponse("chat_settings.html", context)
+    return templates.TemplateResponse(request, "chat_settings.html", context)
 
 
 # ---------------------------------------------------------------------------
@@ -341,7 +341,7 @@ async def chat_settings_standalone(request: Request):
 async def htmx_chat_view(request: Request):
     """Return chat container partial for standalone page reload via HTMX."""
     _ensure_session(request)
-    return templates.TemplateResponse("partials/_chat_container.html", {"request": request})
+    return templates.TemplateResponse(request, "partials/_chat_container.html", {"request": request})
 
 
 @router.get("/chat/htmx/settings-form", response_class=HTMLResponse, include_in_schema=False)
@@ -363,7 +363,7 @@ async def htmx_chat_settings_partial(request: Request):
         output_fields = _extract(agent_obj.output) if getattr(agent_obj, 'output', '') else []
 
     context = {"request": request, "chat_cfg": cfg, "current_flock": flock_inst, "input_fields": input_fields, "output_fields": output_fields}
-    return templates.TemplateResponse("partials/_chat_settings_form.html", context)
+    return templates.TemplateResponse(request, "partials/_chat_settings_form.html", context)
 
 
 # ---------------------------------------------------------------------------
@@ -387,7 +387,7 @@ async def page_shared_chat(
         logger.warning(f"Shared chat link {share_id} not found or not a chat share type.")
         # Consider rendering an error template or redirecting
         error_context = get_base_context_web(request, ui_mode="standalone", error="Shared chat link is invalid or has expired.")
-        return templates.TemplateResponse("error_page.html", {**error_context, "error_title": "Invalid Link"}, status_code=404)
+        return templates.TemplateResponse(request, "error_page.html", {**error_context, "error_title": "Invalid Link"}, status_code=404)
 
     # Load Flock from definition and cache in app.state.shared_flocks
     loaded_flock: Flock | None = None
@@ -404,7 +404,7 @@ async def page_shared_chat(
         except Exception as e_load:
             logger.error(f"Fatal: Could not load Flock from definition for shared chat {share_id}: {e_load}", exc_info=True)
             error_context = get_base_context_web(request, ui_mode="standalone", error=f"Could not load the shared Flock configuration: {e_load!s}")
-            return templates.TemplateResponse("error_page.html", {**error_context, "error_title": "Configuration Error"}, status_code=500)
+            return templates.TemplateResponse(request, "error_page.html", {**error_context, "error_title": "Configuration Error"}, status_code=500)
 
     frozen_chat_cfg = ChatConfig(
         agent_name=shared_config_db.agent_name,
@@ -426,7 +426,7 @@ async def page_shared_chat(
         "flock": loaded_flock # Pass flock for potential display, though backend uses cached one
     })
 
-    response = templates.TemplateResponse("chat.html", context)
+    response = templates.TemplateResponse(request, "chat.html", context)
     if COOKIE_NAME not in request.cookies: # Ensure cookie is set if _ensure_session created a new one
         response.set_cookie(COOKIE_NAME, sid, max_age=60 * 60 * 24 * 7)
     return response
@@ -436,8 +436,7 @@ async def chat_history_partial_shared(request: Request, share_id: str):
     """HTMX endpoint that returns the rendered message list for a shared chat."""
     # _ensure_session called on page load, so cookie should exist for history keying
     history = _get_history_for_shared_chat(request, share_id)
-    return templates.TemplateResponse(
-        "partials/_chat_messages.html",
+    return templates.TemplateResponse(request, "partials/_chat_messages.html",
         {"request": request, "history": history, "now": datetime.now}
     )
 
@@ -460,8 +459,7 @@ async def chat_send_shared(
         # Error response if config or flock couldn't be loaded
         # This history is ephemeral as it won't be saved if the config is bad
         error_history = [{"role": "bot", "text": "Error: Shared chat configuration is invalid or Flock not found.", "timestamp": datetime.now().strftime('%H:%M')}]
-        return templates.TemplateResponse(
-            "partials/_chat_messages.html",
+        return templates.TemplateResponse(request, "partials/_chat_messages.html",
             {"request": request, "history": error_history, "now": datetime.now},
             status_code=404
         )
@@ -544,8 +542,7 @@ async def chat_send_shared(
         "flock_yaml": getattr(flock_inst, 'to_yaml', lambda: "")()
     })
 
-    return templates.TemplateResponse(
-        "partials/_chat_messages.html",
+    return templates.TemplateResponse(request, "partials/_chat_messages.html",
         {"request": request, "history": history, "now": datetime.now}
     )