Self-improving AI Employees for everyone
Python ai-agentsai-employeeai-employeesassistantautonomous-agentsco-employeescompanygrok-botinstinctloop-agentsmuseown-your-datapersonalself-hosted
refactor(Wave 13.2): extract 5 deployment WS handlers to services/deployment/
trohitgac6f98eefddd
diff --git a/server/routers/websocket.py b/server/routers/websocket.pyindex 970d13e3..3c3199d2 100644--- a/server/routers/websocket.py+++ b/server/routers/websocket.py@@ -901,354 +901,12 @@ async def handle_execute_workflow(data: Dict[str, Any], websocket: WebSocket) ->}-# Per-workflow deployment tasks for proper cancellation (Temporal/n8n pattern)-# Maps workflow_id -> asyncio.Task for parallel workflow deployments-_deployment_tasks: Dict[str, asyncio.Task] = {}---@ws_handler()-async def handle_deploy_workflow(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:- """Deploy workflow to run continuously until cancelled.-- Expects:- workflow_id: Workflow identifier (required for locking)- nodes: List of workflow nodes with {id, type, data}- edges: List of edges with {id, source, target}- session_id: Optional session identifier- delay_between_runs: Optional delay in seconds between iterations (default: 1.0)-- Returns:- Deployment start confirmation (deployment runs in background)- """- global _deployment_tasks- workflow_service = container.workflow_service()- broadcaster = get_status_broadcaster()-- workflow_id = data.get("workflow_id")- nodes = data.get("nodes", [])- edges = data.get("edges", [])- session_id = data.get("session_id", "default")-- # DEBUG: Log received edges to trace tool connection issues- logger.debug(f"[Deploy] Received {len(edges)} edges for workflow {workflow_id}")- for e in edges:- target_handle = e.get('targetHandle')- if target_handle and target_handle.startswith('input-') and target_handle != 'input-main':- logger.debug(f"[Deploy] Config edge: {e.get('source')} -> {e.get('target')} (handle={target_handle})")-- # Check for tool connections to AI Agent- tool_edges = [e for e in edges if e.get('targetHandle') == 'input-tools']- if tool_edges:- logger.debug(f"[Deploy] Tool edges found: {len(tool_edges)}")- for te in tool_edges:- logger.debug(f"[Deploy] Tool edge: source={te.get('source')} -> target={te.get('target')}")- else:- logger.debug("[Deploy] No input-tools edges found")-- if not nodes:- return {"success": False, "error": "No nodes provided"}-- if not workflow_id:- return {"success": False, "error": "workflow_id is required for deployment"}-- # Pre-deploy validation gate. Deploy never honors a force-override —- # a broken workflow running on a schedule is far worse than a failed- # one-shot manual run.- from services.workflow_validator import validate_workflow- deploy_report = await validate_workflow(- nodes=nodes, edges=edges,- parameters_by_id=data.get("parameters_by_id"),- )- if deploy_report["errors"]:- return {- "success": False,- "error": "validation_failed",- "report": deploy_report,- }-- # Check if THIS specific workflow is already deployed (per-workflow isolation)- if workflow_service.is_workflow_deployed(workflow_id):- status = workflow_service.get_deployment_status(workflow_id)- return {- "success": False,- "error": f"Workflow {workflow_id} is already deployed. Cancel it first.",- "workflow_id": workflow_id,- "is_running": True,- "run_counter": status.get("run_counter", 0)- }-- # Acquire workflow lock before starting deployment (per-workflow locking - n8n pattern)- lock_acquired = await broadcaster.lock_workflow(workflow_id, reason="deployment")- if not lock_acquired:- lock_info = broadcaster.get_workflow_lock(workflow_id)- return {- "success": False,- "error": f"Workflow {workflow_id} is already locked for {lock_info.get('reason', 'deployment')}",- "locked_by": lock_info.get("workflow_id"),- "locked_at": lock_info.get("locked_at")- }-- # Broadcast deployment starting status using centralized method- await broadcaster.update_workflow_status(executing=True, current_node=None, progress=0)- await broadcaster.update_deployment_status(- is_running=True,- status="starting",- active_runs=0,- workflow_id=workflow_id- )-- # Create status callback to broadcast node and deployment updates- # Include workflow_id in all node status updates (n8n pattern for workflow isolation)- async def status_callback(node_id: str, status: str, node_data: Optional[Dict] = None):- if node_id == "__deployment__":- # Deployment-level status update using centralized method- active_runs = node_data.get("active_runs", 0) if node_data else 0- await broadcaster.update_deployment_status(- is_running=True,- status=status,- active_runs=active_runs,- workflow_id=workflow_id,- data=node_data- )- else:- # Node-level status update with workflow_id for frontend filtering- await broadcaster.update_node_status(node_id, status, node_data, workflow_id=workflow_id)- if status == "executing":- position = node_data.get("position", 0) if node_data else 0- total = node_data.get("total", 1) if node_data else 1- progress = int((position / total) * 100) if total > 0 else 0- await broadcaster.update_workflow_status(executing=True, current_node=node_id, progress=progress)-- # Start deployment as background task (per-workflow - Temporal/n8n pattern)- # In the event-driven pattern, deploy_workflow() returns immediately after setting up triggers.- # The workflow stays locked until cancel_deployment is called.- async def run_deployment():- try:- result = await workflow_service.deploy_workflow(- nodes=nodes,- edges=edges,- session_id=session_id,- status_callback=status_callback,- workflow_id=workflow_id- )-- # In event-driven mode, deploy_workflow returns immediately after trigger setup.- # If it failed, unlock and report error. If successful, stay running.- if not result.get("success"):- # Setup failed - unlock and report error- logger.error("Deployment setup failed", error=result.get("error"), workflow_id=workflow_id)- await broadcaster.update_deployment_status(- is_running=False,- status="error",- active_runs=0,- workflow_id=workflow_id,- error=result.get("error")- )- await broadcaster.unlock_workflow(workflow_id)- # Clean up task reference for this workflow- _deployment_tasks.pop(workflow_id, None)- else:- # Deployment successful - triggers are set up and running.- # Workflow stays locked until cancel_deployment is called.- await broadcaster.update_deployment_status(- is_running=True,- status="running",- active_runs=0,- workflow_id=workflow_id,- data={- "triggers_setup": result.get("triggers_setup", []),- "deployment_id": result.get("deployment_id")- }- )- logger.info("[Deployment] Event-driven deployment active",- deployment_id=result.get("deployment_id"),- workflow_id=workflow_id,- triggers=len(result.get("triggers_setup", [])))-- except Exception as e:- logger.error("Deployment task error", workflow_id=workflow_id, error=str(e))- await broadcaster.update_deployment_status(- is_running=False,- status="error",- active_runs=0,- workflow_id=workflow_id,- error=str(e)- )- await broadcaster.unlock_workflow(workflow_id)- # Clean up task reference for this workflow- _deployment_tasks.pop(workflow_id, None)-- # Store task per workflow for independent cancellation- _deployment_tasks[workflow_id] = asyncio.create_task(run_deployment())-- return {- "success": True,- "message": "Deployment started",- "workflow_id": workflow_id,- "is_running": True,- "locked": True,- "timestamp": time.time()- }---@ws_handler()-async def handle_cancel_deployment(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:- """Cancel running deployment for a specific workflow (Temporal/n8n pattern).-- Expects:- workflow_id: Workflow to cancel (required).-- Also cancels any active event waiters (trigger nodes) and unlocks the workflow.-- Returns:- Cancellation result with iterations completed- """- global _deployment_tasks-- workflow_service = container.workflow_service()- broadcaster = get_status_broadcaster()-- workflow_id = data.get("workflow_id")-- if not workflow_id:- return {"success": False, "error": "workflow_id is required for cancellation"}-- result = await workflow_service.cancel_deployment(workflow_id)-- # Cancel event waiters for this specific workflow's nodes- cancelled_waiters = 0- if result.get("success"):- cancelled_waiters = result.get("waiters_cancelled", 0)-- # Cancel the deployment task for THIS specific workflow only (per-workflow isolation)- task = _deployment_tasks.pop(workflow_id, None)- if task and not task.done():- task.cancel()- try:- await task- except asyncio.CancelledError:- logger.info("[Deployment] Deployment task cancelled", workflow_id=workflow_id)-- # Unlock this specific workflow- if workflow_id:- await broadcaster.unlock_workflow(workflow_id)-- if result.get("success"):- # Clear node statuses for all trigger nodes that were waiting- # The result contains info about cancelled listeners (listener_{node_id})- # Use existing clear_node_status method which broadcasts node_status_cleared- for node_id in result.get("cancelled_listener_node_ids", []):- await broadcaster.clear_node_status(node_id)-- # Broadcast deployment cancelled status using centralized method- await broadcaster.update_workflow_status(executing=False, current_node=None, progress=0)- await broadcaster.update_deployment_status(- is_running=False,- status="cancelled",- active_runs=0,- workflow_id=workflow_id,- data={- "iterations_completed": result.get("iterations_completed", 0)- }- )-- return {- "success": result.get("success", False),- "message": result.get("message", result.get("error")),- "workflow_id": workflow_id,- "was_running": result.get("was_running", False),- "iterations_completed": result.get("iterations_completed", 0),- "cancelled_waiters": cancelled_waiters,- "unlocked": workflow_id is not None,- "timestamp": time.time()- }---@ws_handler()-async def handle_get_deployment_status(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:- """Get current deployment status including workflow lock info.-- Expects (optional):- workflow_id: Get status for specific workflow. If not provided, returns global status.-- Returns:- Current deployment state, iteration count, and lock status- """- workflow_service = container.workflow_service()- broadcaster = get_status_broadcaster()-- workflow_id = data.get("workflow_id")- status = workflow_service.get_deployment_status(workflow_id)-- return {- "is_running": workflow_service.is_deployment_running(workflow_id),- "run_counter": status.get("run_counter", 0),- "active_runs": status.get("active_runs", 0),- "settings": workflow_service.get_deployment_settings(),- "workflow_id": workflow_id or status.get("workflow_id"),- "deployed_workflows": status.get("deployed_workflows", []),- "lock": broadcaster.get_workflow_lock(),- "timestamp": time.time()- }---@ws_handler()-async def handle_get_workflow_lock(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:- """Get current workflow lock status.-- Returns:- Current lock state including locked workflow_id and reason- """- broadcaster = get_status_broadcaster()-- return {- "lock": broadcaster.get_workflow_lock(),- "timestamp": time.time()- }---@ws_handler()-async def handle_update_deployment_settings(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:- """Update deployment settings (can be called during active deployment).-- Expects any of:- delay_between_runs: float - Seconds to wait between iterations- stop_on_error: bool - Stop deployment when a node fails- max_iterations: int - Max iterations (0 = unlimited)-- Returns:- Updated settings and current deployment state- """- workflow_service = container.workflow_service()- broadcaster = get_status_broadcaster()-- settings_to_update = {}- if "delay_between_runs" in data:- settings_to_update["delay_between_runs"] = data["delay_between_runs"]- if "stop_on_error" in data:- settings_to_update["stop_on_error"] = data["stop_on_error"]- if "max_iterations" in data:- settings_to_update["max_iterations"] = data["max_iterations"]-- updated_settings = await workflow_service.update_deployment_settings(settings_to_update)-- # Broadcast settings update- status = workflow_service.get_deployment_status()- await broadcaster.broadcast({- "type": "deployment_settings_updated",- "settings": updated_settings,- "is_running": workflow_service.is_deployment_running(),- "run_counter": status.get("run_counter", 0)- })-- return {- "success": True,- "settings": updated_settings,- "is_running": workflow_service.is_deployment_running(),- "run_counter": status.get("run_counter", 0),- "active_runs": status.get("active_runs", 0),- "timestamp": time.time()- }+# ============================================================================+# Deployment handlers — extracted to services/deployment/handlers.py (Wave 13.2)+# ============================================================================+# 5 handlers (deploy_workflow / cancel_deployment / get_deployment_status /+# get_workflow_lock / update_deployment_settings) self-register into the+# central ws_handler_registry via services/deployment/__init__.py.# ============================================================================@@ -2358,12 +2016,8 @@ MESSAGE_HANDLERS: Dict[str, MessageHandler] = {"remove_dlq_entry": handle_remove_dlq_entry,"purge_dlq": handle_purge_dlq,- # Deployment operations- "deploy_workflow": handle_deploy_workflow,- "cancel_deployment": handle_cancel_deployment,- "get_deployment_status": handle_get_deployment_status,- "get_workflow_lock": handle_get_workflow_lock,- "update_deployment_settings": handle_update_deployment_settings,+ # Deployment operations — extracted to services/deployment/handlers.py+ # (Wave 13.2); registered via ws_handler_registry on package import.# AI operations"execute_ai_node": handle_execute_ai_node,diff --git a/server/services/deployment/__init__.py b/server/services/deployment/__init__.pyindex cb255141..955a56fc 100644--- a/server/services/deployment/__init__.py+++ b/server/services/deployment/__init__.py@@ -1,8 +1,19 @@-"""Deployment module - Event-driven workflow deployment."""+"""Deployment module - Event-driven workflow deployment.++Wave 13.2: side-effect import publishes the 5 deployment WS handlers+(deploy_workflow / cancel_deployment / get_deployment_status /+get_workflow_lock / update_deployment_settings) into the central+``ws_handler_registry``.+"""++from services.ws_handler_registry import register_ws_handlers as _register_ws_handlersfrom .state import DeploymentState, TriggerInfofrom .triggers import TriggerManagerfrom .manager import DeploymentManager+from .handlers import WS_HANDLERS as _DEPLOYMENT_WS_HANDLERS++_register_ws_handlers(_DEPLOYMENT_WS_HANDLERS)__all__ = ["DeploymentState",diff --git a/server/services/deployment/handlers.py b/server/services/deployment/handlers.pynew file mode 100644index 00000000..9f722fae--- /dev/null+++ b/server/services/deployment/handlers.py@@ -0,0 +1,377 @@+"""Deployment domain WebSocket handlers.++Extracted from ``routers/websocket.py`` (Wave 13.2). The 5 handlers+below cover the deployment lifecycle:++ - ``deploy_workflow`` — start a continuously-running workflow with+ triggers + per-workflow locking.+ - ``cancel_deployment`` — cancel a running deployment, drain its+ listeners, unlock the workflow.+ - ``get_deployment_status`` — snapshot of in-flight deployments.+ - ``get_workflow_lock`` — current lock state.+ - ``update_deployment_settings`` — mutate runtime settings without+ re-deploying.++All handlers preserve their pre-Wave-13 wire shape. The module-level+``_deployment_tasks`` dict (workflow_id -> asyncio.Task) moves here+too; it was process-local in ``routers/websocket.py`` and stays the+same shape — only the import path changes.+"""++from __future__ import annotations++import asyncio+import time+from typing import Any, Dict, Optional++from fastapi import WebSocket++from core.logging import get_logger+from services.ws_handler_registry import ws_handler++# ``core.container`` and ``services.status_broadcaster`` are lazy-imported+# inside each handler body. This module is imported transitively via+# ``services.workflow`` during ``core.container`` initialization (the+# container wires ``WorkflowService`` which imports ``services.workflow``+# which imports ``services.deployment``). Eager imports at module scope+# would deadlock the partially-initialized container module.++logger = get_logger(__name__)+++# Per-workflow deployment tasks for proper cancellation (Temporal/n8n pattern).+# Maps workflow_id -> asyncio.Task for parallel workflow deployments.+_deployment_tasks: Dict[str, asyncio.Task] = {}+++@ws_handler()+async def handle_deploy_workflow(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:+ """Deploy workflow to run continuously until cancelled.++ Expects:+ workflow_id: Workflow identifier (required for locking)+ nodes: List of workflow nodes with {id, type, data}+ edges: List of edges with {id, source, target}+ session_id: Optional session identifier+ delay_between_runs: Optional delay in seconds between iterations (default: 1.0)++ Returns:+ Deployment start confirmation (deployment runs in background)+ """+ global _deployment_tasks+ from core.container import container+ from services.status_broadcaster import get_status_broadcaster++ workflow_service = container.workflow_service()+ broadcaster = get_status_broadcaster()++ workflow_id = data.get("workflow_id")+ nodes = data.get("nodes", [])+ edges = data.get("edges", [])+ session_id = data.get("session_id", "default")++ logger.debug(f"[Deploy] Received {len(edges)} edges for workflow {workflow_id}")+ for e in edges:+ target_handle = e.get('targetHandle')+ if target_handle and target_handle.startswith('input-') and target_handle != 'input-main':+ logger.debug(f"[Deploy] Config edge: {e.get('source')} -> {e.get('target')} (handle={target_handle})")++ tool_edges = [e for e in edges if e.get('targetHandle') == 'input-tools']+ if tool_edges:+ logger.debug(f"[Deploy] Tool edges found: {len(tool_edges)}")+ for te in tool_edges:+ logger.debug(f"[Deploy] Tool edge: source={te.get('source')} -> target={te.get('target')}")+ else:+ logger.debug("[Deploy] No input-tools edges found")++ if not nodes:+ return {"success": False, "error": "No nodes provided"}++ if not workflow_id:+ return {"success": False, "error": "workflow_id is required for deployment"}++ # Pre-deploy validation gate. Deploy never honors a force-override —+ # a broken workflow running on a schedule is far worse than a failed+ # one-shot manual run.+ from services.workflow_validator import validate_workflow+ deploy_report = await validate_workflow(+ nodes=nodes, edges=edges,+ parameters_by_id=data.get("parameters_by_id"),+ )+ if deploy_report["errors"]:+ return {+ "success": False,+ "error": "validation_failed",+ "report": deploy_report,+ }++ if workflow_service.is_workflow_deployed(workflow_id):+ status = workflow_service.get_deployment_status(workflow_id)+ return {+ "success": False,+ "error": f"Workflow {workflow_id} is already deployed. Cancel it first.",+ "workflow_id": workflow_id,+ "is_running": True,+ "run_counter": status.get("run_counter", 0),+ }++ lock_acquired = await broadcaster.lock_workflow(workflow_id, reason="deployment")+ if not lock_acquired:+ lock_info = broadcaster.get_workflow_lock(workflow_id)+ return {+ "success": False,+ "error": f"Workflow {workflow_id} is already locked for {lock_info.get('reason', 'deployment')}",+ "locked_by": lock_info.get("workflow_id"),+ "locked_at": lock_info.get("locked_at"),+ }++ await broadcaster.update_workflow_status(executing=True, current_node=None, progress=0)+ await broadcaster.update_deployment_status(+ is_running=True,+ status="starting",+ active_runs=0,+ workflow_id=workflow_id,+ )++ async def status_callback(node_id: str, status: str, node_data: Optional[Dict] = None):+ if node_id == "__deployment__":+ active_runs = node_data.get("active_runs", 0) if node_data else 0+ await broadcaster.update_deployment_status(+ is_running=True,+ status=status,+ active_runs=active_runs,+ workflow_id=workflow_id,+ data=node_data,+ )+ else:+ await broadcaster.update_node_status(node_id, status, node_data, workflow_id=workflow_id)+ if status == "executing":+ position = node_data.get("position", 0) if node_data else 0+ total = node_data.get("total", 1) if node_data else 1+ progress = int((position / total) * 100) if total > 0 else 0+ await broadcaster.update_workflow_status(executing=True, current_node=node_id, progress=progress)++ async def run_deployment():+ try:+ result = await workflow_service.deploy_workflow(+ nodes=nodes,+ edges=edges,+ session_id=session_id,+ status_callback=status_callback,+ workflow_id=workflow_id,+ )++ if not result.get("success"):+ logger.error("Deployment setup failed", error=result.get("error"), workflow_id=workflow_id)+ await broadcaster.update_deployment_status(+ is_running=False,+ status="error",+ active_runs=0,+ workflow_id=workflow_id,+ error=result.get("error"),+ )+ await broadcaster.unlock_workflow(workflow_id)+ _deployment_tasks.pop(workflow_id, None)+ else:+ await broadcaster.update_deployment_status(+ is_running=True,+ status="running",+ active_runs=0,+ workflow_id=workflow_id,+ data={+ "triggers_setup": result.get("triggers_setup", []),+ "deployment_id": result.get("deployment_id"),+ },+ )+ logger.info(+ "[Deployment] Event-driven deployment active",+ deployment_id=result.get("deployment_id"),+ workflow_id=workflow_id,+ triggers=len(result.get("triggers_setup", [])),+ )++ except Exception as e:+ logger.error("Deployment task error", workflow_id=workflow_id, error=str(e))+ await broadcaster.update_deployment_status(+ is_running=False,+ status="error",+ active_runs=0,+ workflow_id=workflow_id,+ error=str(e),+ )+ await broadcaster.unlock_workflow(workflow_id)+ _deployment_tasks.pop(workflow_id, None)++ _deployment_tasks[workflow_id] = asyncio.create_task(run_deployment())++ return {+ "success": True,+ "message": "Deployment started",+ "workflow_id": workflow_id,+ "is_running": True,+ "locked": True,+ "timestamp": time.time(),+ }+++@ws_handler()+async def handle_cancel_deployment(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:+ """Cancel running deployment for a specific workflow (Temporal/n8n pattern).++ Expects:+ workflow_id: Workflow to cancel (required).++ Also cancels any active event waiters (trigger nodes) and unlocks the workflow.++ Returns:+ Cancellation result with iterations completed+ """+ global _deployment_tasks+ from core.container import container+ from services.status_broadcaster import get_status_broadcaster++ workflow_service = container.workflow_service()+ broadcaster = get_status_broadcaster()++ workflow_id = data.get("workflow_id")++ if not workflow_id:+ return {"success": False, "error": "workflow_id is required for cancellation"}++ result = await workflow_service.cancel_deployment(workflow_id)++ cancelled_waiters = 0+ if result.get("success"):+ cancelled_waiters = result.get("waiters_cancelled", 0)++ task = _deployment_tasks.pop(workflow_id, None)+ if task and not task.done():+ task.cancel()+ try:+ await task+ except asyncio.CancelledError:+ logger.info("[Deployment] Deployment task cancelled", workflow_id=workflow_id)++ if workflow_id:+ await broadcaster.unlock_workflow(workflow_id)++ if result.get("success"):+ for node_id in result.get("cancelled_listener_node_ids", []):+ await broadcaster.clear_node_status(node_id)++ await broadcaster.update_workflow_status(executing=False, current_node=None, progress=0)+ await broadcaster.update_deployment_status(+ is_running=False,+ status="cancelled",+ active_runs=0,+ workflow_id=workflow_id,+ data={+ "iterations_completed": result.get("iterations_completed", 0),+ },+ )++ return {+ "success": result.get("success", False),+ "message": result.get("message", result.get("error")),+ "workflow_id": workflow_id,+ "was_running": result.get("was_running", False),+ "iterations_completed": result.get("iterations_completed", 0),+ "cancelled_waiters": cancelled_waiters,+ "unlocked": workflow_id is not None,+ "timestamp": time.time(),+ }+++@ws_handler()+async def handle_get_deployment_status(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:+ """Get current deployment status including workflow lock info."""+ from core.container import container+ from services.status_broadcaster import get_status_broadcaster++ workflow_service = container.workflow_service()+ broadcaster = get_status_broadcaster()++ workflow_id = data.get("workflow_id")+ status = workflow_service.get_deployment_status(workflow_id)++ return {+ "is_running": workflow_service.is_deployment_running(workflow_id),+ "run_counter": status.get("run_counter", 0),+ "active_runs": status.get("active_runs", 0),+ "settings": workflow_service.get_deployment_settings(),+ "workflow_id": workflow_id or status.get("workflow_id"),+ "deployed_workflows": status.get("deployed_workflows", []),+ "lock": broadcaster.get_workflow_lock(),+ "timestamp": time.time(),+ }+++@ws_handler()+async def handle_get_workflow_lock(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:+ """Get current workflow lock status."""+ from services.status_broadcaster import get_status_broadcaster++ broadcaster = get_status_broadcaster()++ return {+ "lock": broadcaster.get_workflow_lock(),+ "timestamp": time.time(),+ }+++@ws_handler()+async def handle_update_deployment_settings(+ data: Dict[str, Any], websocket: WebSocket,+) -> Dict[str, Any]:+ """Update deployment settings (can be called during active deployment)."""+ from core.container import container+ from services.status_broadcaster import get_status_broadcaster++ workflow_service = container.workflow_service()+ broadcaster = get_status_broadcaster()++ settings_to_update = {}+ if "delay_between_runs" in data:+ settings_to_update["delay_between_runs"] = data["delay_between_runs"]+ if "stop_on_error" in data:+ settings_to_update["stop_on_error"] = data["stop_on_error"]+ if "max_iterations" in data:+ settings_to_update["max_iterations"] = data["max_iterations"]++ updated_settings = await workflow_service.update_deployment_settings(settings_to_update)++ status = workflow_service.get_deployment_status()+ await broadcaster.broadcast({+ "type": "deployment_settings_updated",+ "settings": updated_settings,+ "is_running": workflow_service.is_deployment_running(),+ "run_counter": status.get("run_counter", 0),+ })++ return {+ "success": True,+ "settings": updated_settings,+ "is_running": workflow_service.is_deployment_running(),+ "run_counter": status.get("run_counter", 0),+ "active_runs": status.get("active_runs", 0),+ "timestamp": time.time(),+ }+++WS_HANDLERS: Dict[str, Any] = {+ "deploy_workflow": handle_deploy_workflow,+ "cancel_deployment": handle_cancel_deployment,+ "get_deployment_status": handle_get_deployment_status,+ "get_workflow_lock": handle_get_workflow_lock,+ "update_deployment_settings": handle_update_deployment_settings,+}+++__all__ = [+ "WS_HANDLERS",+ "handle_cancel_deployment",+ "handle_deploy_workflow",+ "handle_get_deployment_status",+ "handle_get_workflow_lock",+ "handle_update_deployment_settings",+]