Update app.py

app.py

@@ -66,23 +66,19 @@ async def send_html_chunks(websocket, soup):
         
         await websocket.send(json.dumps({"type": "end",}))
     
-
-# async def send_html_chunks(ws, html_data, chunk_size=1024):
-   
-
-#     # Split the HTML data into chunks
-#     total_chunks = math.ceil(len(html_data) / chunk_size)
-#     for i in range(total_chunks):
-#         start = i * chunk_size
-#         end = min(start + chunk_size, len(html_data))
-#         chunk = html_data[start:end]
-
-#         # Send the chunk with chunk number and total chunks information
-#         chunk_message = f"chunk_{i+1}/{total_chunks}:{chunk}"
-#         await ws.send(chunk_message.encode())
-
-#         # Wait for a short interval before sending the next chunk
-#         await asyncio.sleep(0.1)  # Adjust as needed
+async def send_message_chunks(websocket, message):
+    msg_id = str(uuid.uuid4())
+    message_json = json.dumps(message)
+    chunks = [message_json[i:i+10] for i in range(0, len(message_json), 10)]
+    
+    for i, chunk in enumerate(chunks):
+        chunk_data = {
+            'msg_id': msg_id,
+            'part': chunk,
+            'end': i == len(chunks) - 1
+        }
+        await websocket.send(json.dumps(chunk_data))
+        print(f"Sent chunk: {chunk_data}")
         
 def auto_detect_mode(content):
     if isinstance(content, str):
@@ -282,7 +278,7 @@ async def get_file_content(websocket, key,project_name, path,rpath,name,connecte
                 'rfilePath':rpath,
                 'filePath':path,
         }
-            await websocket.send(json.dumps(event))
+            await send_message_chunks(websocket,event)
         except UnicodeDecodeError:
             with open(file_path, 'rb') as file:
                 content = file.read()
@@ -293,13 +289,13 @@ async def get_file_content(websocket, key,project_name, path,rpath,name,connecte
                 'rfilePath':rpath,
                 'filePath':path,
         }
-            await websocket.send(json.dumps(event))
+            await await send_message_chunks(websocket,event)
     except Exception as e:
         event = {
         "type": "error",
         "message": f"Failed to read file content: {str(e)}",
             }
-        await websocket.send(json.dumps(event))
+        await await send_message_chunks(websocket,event)
         
 
 
@@ -371,14 +367,14 @@ async def read_process_output(process, websocket):
                 "data": word.decode('utf-8'),
             }
                 print('sending data',1)
-                await websocket.send(json.dumps(event))
+                await send_message_chunks(websocket,event)
                 word = b''
             print("line is completed")
             event = {
                 "type": "terminal-newline",
                 "data": "",
             }
-            await websocket.send(json.dumps(event))
+            await send_message_chunks(websocket,event)
         elif char == b' ':
             if word:
                 print(word.decode('utf-8'),2)
@@ -387,7 +383,7 @@ async def read_process_output(process, websocket):
                 "data": word.decode('utf-8'),
             }
                 print('sending data',2)
-                await websocket.send(json.dumps(event))
+                await send_message_chunks(websocket,event)
                 word = b''
             print("space is occurred")
             event = {
@@ -395,7 +391,7 @@ async def read_process_output(process, websocket):
                 "data": " ",
             }
             print('sending data',3)
-            await websocket.send(json.dumps(event))
+            await send_message_chunks(websocket,event)
         elif char == b'':
             if word:
                 print(word.decode('utf-8'),3)
@@ -404,7 +400,7 @@ async def read_process_output(process, websocket):
                 "data": word.decode('utf-8'),
             }
                 print('sending data',4)
-                await websocket.send(json.dumps(event))
+                await send_message_chunks(websocket,event)
             break
         else:
             word += char
@@ -418,14 +414,14 @@ async def read_process_output(process, websocket):
                 "type": "terminal-error",
                 "data": word.decode('utf-8'),
             }
-                await websocket.send(json.dumps(event))
+                await send_message_chunks(websocket,event)
                 word = b''
             print("line is completed")
             event = {
                 "type": "terminal-newline",
                 "data": "",
             }
-            await websocket.send(json.dumps(event))
+            await send_message_chunks(websocket,event)
         elif char == b' ':
             if word:
                 print(word.decode('utf-8'))
@@ -433,14 +429,14 @@ async def read_process_output(process, websocket):
                 "type": "terminal-error",
                 "data": word.decode('utf-8'),
             }
-                await websocket.send(json.dumps(event))
+                await send_message_chunks(websocket,event)
                 word = b''
             print("space is occurred")
             event = {
                 "type": "terminal-error",
                 "data": " ",
             }
-            await websocket.send(json.dumps(event))
+            await send_message_chunks(websocket,event)
         elif char == b'':
             if word:
                 print(word.decode('utf-8'))
@@ -454,7 +450,7 @@ async def read_process_output(process, websocket):
         #         "type": "terminal-data",
         #         "data": line.strip().decode('utf-8'),
         #     }
-        #     await websocket.send(json.dumps(event))
+        #     await send_message_chunks(websocket,event)
             
 
         # async for line in process.stderr:
@@ -463,7 +459,7 @@ async def read_process_output(process, websocket):
         #         "type": "terminal-error",
         #         "data": line.strip().decode('utf-8'),
         #     }
-        #     await websocket.send(json.dumps(event))
+        #     await send_message_chunks(websocket,event)
 
 async def handle_user_input(websocket,key, process, connected,process_ids):
     while True:
@@ -529,14 +525,14 @@ async def handle_user_input(websocket,key, process, connected,process_ids):
                                                 "type": "terminal-data-end",
                                                
                                             }
-                                            await websocket.send(json.dumps(event))
+                                            await send_message_chunks(websocket,event)
                                             
                                         else:
                                             event = {
                                                 "type": "terminal-data-end",
                                                
                                             }
-                                            await websocket.send(json.dumps(event))
+                                            await send_message_chunks(websocket,event)
 
                                         process_ids.remove(id)
                                 
@@ -848,7 +844,7 @@ async def create_file_structure(websocket, data, base_path='.'):
             "type": "msg",
             "message": "project created",
         }
-    await websocket.send(json.dumps(event))
+    await send_message_chunks(websocket,event)
 
             
 async def error(websocket, message):
@@ -860,7 +856,7 @@ async def error(websocket, message):
         "type": "error",
         "message": message,
     }
-    await websocket.send(json.dumps(event))
+    await send_message_chunks(websocket,event)
 
 
 async def exe(websocket,connected,key,process_ids):
@@ -869,332 +865,341 @@ async def exe(websocket,connected,key,process_ids):
 
     """
     # print('in exe')
+    message_parts = {}
     async for message in websocket:
         # Parse a "play" event from the UI.
-        print(message)
-        event = json.loads(message)
-        print(event,1)
-        print(type(event),1)
-        assert event["type"] == "cmd"
-        # command = event["command"]
-        print(event,2)
-
-        try:
-            if event["command"]["type"]=="shell":
-                    base_path = os.path.join(os.getcwd(), 'projects', key,event["project_name"])
-                    directory_path = base_path
-                    event_handler = FileHandler(websocket,connected)
-                    observer = Observer()
-                    observer.schedule(event_handler, path=directory_path, recursive=True)
-                    observer.start()
-
-                    try:
-                        # await execute_command(websocket, key,event["project_name"], event["command"]["command"], connected)
-                        # base_path = os.path.join(os.getcwd(), 'projects', key,event["project_name"])
-                        print(base_path)
-                        mod_command = f'cd {base_path} && {event["command"]["command"]}'
-                        print(mod_command)
-                    
+        data = json.loads(message)
+        msg_id = data['msg_id']
+        part = data['part']
+        if msg_id not in message_parts:
+            message_parts[msg_id] = []
+        message_parts[msg_id].append(part)
+        if data['end']:
+            full_message = ''.join(message_parts[msg_id])
+            print(f"Received full message: {full_message}")
+        
+            event = json.loads(full_message)
+            del message_parts[msg_id]
+            assert event["type"] == "cmd"
+            # command = event["command"]
+            print(event,2)
+    
+            try:
+                if event["command"]["type"]=="shell":
+                        base_path = os.path.join(os.getcwd(), 'projects', key,event["project_name"])
+                        directory_path = base_path
+                        event_handler = FileHandler(websocket,connected)
+                        observer = Observer()
+                        observer.schedule(event_handler, path=directory_path, recursive=True)
+                        observer.start()
+    
                         try:
-                            process = await asyncio.create_subprocess_shell(
-                                mod_command,
-                                # cwd=base_path,
-                                stdin=asyncio.subprocess.PIPE,
-                                stdout=asyncio.subprocess.PIPE,
-                                stderr=asyncio.subprocess.PIPE,
-                                # text=True,
-                            )
-                            id=process.pid
-                            process_ids.append(id)
+                            # await execute_command(websocket, key,event["project_name"], event["command"]["command"], connected)
+                            # base_path = os.path.join(os.getcwd(), 'projects', key,event["project_name"])
+                            print(base_path)
+                            mod_command = f'cd {base_path} && {event["command"]["command"]}'
+                            print(mod_command)
+                        
+                            try:
+                                process = await asyncio.create_subprocess_shell(
+                                    mod_command,
+                                    # cwd=base_path,
+                                    stdin=asyncio.subprocess.PIPE,
+                                    stdout=asyncio.subprocess.PIPE,
+                                    stderr=asyncio.subprocess.PIPE,
+                                    # text=True,
+                                )
+                                id=process.pid
+                                process_ids.append(id)
+                        
+                                async def send_message(message):
+                                    # print('sending msg')
+                                    # await websocket.send(f'data: {message}')
+                                    websockets.broadcast(connected,json.dumps(message) )
+                        
+                                
+                        
+                                await asyncio.gather(
+                                  handle_user_input(websocket,key, process, connected,process_ids),
+                                  read_process_output(process, websocket)
+                                )
+                        
+                                return_code = await process.wait()
+                                if return_code == 0:
+                                                event = {
+                                                    "type": "terminal-data-end",
+                                                   
+                                                }
+                                                await send_message_chunks(websocket,event)
+                                                
+                                else:
+                                                event = {
+                                                    "type": "terminal-data-end",
+                                                   
+                                                }
+                                                await send_message_chunks(websocket,event)
+                                process_ids.remove(id)
+                        
+                            except Exception as e:
+                                await error(websocket, str(e))
+                        except KeyboardInterrupt:
+                            pass  # Handle KeyboardInterrupt to gracefully stop the observer
+    
+                        observer.stop()
+                        observer.join()
+                   
+                elif event["command"]["type"]=="write":
                     
-                            async def send_message(message):
-                                # print('sending msg')
-                                # await websocket.send(f'data: {message}')
-                                websockets.broadcast(connected,json.dumps(message) )
+                    await wirte_file(websocket, key,event["project_name"], event["path"], event["content"], connected)
+                elif event["command"]["type"] == "curl":
+                    method = event.get("method", "GET")
+                    url = event["url"]
+                    body = event.get("data", "")
+                    headers = event.get("headers", {})
+            
+                    if method.upper() == "GET":
+                        response = requests.get(url, headers=headers)
+                    elif method.upper() == "POST":
+                        response = requests.post(url, data=body, headers=headers)
+                    else:
+                        response = {"error": "Unsupported method"}
+            
+                    if isinstance(response, dict):
+                        response_data = {
+                            "type": "error",
+                            "data": response,
+                        }
+                        await websocket.send(json.dumps(response_data))
+                        return
+            
+                    # Parse HTML content
+                    souptmp = BeautifulSoup(response.text, "html.parser")
                     
+                            # Step 1: Define the initial HTML string
+                    html_str = """
+                            <!DOCTYPE html>
+                            <html lang="en">
+                            <head>
+                                <meta charset="UTF-8">
+                                <meta name="viewport" content="width=device-width, initial-scale=1.0">
+                                
+                            </head>
+                            <body>
+                                <h1>Hello, World!</h1>
+                            </body>
+                            </html>
+                            """
+                            
+                            # Step 2: Parse the initial HTML content
+                    soup = BeautifulSoup(html_str, 'html.parser')
                             
+                            # Step 3: Replace the existing body content with the new content from souptmp
+                    if soup.body:
+                                soup.body.clear()
+                                soup.body.append(souptmp)
+                    else:
+                                print("No <body> tag found in the HTML")
                     
-                            await asyncio.gather(
-                              handle_user_input(websocket,key, process, connected,process_ids),
-                              read_process_output(process, websocket)
-                            )
+                            # Inline CSS and JavaScript
+                    soup = inline_resources(soup, url)
+                            
+                    response_data = {
+                                "type": "web-data",
+                                "data": str(soup),
+                            }
+                    # await websocket.send(json.dumps(response_data))
+                    await send_html_chunks(websocket, soup)
                     
-                            return_code = await process.wait()
-                            if return_code == 0:
-                                            event = {
-                                                "type": "terminal-data-end",
-                                               
-                                            }
-                                            await websocket.send(json.dumps(event))
-                                            
-                            else:
-                                            event = {
-                                                "type": "terminal-data-end",
-                                               
-                                            }
-                                            await websocket.send(json.dumps(event))
-                            process_ids.remove(id)
+    
+                elif event["command"]["type"]=="create":
+                    if event["item"]=="folder":
+                        await create_folder(websocket, key,event["project_name"], event["path"],event["name"],event['root'],event['targetElementData'],event["rpath"], connected)
+                    else:
+                        await create_file(websocket, key,event["project_name"], event["path"],event["name"],event['root'],event['targetElementData'],event["rpath"], connected)
                     
-                        except Exception as e:
-                            await error(websocket, str(e))
-                    except KeyboardInterrupt:
-                        pass  # Handle KeyboardInterrupt to gracefully stop the observer
-
-                    observer.stop()
-                    observer.join()
-               
-            elif event["command"]["type"]=="write":
-                
-                await wirte_file(websocket, key,event["project_name"], event["path"], event["content"], connected)
-            elif event["command"]["type"] == "curl":
-                method = event.get("method", "GET")
-                url = event["url"]
-                body = event.get("data", "")
-                headers = event.get("headers", {})
-        
-                if method.upper() == "GET":
-                    response = requests.get(url, headers=headers)
-                elif method.upper() == "POST":
-                    response = requests.post(url, data=body, headers=headers)
-                else:
-                    response = {"error": "Unsupported method"}
-        
-                if isinstance(response, dict):
-                    response_data = {
-                        "type": "error",
-                        "data": response,
-                    }
-                    await websocket.send(json.dumps(response_data))
-                    return
-        
-                # Parse HTML content
-                souptmp = BeautifulSoup(response.text, "html.parser")
+                    
+                elif event["command"]["type"]=="delete":
+                    
+                    await delete_item(websocket, key,event["project_name"], event["path"],event['rpath'],event['targetElementData'], connected)
+                elif event["command"]["type"]=="get_content":
+                    
+                    await get_file_content(websocket, key,event["project_name"],event["filePath"], event["rfilePath"],event["fileName"] ,connected)
+                elif event["command"]["type"]=="rename":
+                    
+                    await rename_item(websocket, key,event["project_name"], event["path"],event['rpath'], event["name"], event["root"], connected)
+                elif event["command"]["type"]=="join":
+                    await join(websocket, event["join"])
+                elif event["command"]["type"]=="sendDir":
+                    data=json.loads(event["file_structure"])
+                    event = {
+                    "type": "createDir",
+                    
+                    "path": data,
+                        "root":event['root'],
+                    
+                }
+                    # websockets.broadcast(connected,json.dumps(event))
+                    websockets.broadcast(connected, json.dumps(event))
+                elif event["command"]["type"]=="createItemUI":
+                    
+                    event = {
+                    "type": "createItemUI",
+                    
+                    'targetElementData':event['targetElementData'],
+            'data':event['data']
+                    
+                }
+                    # websockets.broadcast(connected,json.dumps(event))
+                    websockets.broadcast(connected, json.dumps(event))
+    
+                elif event["command"]["type"]=="renameItemInUI":
+                    
+                    event = {
+                    "type": "renameItemInUI",
+                    
+                    'path':event['path'],
+            'new_path':event['new_path'],
+            'name':event['name'],
+            'new_rpath':event['new_rpath'],
+                    
+                }
+                    # websockets.broadcast(connected,json.dumps(event))
+                    websockets.broadcast(connected, json.dumps(event))
+                elif event["command"]["type"]=="createFolderUI":
+                    
+                    event = {
+                    "type": "createFolderUI",
+                    
+                    'targetElementData':event['targetElementData'],
+            'data':event['data']
+                    
+                }
+                    # websockets.broadcast(connected,json.dumps(event))
+                    websockets.broadcast(connected, json.dumps(event))
+    
+                elif event["command"]["type"]=="removeItemFromUI":
+                    
+                    event = {
+                    "type": "removeItemFromUI",
+                    
+                    'targetElementData':event['targetElementData'],
+            'path':event['path']
+                    
+                }
+                    # websockets.broadcast(connected,json.dumps(event))
+                    websockets.broadcast(connected, json.dumps(event))
+                    
+                elif event["command"]["type"]=="project":
+                    base_path = os.path.join(os.getcwd(), 'projects',key, event["project_name"])
+                    data=json.loads(event["file_structure"])
+                    
+                    await create_file_structure(websocket,data, base_path=base_path)
+                    # await rename_item(websocket, key,event["project_name"], event["path"], event["name"], connected)
+                elif event["command"]["type"]=="collabration":
+                    
+                    event = {
+                    "type": "collabration",
+                    'name': event["name"],
+                'line': event["cursorPos-line"],
+                        'ch': event["cursorPos-ch"],
+                        'file':event["file"],
+                'content': event["content"],
+                        'color':event["color"]
+                }
+                    websockets.broadcast(connected, json.dumps(event))
+                elif event["command"]["type"]=="cursor":
+                    
+                    event = {
+                    "type": "cursor",
+                    'offset': event["offset"],
+                        'userid': event["userid"],
+      'userlabel': event["userlabel"],
+      'usercolor': event["usercolor"],
+      'fileName':event["fileName"],
                 
-                        # Step 1: Define the initial HTML string
-                html_str = """
-                        <!DOCTYPE html>
-                        <html lang="en">
-                        <head>
-                            <meta charset="UTF-8">
-                            <meta name="viewport" content="width=device-width, initial-scale=1.0">
-                            
-                        </head>
-                        <body>
-                            <h1>Hello, World!</h1>
-                        </body>
-                        </html>
-                        """
-                        
-                        # Step 2: Parse the initial HTML content
-                soup = BeautifulSoup(html_str, 'html.parser')
-                        
-                        # Step 3: Replace the existing body content with the new content from souptmp
-                if soup.body:
-                            soup.body.clear()
-                            soup.body.append(souptmp)
-                else:
-                            print("No <body> tag found in the HTML")
+                }
+                    websockets.broadcast(connected, json.dumps(event))
+                elif event["command"]["type"]=="select":
+                    
+                    event = {
+                    "type": "select",
+                    'id': event["id"],
+                'startOffset': event["startOffset"],
+                        'endOffset': event["endOffset"],
+                        'userid': event["userid"],
+      'userlabel': event["userlabel"],
+      'usercolor': event["usercolor"],
+      'fileName':event["fileName"],
+                       
+                }
+                    websockets.broadcast(connected, json.dumps(event))
+                elif event["command"]["type"]=="addselection":
+                    
+                    event = {
+                    "type": "addselection",
+                    
+                        'userid': event["userid"],
+      'userlabel': event["userlabel"],
+      'usercolor': event["usercolor"],
+      
                 
-                        # Inline CSS and JavaScript
-                soup = inline_resources(soup, url)
+                }
+                    websockets.broadcast(connected, json.dumps(event))
+                elif event["command"]["type"]=="insert":
+                    
+                    event = {
+                    "type": "insert",
+                    'index': event["index"],
+                'text': event["text"],
+                         'userid': event["userid"],
+      'userlabel': event["userlabel"],
+      'usercolor': event["usercolor"],
+      'fileName':event["fileName"],
+                        'tabStatus':event['tabStatus'],
+                       
+                }
+                    websockets.broadcast(connected, json.dumps(event))
+                elif event["command"]["type"]=="replace":
+                    
+                    event = {
+                    "type": "replace",
+                    'index': event["index"],
+                'length': event["length"],
+                        'text': event["text"],
+                         'userid': event["userid"],
+      'userlabel': event["userlabel"],
+      'usercolor': event["usercolor"],
+      'fileName':event["fileName"],
+                      'tabStatus':event['tabStatus'],
+                }
+                    websockets.broadcast(connected, json.dumps(event))
+                elif event["command"]["type"]=="edelelte":
+                    
+                    event = {
+                    "type": "edelelte",
+                    'index': event["index"],
+                'length': event["length"],
+                         'userid': event["userid"],
+      'userlabel': event["userlabel"],
+      'usercolor': event["usercolor"],
+      'fileName':event["fileName"],
                         
-                response_data = {
-                            "type": "web-data",
-                            "data": str(soup),
-                        }
-                # await websocket.send(json.dumps(response_data))
-                await send_html_chunks(websocket, soup)
-                
-
-            elif event["command"]["type"]=="create":
-                if event["item"]=="folder":
-                    await create_folder(websocket, key,event["project_name"], event["path"],event["name"],event['root'],event['targetElementData'],event["rpath"], connected)
-                else:
-                    await create_file(websocket, key,event["project_name"], event["path"],event["name"],event['root'],event['targetElementData'],event["rpath"], connected)
-                
-                
-            elif event["command"]["type"]=="delete":
-                
-                await delete_item(websocket, key,event["project_name"], event["path"],event['rpath'],event['targetElementData'], connected)
-            elif event["command"]["type"]=="get_content":
-                
-                await get_file_content(websocket, key,event["project_name"],event["filePath"], event["rfilePath"],event["fileName"] ,connected)
-            elif event["command"]["type"]=="rename":
-                
-                await rename_item(websocket, key,event["project_name"], event["path"],event['rpath'], event["name"], event["root"], connected)
-            elif event["command"]["type"]=="join":
-                await join(websocket, event["join"])
-            elif event["command"]["type"]=="sendDir":
-                data=json.loads(event["file_structure"])
-                event = {
-                "type": "createDir",
-                
-                "path": data,
-                    "root":event['root'],
-                
-            }
-                # websockets.broadcast(connected,json.dumps(event))
-                websockets.broadcast(connected, json.dumps(event))
-            elif event["command"]["type"]=="createItemUI":
-                
-                event = {
-                "type": "createItemUI",
-                
-                'targetElementData':event['targetElementData'],
-        'data':event['data']
-                
-            }
-                # websockets.broadcast(connected,json.dumps(event))
-                websockets.broadcast(connected, json.dumps(event))
-
-            elif event["command"]["type"]=="renameItemInUI":
-                
-                event = {
-                "type": "renameItemInUI",
-                
-                'path':event['path'],
-        'new_path':event['new_path'],
-        'name':event['name'],
-        'new_rpath':event['new_rpath'],
-                
-            }
-                # websockets.broadcast(connected,json.dumps(event))
-                websockets.broadcast(connected, json.dumps(event))
-            elif event["command"]["type"]=="createFolderUI":
-                
-                event = {
-                "type": "createFolderUI",
-                
-                'targetElementData':event['targetElementData'],
-        'data':event['data']
-                
-            }
-                # websockets.broadcast(connected,json.dumps(event))
-                websockets.broadcast(connected, json.dumps(event))
-
-            elif event["command"]["type"]=="removeItemFromUI":
-                
-                event = {
-                "type": "removeItemFromUI",
-                
-                'targetElementData':event['targetElementData'],
-        'path':event['path']
-                
-            }
-                # websockets.broadcast(connected,json.dumps(event))
-                websockets.broadcast(connected, json.dumps(event))
-                
-            elif event["command"]["type"]=="project":
-                base_path = os.path.join(os.getcwd(), 'projects',key, event["project_name"])
-                data=json.loads(event["file_structure"])
-                
-                await create_file_structure(websocket,data, base_path=base_path)
-                # await rename_item(websocket, key,event["project_name"], event["path"], event["name"], connected)
-            elif event["command"]["type"]=="collabration":
-                
-                event = {
-                "type": "collabration",
-                'name': event["name"],
-            'line': event["cursorPos-line"],
-                    'ch': event["cursorPos-ch"],
-                    'file':event["file"],
-            'content': event["content"],
-                    'color':event["color"]
-            }
-                websockets.broadcast(connected, json.dumps(event))
-            elif event["command"]["type"]=="cursor":
-                
-                event = {
-                "type": "cursor",
-                'offset': event["offset"],
-                    'userid': event["userid"],
-  'userlabel': event["userlabel"],
-  'usercolor': event["usercolor"],
-  'fileName':event["fileName"],
+                      
+                }
+                    websockets.broadcast(connected, json.dumps(event))
+                elif event["command"]["type"]=="keep-alive":
+                            event = {
+            "type": "keep-alive",
             
-            }
-                websockets.broadcast(connected, json.dumps(event))
-            elif event["command"]["type"]=="select":
-                
-                event = {
-                "type": "select",
-                'id': event["id"],
-            'startOffset': event["startOffset"],
-                    'endOffset': event["endOffset"],
-                    'userid': event["userid"],
-  'userlabel': event["userlabel"],
-  'usercolor': event["usercolor"],
-  'fileName':event["fileName"],
-                   
-            }
-                websockets.broadcast(connected, json.dumps(event))
-            elif event["command"]["type"]=="addselection":
-                
-                event = {
-                "type": "addselection",
-                
-                    'userid': event["userid"],
-  'userlabel': event["userlabel"],
-  'usercolor': event["usercolor"],
-  
+        }
             
-            }
-                websockets.broadcast(connected, json.dumps(event))
-            elif event["command"]["type"]=="insert":
-                
-                event = {
-                "type": "insert",
-                'index': event["index"],
-            'text': event["text"],
-                     'userid': event["userid"],
-  'userlabel': event["userlabel"],
-  'usercolor': event["usercolor"],
-  'fileName':event["fileName"],
-                    'tabStatus':event['tabStatus'],
-                   
-            }
-                websockets.broadcast(connected, json.dumps(event))
-            elif event["command"]["type"]=="replace":
-                
-                event = {
-                "type": "replace",
-                'index': event["index"],
-            'length': event["length"],
-                    'text': event["text"],
-                     'userid': event["userid"],
-  'userlabel': event["userlabel"],
-  'usercolor': event["usercolor"],
-  'fileName':event["fileName"],
-                  'tabStatus':event['tabStatus'],
-            }
-                websockets.broadcast(connected, json.dumps(event))
-            elif event["command"]["type"]=="edelelte":
-                
-                event = {
-                "type": "edelelte",
-                'index': event["index"],
-            'length': event["length"],
-                     'userid': event["userid"],
-  'userlabel': event["userlabel"],
-  'usercolor': event["usercolor"],
-  'fileName':event["fileName"],
-                    
-                  
-            }
-                websockets.broadcast(connected, json.dumps(event))
-            elif event["command"]["type"]=="keep-alive":
-                        event = {
-        "type": "keep-alive",
-        
-    }
-        
-            else:
-                # First player starts a new game.
-                pass
-        except Exception as exc:
-            # Send an "error" event if the move was illegal.
-            await error(websocket, str(exc))
-            continue
+                else:
+                    # First player starts a new game.
+                    pass
+            except Exception as exc:
+                # Send an "error" event if the move was illegal.
+                await error(websocket, str(exc))
+                continue
 
 
 async def start(websocket,events):
@@ -1215,7 +1220,7 @@ async def start(websocket,events):
             "join": join_key,
             
         }
-        await websocket.send(json.dumps(event))
+        await send_message_chunks(websocket,event)
       
         await exe(websocket,connected,join_key,process_ids)
     finally: