app.py

import asyncio 
import json
import os
import secrets
import signal
import subprocess
import websockets
import shutil
from connect4 import PLAYER1, PLAYER2, Connect4
from user import User
import requests
from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler
from bs4 import BeautifulSoup
from urllib.parse import urlparse, urljoin
import math
import uuid


def is_absolute(url):
    return bool(urlparse(url).netloc)

def handle_protocol_relative(url, base_url):
    if url.startswith("//"):
        parsed_base_url = urlparse(base_url)
        return f"{parsed_base_url.scheme}:{url}"
    return url

def inline_resources(soup, base_url):
    # Inline CSS
    for link_tag in soup.find_all('link', rel='stylesheet'):
        href = link_tag.get('href')
        if href:
            href = handle_protocol_relative(href, base_url)
            full_url = urljoin(base_url, href) if not is_absolute(href) else href
            css_response = requests.get(full_url)
            if css_response.status_code == 200:
                style_tag = soup.new_tag('style')
                style_tag.string = css_response.text
                link_tag.replace_with(style_tag)

    # Inline JavaScript
    for script_tag in soup.find_all('script', src=True):
        src = script_tag.get('src')
        if src:
            src = handle_protocol_relative(src, base_url)
            full_url = urljoin(base_url, src) if not is_absolute(src) else src
            js_response = requests.get(full_url)
            if js_response.status_code == 200:
                script_tag.string = js_response.text
                del script_tag['src']

    return soup

async def send_html_chunks(websocket, soup):
    
        
            # Convert the BeautifulSoup object back to a string and split into lines
        html_str = str(soup)
        lines = html_str.split('\n')
        
        # Send each line as a separate chunk
        for line in lines:
            line = line.strip()
            if line:  # Send non-empty lines
                await websocket.send(json.dumps({"type": "chunk", "content": line}))
        
        await websocket.send(json.dumps({"type": "end",}))
    
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):
        return 'w'  # If content is a string, it's text
    elif isinstance(content, bytes):
        return 'wb'  # If content is bytes, it's binary
    else:
        raise ValueError("Unsupported content type. Expected str or bytes.")
class FileHandler(FileSystemEventHandler):
    def __init__(self, websocket,connected):
        super().__init__()
        self.websocket = websocket
        self.connected = connected
    def on_modified(self, event):
        if event.is_directory:
            return
        with open(event.src_path, 'r', encoding='utf-8') as file:
            content = file.read()
        print(f'File {event.src_path} has been modified.')
        new_event = {
                "type": "file-modifie",
                "content": content,
        "path": event.src_path,
          }
        websockets.broadcast(self.connected,json.dumps(new_event))
        # websockets.broadcast(self.connected,f'File {event.src_path} has been modified.')

    def on_created(self, event):
        if event.is_directory:
            new_event = {
                "type": "folder-create",
                
        "path": event.src_path,
            "name": event.src_path.split('/')[-1]
          }
            # print(new_event)
            websockets.broadcast(self.connected,json.dumps(new_event))
        else:
            with open(event.src_path, 'r', encoding='utf-8') as file:
                content = file.read()
            print(f'File {event.src_path} has been created.')
            new_event = {
                    "type": "file-create",
                    "content": content,
            "path": event.src_path,
                "name": event.src_path.split('/')[-1]
              }
            # print(new_event)
            websockets.broadcast(self.connected,json.dumps(new_event))
        # websockets.broadcast(self.connected,f'File {event.src_path} has been created.')

    def on_deleted(self, event):
        if event.is_directory:
            new_event = {
                "type": "delete",
                
        "path": event.src_path,
            "name": event.src_path.split('/')[-1],
          }
            websockets.broadcast(self.connected,json.dumps(new_event))
        else:
            print(f'File {event.src_path} has been deleted.')
            new_event = {
                    "type": "delete",
                    "name": event.src_path.split('/')[-1],
            "path": event.src_path,
              }
            print(event.src_path)
            websockets.broadcast(self.connected,json.dumps(new_event))

    def on_moved(self, event):
        if event.is_directory:
            new_event = {
                "type": "rename",
                
        "OldPath": event.src_path,
            "oldname": event.src_path.split('/')[-1],
            "NewPath": event.dest_path,
        "newname": event.dest_path.split('/')[-1],
          }
            websockets.broadcast(self.connected,json.dumps(new_event))
        else:
            # print(f'File {event.src_path} has been renamed to {event.dest_path}.')
            new_event = {
                    "type": "rename",
                    
            "OldPath": event.src_path,
                "oldname": event.src_path.split('/')[-1],
                "NewPath": event.dest_path,
            "newname": event.dest_path.split('/')[-1],
              }
            websockets.broadcast(self.connected,json.dumps(new_event))

JOIN = {}

WATCH = {}

async def generate_file_structure(path, encoding='utf-8'):
  file_structure = {'name': os.path.basename(path), 'type': 'folder', 'path': path, 'children': []}
  
  try:
      entries = os.listdir(path)
  except FileNotFoundError:
      return file_structure  # Return an empty structure for non-existing directories
  
  for entry in entries:
      entry_path = os.path.join(path, entry)
      if os.path.isdir(entry_path):
          child_structure =await generate_file_structure(entry_path, encoding)
          file_structure['children'].append(child_structure)
      elif os.path.isfile(entry_path):
          try:
              with open(entry_path, 'r', encoding=encoding) as file:
                  content = file.read()
          except UnicodeDecodeError:
              content = 'Unable to read content'
          file_structure['children'].append({'name': entry, 'type': 'file', 'path': entry_path, 'content': content})
  
  return file_structure

async def rename_item(websocket, key,project_name, path,rpath,new_name,root, connected):
    
    old_path = os.path.join(os.getcwd(),'projects', key,project_name, rpath)
    new_name = new_name
    new_path = os.path.join(os.path.dirname(old_path), new_name)
    try:
        if os.path.exists(old_path):
            # Determine the new path
            

            # Rename the file or folder
            os.rename(old_path, new_path)

            websockets.broadcast(connected,'success')
            event = {
                "type": "rename-success",
                "data": f'{old_path}-->{new_path}',
                "path": path,
                "new_rpath":rpath,
                "name": new_name,
                "root":root,
            }
            websockets.broadcast(connected,json.dumps(event))
        else:
            event = {
                "type": "rename-failed",
                "data": f'{old_path}-->{new_path} failed Item not found',
                "old_path": path,
                "new_name": new_name,
            }
            websockets.broadcast(connected,json.dumps(event))
    except Exception as e:
        websockets.broadcast(connected,str(e))

async def delete_item(websocket, key,project_name, path,rpath,targetElementData, connected):
          try:
              
              item_path = os.path.join(os.getcwd(), 'projects', key,project_name, rpath)

              if os.path.exists(item_path):
                  if os.path.isdir(item_path):
                    shutil.rmtree(item_path)  # Remove the directory and its contents
                  elif os.path.isfile(item_path):
                      os.remove(item_path)  # Remove the file
                    
                  event = {
                "type": "delete-success",
                "data": path,
                    "path":path,
                      "targetElementData":targetElementData,
            }
                  # print(event)
                  websockets.broadcast(connected,json.dumps(event))
                  # websockets.broadcast(connected,'success')
              else:
                  event = {
                "type": "delete-failed",
                "data": f'{item_path} Item not found',
            }
                  websockets.broadcast(connected,json.dumps(event))
          except Exception as e:
              # print(e)
              websockets.broadcast(connected,str(e))

async def get_file_content(websocket, key,project_name, path,rpath,name,connected):
    
    file_path = os.path.join(os.getcwd(), 'projects', key,project_name, rpath)

    try:
        try:
            with open(file_path, 'r') as file:
                content = file.read()
            event = {
            "type": "content",
            "content": content,
                'fileName':name,
                'rfilePath':rpath,
                'filePath':path,
        }
            await send_message_chunks(websocket,event)
        except UnicodeDecodeError:
            with open(file_path, 'rb') as file:
                content = file.read()
            event = {
            "type": "content",
            "content": content,
                'fileName':name,
                'rfilePath':rpath,
                'filePath':path,
        }
            await send_message_chunks(websocket,event)
    except Exception as e:
        event = {
        "type": "error",
        "message": f"Failed to read file content: {str(e)}",
            }
        await send_message_chunks(websocket,event)
        


async def create_file(websocket, key,project_name, path,name,root,targetElementData,rpath, connected):
    file_path = os.path.join(os.getcwd(), 'projects', key,project_name, rpath,name)
    # Create the file
    with open(file_path, 'w'):
            pass
    event = {
                "type": "file-created",
                "data": file_path,
        "path": path,
                "name": name,
        "root":root,
        "targetElementData":targetElementData,
            }
    websockets.broadcast(connected,json.dumps(event))
    

async def create_folder(websocket, key,project_name, path,name,root,targetElementData,rpath, connected):
    folder_path = os.path.join(os.getcwd(), 'projects', key,project_name, rpath,name)
    # Create the folder
    os.makedirs(folder_path)
    event = {
                "type": "folder-created",
                "data": folder_path,
        "path": path,
                "name": name,
        "root":root,
        "targetElementData":targetElementData,
            }
    # print(folder_path,'created')
    websockets.broadcast(connected,json.dumps(event))
    


async def wirte_file(websocket, key,project_name, path, content, connected):
    try:
        file_path = os.path.join(os.getcwd(), 'projects', key,project_name, path)
        file_content = content
        mode = auto_detect_mode(content)
        with open(file_path, mode) as file:
            file.write(file_content)

        event = {
                "type": "write-success",
                "data": file_path,
            "path": path,
                "content": content,
            }
        # websockets.broadcast(connected,json.dumps(event))
    except FileNotFoundError as e:
        event = {
                "type": "write-error",
                "data": e,
            }
        websockets.broadcast(connected,json.dumps(event))

async def read_process_output(process, websocket):
    # Read the output and error byte by byte and print word by word
    word = b''
    while True:
        char = await process.stdout.read(1)
        if char == b'\n':
            if word:
                print(word.decode('utf-8'),1)
                event = {
                "type": "terminal-data",
                "data": word.decode('utf-8'),
            }
                print('sending data',1)
                await send_message_chunks(websocket,event)
                word = b''
            print("line is completed")
            event = {
                "type": "terminal-newline",
                "data": "",
            }
            await send_message_chunks(websocket,event)
        elif char == b' ':
            if word:
                print(word.decode('utf-8'),2)
                event = {
                "type": "terminal-data",
                "data": word.decode('utf-8'),
            }
                print('sending data',2)
                await send_message_chunks(websocket,event)
                word = b''
            print("space is occurred")
            event = {
                "type": "terminal-data",
                "data": " ",
            }
            print('sending data',3)
            await send_message_chunks(websocket,event)
        elif char == b'':
            if word:
                print(word.decode('utf-8'),3)
                event = {
                "type": "terminal-data",
                "data": word.decode('utf-8'),
            }
                print('sending data',4)
                await send_message_chunks(websocket,event)
            break
        else:
            word += char
    
    while True:
        char = await process.stderr.read(1)
        if char == b'\n':
            if word:
                print(word.decode('utf-8'))
                event = {
                "type": "terminal-error",
                "data": word.decode('utf-8'),
            }
                await send_message_chunks(websocket,event)
                word = b''
            print("line is completed")
            event = {
                "type": "terminal-newline",
                "data": "",
            }
            await send_message_chunks(websocket,event)
        elif char == b' ':
            if word:
                print(word.decode('utf-8'))
                event = {
                "type": "terminal-error",
                "data": word.decode('utf-8'),
            }
                await send_message_chunks(websocket,event)
                word = b''
            print("space is occurred")
            event = {
                "type": "terminal-error",
                "data": " ",
            }
            await send_message_chunks(websocket,event)
        elif char == b'':
            if word:
                print(word.decode('utf-8'))
            break
        else:
            word += char
        # async for line in process.stdout:
        #     # print('sending line')
            
        #     event = {
        #         "type": "terminal-data",
        #         "data": line.strip().decode('utf-8'),
        #     }
        #     await send_message_chunks(websocket,event)
            

        # async for line in process.stderr:
        #     # print(f'error:{line.strip()}')
        #     event = {
        #         "type": "terminal-error",
        #         "data": line.strip().decode('utf-8'),
        #     }
        #     await send_message_chunks(websocket,event)

async def handle_user_input(websocket,key, process, connected,process_ids):
    while True:
        try:
            await asyncio.sleep(0.1)
            if process.returncode is not None:
                break
            # message = await websocket.recv()
            async for message in websocket:
                # user_input = json.loads(message)
                # print(user_input)
                # print(f'Received user input: {user_input["command"]["command"]}')
                
                # process_input(user_input["command"]["command"], process)
                event = json.loads(message)
                assert event["type"] == "cmd"
                # command = event["command"]
                print(f'Received user input: {event}')
                try:
                    if event["command"]["type"]=="shell":
                            await asyncio.sleep(0.1)
                            if process.returncode is not None:
                                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)
                                
                                    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()
                            else:
                                await process_input(event["command"]["command"], process)
                       
                    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")
                
                        # 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")
                
                        # Inline CSS and JavaScript
                        soup = inline_resources(soup, url)
                        
                        response_data = {
                            "type": "web-data",
                            "data": str(soup),
                        }
                        await websocket.send(json.dumps(response_data))
                        # Convert the final soup to a string
                        

                    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"]=="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"],
                           
                    }
                        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"],
                          
                    }
                        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",
        
    }
                        websockets.broadcast(connected, json.dumps(event))
                    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
                break
        except websockets.ConnectionClosed:
            print("WebSocket connection closed")
            break
        except Exception as e:
            print(f"Error in input thread: {str(e)}")
            pass

async def process_input(user_input, process):
    
    if process:
        try:
            
            if user_input == 'Ctrl+C':
                print('Stopping process')
                 # Send Ctrl+C signal to the subprocess
                process.send_signal(signal.SIGINT)
                os.killpg(os.getpgid(process.pid), signal.SIGTERM)
                # Read output and error asynchronously
                # os.kill(int(process.pid), signal.CTRL_C_EVENT)
                print('stoping signal sent')
                
            else:
                print(user_input)
                process.stdin.write(user_input.encode('utf-8') + b'\n')
                # process.stdin.flush()
        except Exception as e:
            print(f"Error writing to process stdin: {str(e)}")
    else:
        print("No process available to write to.")

async def create_file_structure(websocket, data, base_path='.'):
    if data['type'] == 'folder':
        folder_path = os.path.join(base_path, data['name'])
        os.makedirs(folder_path, exist_ok=True)
        for child in data['children']:
            await create_file_structure(websocket,child, base_path=folder_path)
    elif data['type'] == 'file':
        mode = auto_detect_mode(data['content'])
        file_path = os.path.join(base_path, data['name'])
        with open(file_path,mode) as file:
            file.write(data['content'])

    event = {
            "type": "msg",
            "message": "project created",
        }
    await send_message_chunks(websocket,event)

            
async def error(websocket, message):
    """
    Send an error message.

    """
    event = {
        "type": "error",
        "message": message,
    }
    await send_message_chunks(websocket,event)


async def exe(websocket,connected,key,process_ids):
    """
    Receive and process moves from a player.

    """
    # print('in exe')
    message_parts = {}
    async for message in websocket:
        # Parse a "play" event from the UI.
        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:
                            # 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":
                    
                    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")
                    
                            # 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)
                    
    
                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"]=="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


async def start(websocket,events):

    user = User()
    connected = {websocket}
    process_ids = []
    

    join_key = secrets.token_urlsafe(12)
    JOIN[join_key] = user, connected


    try:
        # Send the secret access tokens to the browser of the first player,
        # where they'll be used for building "join" and "watch" links.
        event = {
            "type": "init",
            "join": join_key,
            
        }
        await send_message_chunks(websocket,event)
      
        await exe(websocket,connected,join_key,process_ids)
    finally:
        del JOIN[join_key]
        project_path = os.path.join(os.getcwd(), 'projects', JOIN[join_key])
        shutil.rmtree(project_path)
        for id in process_ids:
            os.killpg(os.getpgid(id), signal.SIGTERM)
        


async def join(websocket, key):
    """
    Handle a connection from the second player: join an existing game.

    """
    # Find the Connect Four game.
    try:
        user, connected = JOIN[key]
    except KeyError:
        await error(websocket, "collabration not found.")
        return

    # Register to receive moves from this game.
    connected.add(websocket)
    try:
        event = {
                "type": "sendDir",
     }
        websockets.broadcast(connected,json.dumps(event))
        await exe(websocket,connected,key)
    finally:
        connected.remove(websocket)

async def handler(websocket):
    """
    Handle a connection and dispatch it according to who is connecting.

    """
    # Receive and parse the "init" event from the UI.
    
    message_parts = {}
    async for message in websocket:
        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)
           
            if event["type"] == "init":
                if "join" in event:
                    # Second player joins an existing game.
                    await join(websocket, event["join"])
                else:
                    # First player starts a new game.
                    await start(websocket, full_message)
            elif event["type"] == "cmd":
                # print('executing commad')
                # Execute a command in the project folder.
                await execute_command(websocket, event["project_name"], event["command"])

async def main():
    # Set the stop condition when receiving SIGTERM.
    loop = asyncio.get_running_loop()
    stop = loop.create_future()
    loop.add_signal_handler(signal.SIGTERM, stop.set_result, None)

    port = int(os.environ.get("PORT", "7860"))
    async with websockets.serve(handler, "0.0.0.0", port):
        await stop


if __name__ == "__main__":
    asyncio.run(main())