Merge branch 'p254' into p284

api/app.py

@@ -33,8 +33,13 @@ else:
 
     from app_factory import create_app
 
-    app = create_app()
+    socketio_app, app = create_app()
     celery = app.extensions["celery"]
 
 if __name__ == "__main__":
-    app.run(host="0.0.0.0", port=5001)
+    from gevent import pywsgi
+
+    host = os.environ.get("HOST", "0.0.0.0")
+    port = int(os.environ.get("PORT", 5001))
+    server = pywsgi.WSGIServer((host, port), socketio_app)
+    server.serve_forever()

api/app_factory.py

@@ -31,10 +31,18 @@ def create_flask_app_with_configs() -> DifyApp:
     return dify_app
 
 
-def create_app() -> DifyApp:
+def create_app() -> tuple[any, DifyApp]:
     start_time = time.perf_counter()
     app = create_flask_app_with_configs()
     initialize_extensions(app)
+
+    import socketio
+
+    from extensions.ext_socketio import sio
+
+    sio.app = app
+    socketio_app = socketio.WSGIApp(sio, app)
+
     end_time = time.perf_counter()
     if dify_config.DEBUG:
         logger.info("Finished create_app (%s ms)", round((end_time - start_time) * 1000, 2))

api/controllers/console/__init__.py

@@ -79,6 +79,7 @@ from .app import (
     mcp_server,
     message,
     model_config,
+    online_user,
     ops_trace,
     site,
     statistic,

api/controllers/console/app/online_user.py

@@ -0,0 +1,213 @@
+import json
+import time
+
+from extensions.ext_redis import redis_client
+from extensions.ext_socketio import sio
+from libs.passport import PassportService
+from services.account_service import AccountService
+
+
+@sio.on("connect")
+def socket_connect(sid, environ, auth):
+    """
+    WebSocket connect event, do authentication here.
+    """
+    token = None
+    if auth and isinstance(auth, dict):
+        token = auth.get("token")
+    if not token:
+        return False
+
+    try:
+        decoded = PassportService().verify(token)
+        user_id = decoded.get("user_id")
+        if not user_id:
+            return False
+
+        with sio.app.app_context():
+            user = AccountService.load_logged_in_account(account_id=user_id)
+            if not user:
+                return False
+
+            sio.save_session(sid, {"user_id": user.id, "username": user.name, "avatar": user.avatar})
+
+            return True
+
+    except Exception:
+        return False
+
+
+@sio.on("user_connect")
+def handle_user_connect(sid, data):
+    """
+    Handle user connect event, check login and get user info.
+    """
+
+    workflow_id = data.get("workflow_id")
+    if not workflow_id:
+        return {"msg": "workflow_id is required"}, 400
+
+    session = sio.get_session(sid)
+    user_id = session.get("user_id")
+
+    if not user_id:
+        return {"msg": "unauthorized"}, 401
+
+    old_info_json = redis_client.hget(f"workflow_online_users:{workflow_id}", user_id)
+    if old_info_json:
+        old_info = json.loads(old_info_json)
+        old_sid = old_info.get("sid")
+        if old_sid and old_sid != sid:
+            sio.disconnect(sid=old_sid)
+
+    user_info = {
+        "user_id": user_id,
+        "username": session.get("username", "Unknown"),
+        "avatar": session.get("avatar", None),
+        "sid": sid,
+    }
+
+    # --- Leader Election Logic ---
+    workflow_users_key = f"workflow_online_users:{workflow_id}"
+    workflow_order_key = f"workflow_user_order:{workflow_id}"
+
+    # Remove user from list in case of reconnection, to add them to the end
+    redis_client.lrem(workflow_order_key, 0, user_id)
+    # Add user to the end of the list
+    redis_client.rpush(workflow_order_key, user_id)
+
+    # The first user in the list is the leader
+    leader_user_id_bytes = redis_client.lindex(workflow_order_key, 0)
+    is_leader = leader_user_id_bytes and leader_user_id_bytes.decode("utf-8") == user_id
+
+    # Notify the connecting client of their leader status
+    sio.emit("status", {"isLeader": is_leader}, room=sid)
+    # --- End of Leader Election Logic ---
+
+    redis_client.hset(workflow_users_key, user_id, json.dumps(user_info))
+    redis_client.set(f"ws_sid_map:{sid}", json.dumps({"workflow_id": workflow_id, "user_id": user_id}))
+
+    sio.enter_room(sid, workflow_id)
+    broadcast_online_users(workflow_id)
+
+    return {"msg": "connected", "user_id": user_id, "sid": sid}
+
+
+@sio.on("disconnect")
+def handle_disconnect(sid):
+    """
+    Handle user disconnect event, remove user from workflow's online user list.
+    """
+    mapping = redis_client.get(f"ws_sid_map:{sid}")
+    if mapping:
+        data = json.loads(mapping)
+        workflow_id = data["workflow_id"]
+        user_id = data["user_id"]
+
+        workflow_users_key = f"workflow_online_users:{workflow_id}"
+        workflow_order_key = f"workflow_user_order:{workflow_id}"
+
+        # Get leader before any modification
+        leader_user_id_bytes = redis_client.lindex(workflow_order_key, 0)
+        was_leader = leader_user_id_bytes and leader_user_id_bytes.decode("utf-8") == user_id
+
+        # Remove user
+        redis_client.hdel(workflow_users_key, user_id)
+        redis_client.delete(f"ws_sid_map:{sid}")
+        redis_client.lrem(workflow_order_key, 0, user_id)
+
+        # Check if leader disconnected and a new one needs to be elected
+        if was_leader:
+            new_leader_user_id_bytes = redis_client.lindex(workflow_order_key, 0)
+            if new_leader_user_id_bytes:
+                new_leader_user_id = new_leader_user_id_bytes.decode("utf-8")
+                # get new leader's info to find their sid
+                new_leader_info_json = redis_client.hget(workflow_users_key, new_leader_user_id)
+                if new_leader_info_json:
+                    new_leader_info = json.loads(new_leader_info_json)
+                    new_leader_sid = new_leader_info.get("sid")
+                    if new_leader_sid:
+                        sio.emit("status", {"isLeader": True}, room=new_leader_sid)
+
+        # If the room is empty, clean up the redis key
+        if redis_client.llen(workflow_order_key) == 0:
+            redis_client.delete(workflow_order_key)
+
+        broadcast_online_users(workflow_id)
+
+
+def broadcast_online_users(workflow_id):
+    """
+    broadcast online users to the workflow room
+    """
+    workflow_users_key = f"workflow_online_users:{workflow_id}"
+    workflow_order_key = f"workflow_user_order:{workflow_id}"
+
+    # The first user in the list is the leader
+    leader_user_id_bytes = redis_client.lindex(workflow_order_key, 0)
+    leader_user_id = leader_user_id_bytes.decode("utf-8") if leader_user_id_bytes else None
+
+    users_json = redis_client.hgetall(workflow_users_key)
+    users = []
+    for _, user_info_json in users_json.items():
+        try:
+            users.append(json.loads(user_info_json))
+        except Exception:
+            continue
+    sio.emit(
+        "online_users",
+        {"workflow_id": workflow_id, "users": users, "leader": leader_user_id},
+        room=workflow_id,
+    )
+
+
+@sio.on("collaboration_event")
+def handle_collaboration_event(sid, data):
+    """
+    Handle general collaboration events, include:
+    1. mouseMove
+    2. varsAndFeaturesUpdate
+
+    """
+    mapping = redis_client.get(f"ws_sid_map:{sid}")
+
+    if not mapping:
+        return {"msg": "unauthorized"}, 401
+
+    mapping_data = json.loads(mapping)
+    workflow_id = mapping_data["workflow_id"]
+    user_id = mapping_data["user_id"]
+
+    event_type = data.get("type")
+    event_data = data.get("data")
+    timestamp = data.get("timestamp", int(time.time()))
+
+    if not event_type:
+        return {"msg": "invalid event type"}, 400
+
+    sio.emit(
+        "collaboration_update",
+        {"type": event_type, "userId": user_id, "data": event_data, "timestamp": timestamp},
+        room=workflow_id,
+        skip_sid=sid,
+    )
+
+    return {"msg": "event_broadcasted"}
+
+
+@sio.on("graph_event")
+def handle_graph_event(sid, data):
+    """
+    Handle graph events - simple broadcast relay.
+    """
+    mapping = redis_client.get(f"ws_sid_map:{sid}")
+
+    if not mapping:
+        return {"msg": "unauthorized"}, 401
+
+    mapping_data = json.loads(mapping)
+    workflow_id = mapping_data["workflow_id"]
+
+    sio.emit("graph_update", data, room=workflow_id, skip_sid=sid)
+
+    return {"msg": "graph_update_broadcasted"}

api/controllers/console/app/workflow.py

@@ -23,6 +23,7 @@ from core.helper.trace_id_helper import get_external_trace_id
 from core.workflow.graph_engine.manager import GraphEngineManager
 from extensions.ext_database import db
 from factories import file_factory, variable_factory
+from fields.online_user_fields import online_user_list_fields
 from fields.workflow_fields import workflow_fields, workflow_pagination_fields
 from fields.workflow_run_fields import workflow_run_node_execution_fields
 from libs import helper
@@ -1004,3 +1005,101 @@ class DraftWorkflowNodeLastRunApi(Resource):
         if node_exec is None:
             raise NotFound("last run not found")
         return node_exec
+
+
+class WorkflowOnlineUsersApi(Resource):
+    @setup_required
+    @login_required
+    @account_initialization_required
+    @marshal_with(online_user_list_fields)
+    def get(self):
+        parser = reqparse.RequestParser()
+        parser.add_argument("workflow_ids", type=str, required=True, location="args")
+        args = parser.parse_args()
+
+        workflow_ids = [id.strip() for id in args["workflow_ids"].split(",")]
+
+        results = {}
+        for workflow_id in workflow_ids:
+            users_json = redis_client.hgetall(f"workflow_online_users:{workflow_id}")
+
+            users = []
+            for _, user_info_json in users_json.items():
+                try:
+                    users.append(json.loads(user_info_json))
+                except Exception:
+                    continue
+            results[workflow_id] = users
+
+        return {"data": results}
+
+
+api.add_resource(
+    DraftWorkflowApi,
+    "/apps/<uuid:app_id>/workflows/draft",
+)
+api.add_resource(
+    WorkflowConfigApi,
+    "/apps/<uuid:app_id>/workflows/draft/config",
+)
+api.add_resource(
+    AdvancedChatDraftWorkflowRunApi,
+    "/apps/<uuid:app_id>/advanced-chat/workflows/draft/run",
+)
+api.add_resource(
+    DraftWorkflowRunApi,
+    "/apps/<uuid:app_id>/workflows/draft/run",
+)
+api.add_resource(
+    WorkflowTaskStopApi,
+    "/apps/<uuid:app_id>/workflow-runs/tasks/<string:task_id>/stop",
+)
+api.add_resource(
+    DraftWorkflowNodeRunApi,
+    "/apps/<uuid:app_id>/workflows/draft/nodes/<string:node_id>/run",
+)
+api.add_resource(
+    AdvancedChatDraftRunIterationNodeApi,
+    "/apps/<uuid:app_id>/advanced-chat/workflows/draft/iteration/nodes/<string:node_id>/run",
+)
+api.add_resource(
+    WorkflowDraftRunIterationNodeApi,
+    "/apps/<uuid:app_id>/workflows/draft/iteration/nodes/<string:node_id>/run",
+)
+api.add_resource(
+    AdvancedChatDraftRunLoopNodeApi,
+    "/apps/<uuid:app_id>/advanced-chat/workflows/draft/loop/nodes/<string:node_id>/run",
+)
+api.add_resource(
+    WorkflowDraftRunLoopNodeApi,
+    "/apps/<uuid:app_id>/workflows/draft/loop/nodes/<string:node_id>/run",
+)
+api.add_resource(
+    PublishedWorkflowApi,
+    "/apps/<uuid:app_id>/workflows/publish",
+)
+api.add_resource(
+    PublishedAllWorkflowApi,
+    "/apps/<uuid:app_id>/workflows",
+)
+api.add_resource(
+    DefaultBlockConfigsApi,
+    "/apps/<uuid:app_id>/workflows/default-workflow-block-configs",
+)
+api.add_resource(
+    DefaultBlockConfigApi,
+    "/apps/<uuid:app_id>/workflows/default-workflow-block-configs/<string:block_type>",
+)
+api.add_resource(
+    ConvertToWorkflowApi,
+    "/apps/<uuid:app_id>/convert-to-workflow",
+)
+api.add_resource(
+    WorkflowByIdApi,
+    "/apps/<uuid:app_id>/workflows/<string:workflow_id>",
+)
+api.add_resource(
+    DraftWorkflowNodeLastRunApi,
+    "/apps/<uuid:app_id>/workflows/draft/nodes/<string:node_id>/last-run",
+)
+api.add_resource(WorkflowOnlineUsersApi, "/apps/workflows/online-users")

api/docker/entrypoint.sh

@@ -38,6 +38,7 @@ elif [[ "${MODE}" == "beat" ]]; then
   exec celery -A app.celery beat --loglevel ${LOG_LEVEL:-INFO}
 else
   if [[ "${DEBUG}" == "true" ]]; then
+  # TODO: add socketio support
     exec flask run --host=${DIFY_BIND_ADDRESS:-0.0.0.0} --port=${DIFY_PORT:-5001} --debug
   else
     exec gunicorn \

api/extensions/ext_socketio.py

@@ -0,0 +1,5 @@
+import socketio
+
+from configs import dify_config
+
+sio = socketio.Server(async_mode="gevent", cors_allowed_origins=dify_config.CONSOLE_CORS_ALLOW_ORIGINS)

api/fields/online_user_fields.py

@@ -0,0 +1,17 @@
+from flask_restful import fields
+
+online_user_partial_fields = {
+    "id": fields.String,
+    "username": fields.String,
+    "avatar": fields.String,
+    "sid": fields.String,
+}
+
+workflow_online_users_fields = {
+    "workflow_id": fields.String,
+    "users": fields.List(fields.Nested(online_user_partial_fields)),
+}
+
+online_user_list_fields = {
+    "data": fields.List(fields.Nested(workflow_online_users_fields)),
+}

api/pyproject.toml

@@ -71,6 +71,7 @@ dependencies = [
     "pypdfium2==4.30.0",
     "python-docx~=1.1.0",
     "python-dotenv==1.0.1",
+    "python-socketio~=5.13.0",
     "pyyaml~=6.0.1",
     "readabilipy~=0.3.0",
     "redis[hiredis]~=6.1.0",