Update app.py

app.py

@@ -48,7 +48,7 @@ logger = logging.getLogger(__name__)
 executor = ThreadPoolExecutor(max_workers=4)
 
 # Example HF models (replace with your actual models)
-HF_MODELS = {{{{
+HF_MODELS = {{
     "Mistral-8x7B": "mistralai/Mixtral-8x7B-Instruct-v0.1",
     "Llama-2-7B-chat": "huggingface/llama-2-7b-chat-hf",
     "CodeLlama-34B": "codellama/CodeLlama-34b-Instruct-hf",
@@ -77,12 +77,12 @@ class OTCodeEditor:
     def __init__(self, initial_value: Dict[str, str]):
         self.files: Dict[str, str] = initial_value.copy()
         self.revision = 0 # Basic revision counter, not used for OT logic
-        logger.debug(f"OTCodeEditor initialized with files: {{{{list(self.files.keys())}}")
+        logger.debug(f"OTCodeEditor initialized with files: {{list(self.files.keys())}}")
 
     def apply_delta(self, delta: Dict[str, Any]):
         # VERY basic placeholder: This logs the delta but does NOT perform OT.
         # It does NOT handle concurrent edits safely.
-        logger.warning(f"Placeholder apply_delta called. Delta: {{{{str(delta)[:200]}}. "
+        logger.warning(f"Placeholder apply_delta called. Delta: {{str(delta)[:200]}}. "
                        "WARNING: Full Operational Transformation is NOT implemented. Concurrent edits are UNSAFE.")
         # Increment revision regardless for basic tracking
         self.revision += 1
@@ -108,7 +108,7 @@ try:
         block_shadow="*shadow_drop_lg",
     )
 except AttributeError as e:
-    logger.warning(f"Could not apply all theme settings (might be Gradio version difference): {{{{e}}. Using default Soft theme.")
+    logger.warning(f"Could not apply all theme settings (might be Gradio version difference): {{e}}. Using default Soft theme.")
     theme = gr.themes.Soft()
 
 
@@ -123,25 +123,25 @@ class WebhookHandler(BaseHTTPRequestHandler):
             payload_bytes = self.rfile.read(content_length)
             payload = json.loads(payload_bytes.decode('utf-8'))
         except json.JSONDecodeError:
-            logger.error(f"Invalid JSON payload received: {{{{payload_bytes[:500]}}")
+            logger.error(f"Invalid JSON payload received: {{payload_bytes[:500]}}")
             self.send_response(400)
             self.send_header("Content-type", "text/plain")
             self.end_headers()
             self.wfile.write(b"Invalid JSON payload")
             return
         except Exception as e:
-            logger.error(f"Error reading webhook payload: {{{{e}}")
+            logger.error(f"Error reading webhook payload: {{e}}")
             self.send_response(500)
             self.end_headers()
             return
 
         event = self.headers.get('X-GitHub-Event')
         delivery_id = self.headers.get('X-GitHub-Delivery')
-        logger.info(f"Received GitHub webhook event: {{{{}event}} (Delivery ID: {{{{delivery_id}})")
+        logger.info(f"Received GitHub webhook event: {{}event}} (Delivery ID: {{delivery_id}})")
 
         if event == 'issues' and WebhookHandler.manager_instance and WebhookHandler.main_loop:
             action = payload.get('action')
-            logger.info(f"Issue action: {{{{action}}")
+            logger.info(f"Issue action: {{action}}")
             # Handle common actions that affect issue state or content
             if action in ['opened', 'reopened', 'closed', 'assigned', 'unassigned', 'edited', 'labeled', 'unlabeled', 'milestoned', 'demilestoned']:
                 if WebhookHandler.main_loop.is_running():
@@ -150,15 +150,15 @@ class WebhookHandler(BaseHTTPRequestHandler):
                         WebhookHandler.manager_instance.handle_webhook_event(event, action, payload),
                         WebhookHandler.main_loop
                     )
-                    logger.debug(f"Scheduled webhook processing for action '{{{{action}}' in main loop.")
+                    logger.debug(f"Scheduled webhook processing for action '{{action}}' in main loop.")
                 else:
                      logger.error("Asyncio event loop is not running in the target thread for webhook.")
             else:
-                 logger.info(f"Webhook action '{{{{action}}' received but not actively handled by current logic.")
+                 logger.info(f"Webhook action '{{action}}' received but not actively handled by current logic.")
         elif event == 'ping':
              logger.info("Received GitHub webhook ping.")
         else:
-            logger.warning(f"Unhandled event type: {{{{event}} or manager/loop not initialized.")
+            logger.warning(f"Unhandled event type: {{event}} or manager/loop not initialized.")
 
         self.send_response(200)
         self.send_header("Content-type", "text/plain")
@@ -2158,10 +2158,10 @@ def create_ui(manager: IssueManager) -> gr.Blocks:
             logger.info(f"Generated Client ID for WebSocket: {{client_id}}")
             return f"""
             <script>
-                (function() {{{{ // IIFE
-                    if (window.collabWsInitialized) {{{{
+                (function() {{ // IIFE
+                    if (window.collabWsInitialized) {{
                         console.log('WebSocket script already initialized. Skipping setup.');
-                        if (!window.collabWs || window.collabWs.readyState === WebSocket.CLOSED) {{{{
+                        if (!window.collabWs || window.collabWs.readyState === WebSocket.CLOSED) {{
                             console.log('Attempting reconnect from existing script...');
                             connectWebSocket();
                         }}
@@ -2176,12 +2176,12 @@ def create_ui(manager: IssueManager) -> gr.Blocks:
                     const wsPort = {{ws_port};
                     const hostname = window.location.hostname;
                     const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
-                    if (hostname === 'localhost' || hostname === '127.0.0.1' || hostname.endsWith('.gradio.live')) {{{{
-                        wsUrl = `${{{{protocol}}//${{{{hostname}}:${{{{wsPort}}`;
+                    if (hostname === 'localhost' || hostname === '127.0.0.1' || hostname.endsWith('.gradio.live')) {{
+                        wsUrl = `${{protocol}}//${{hostname}}:${{wsPort}}`;
                          console.log('Detected local/gradio.live environment, using direct WebSocket URL:', wsUrl);
-                    }} else {{{{
+                    }} else {{
                         const wsPath = '/ws';
-                        wsUrl = `${{{{protocol}}//${{{{window.location.host}}${{{{wsPath}}`;
+                        wsUrl = `${{protocol}}//${{window.location.host}}${{wsPath}}`;
                         console.log('Detected non-local environment, assuming proxied WebSocket URL:', wsUrl);
                     }}
                     let collabWs = null;
@@ -2196,42 +2196,42 @@ def create_ui(manager: IssueManager) -> gr.Blocks:
                     let editorChangeListenerAttached = false;
                     let lastSentDeltaTimestamp = 0;
                     const deltaSendDebounceMs = 250;
-                    function updateCollabList(collaborators) {{{{
+                    function updateCollabList(collaborators) {{
                         const collabListDiv = document.getElementById('collab-list');
                         if (!collabListDiv) return;
-                        const activeCollaborators = Object.entries(collaborators || {{{{}})
+                        const activeCollaborators = Object.entries(collaborators || {{}})
                             .filter(([id, info]) => id !== clientId);
-                        if (activeCollaborators.length > 0) {{{{
+                        if (activeCollaborators.length > 0) {{
                             collabListDiv.innerHTML = activeCollaborators
                                 .map(([id, info]) => `
-                                    <div class="collab-item" title="ID: ${{{{id}}">
-                                        <span style="font-weight: 500;">${{{{info.name || id.substring(0, 8)}}:</span>
-                                        <span style="color: #555;">${{{{info.status || 'Idle'}}</span>
+                                    <div class="collab-item" title="ID: ${{id}}">
+                                        <span style="font-weight: 500;">${{info.name || id.substring(0, 8)}}:</span>
+                                        <span style="color: #555;">${{info.status || 'Idle'}}</span>
                                     </div>`)
                                 .join('');
-                        }} else {{{{
+                        }} else {{
                             collabListDiv.innerHTML = '<span style="color: #6b7280;">You are the only active user.</span>';
                         }}
                     }}
-                    function updateStatusBar(message, isError = false) {{{{
+                    function updateStatusBar(message, isError = false) {{
                         const statusBar = document.querySelector('#status_output_txt textarea');
-                        if (statusBar) {{{{
+                        if (statusBar) {{
                             const timestamp = new Date().toLocaleTimeString();
-                            statusBar.value = `[${{{{timestamp}}] ${{{{message}}`;
+                            statusBar.value = `[${{timestamp}}] ${{message}}`;
                             statusBar.style.color = isError ? '#D32F2F' : '#333';
                             statusBar.style.fontWeight = isError ? 'bold' : 'normal';
                         }}
                     }}
-                    function connectWebSocket() {{{{
-                        if (collabWs && (collabWs.readyState === WebSocket.OPEN || collabWs.readyState === WebSocket.CONNECTING)) {{{{
-                            console.log(`WebSocket already ${{{{(collabWs.readyState === WebSocket.OPEN) ? 'open' : 'connecting'}}. State: ${{{{collabWs.readyState}}`);
+                    function connectWebSocket() {{
+                        if (collabWs && (collabWs.readyState === WebSocket.OPEN || collabWs.readyState === WebSocket.CONNECTING)) {{
+                            console.log(`WebSocket already ${{(collabWs.readyState === WebSocket.OPEN) ? 'open' : 'connecting'}}. State: ${{collabWs.readyState}}`);
                             return;
                         }}
-                        console.log(`Attempting WebSocket connection to ${{{{wsUrl}} (Attempt ${{{{reconnectAttempts + 1}}/${{{{maxReconnectAttempts}})...`);
-                        updateStatusBar(`Connecting collaboration service (Attempt ${{{{reconnectAttempts + 1}})...`);
-                        try {{{{
+                        console.log(`Attempting WebSocket connection to ${{wsUrl}} (Attempt ${{reconnectAttempts + 1}}/${{maxReconnectAttempts}})...`);
+                        updateStatusBar(`Connecting collaboration service (Attempt ${{reconnectAttempts + 1}})...`);
+                        try {{
                              collabWs = new WebSocket(wsUrl);
-                        }} catch (e) {{{{
+                        }} catch (e) {{
                              console.error("WebSocket constructor failed:", e);
                              updateStatusBar("Collaboration connection failed (init error).", true);
                              // Handle reconnection attempt here as well
@@ -2239,121 +2239,121 @@ def create_ui(manager: IssueManager) -> gr.Blocks:
                              return; // Prevent setting up listeners on failed constructor
                         }}
                         window.collabWs = collabWs;
-                        collabWs.onopen = function(event) {{{{
+                        collabWs.onopen = function(event) {{
                             console.log('WebSocket connection established.');
                             updateStatusBar('Collaboration connected.');
                             reconnectAttempts = 0;
-                            if(connectInterval) {{{{ clearInterval(connectInterval); connectInterval = null; }}
-                            sendWsMessage({{{{ type: 'join', clientId: clientId, name: `User_${{{{clientId.substring(0,4)}}` }});
+                            if(connectInterval) {{ clearInterval(connectInterval); connectInterval = null; }}
+                            sendWsMessage({{ type: 'join', clientId: clientId, name: `User_${{clientId.substring(0,4)}}` }});
                             setupCodeEditorListener();
                         }};
-                        collabWs.onmessage = function(event) {{{{
-                            try {{{{
+                        collabWs.onmessage = function(event) {{
+                            try {{
                                 const data = JSON.parse(event.data);
-                                if (data.type === 'collaboration_status') {{{{
+                                if (data.type === 'collaboration_status') {{
                                     updateCollabList(data.collaborators);
-                                }} else if (data.type === 'code_update') {{{{
+                                }} else if (data.type === 'code_update') {{
                                     const receivedIssueNum = parseInt(data.issue_num, 10);
-                                    if (aceEditorInstance && receivedIssueNum === currentIssueId && data.senderId !== clientId) {{{{
-                                        console.warn(`Applying remote delta for issue ${{{{receivedIssueNum}} from ${{{{data.senderId}}. WARNING: NO OT!`);
-                                        try {{{{
+                                    if (aceEditorInstance && receivedIssueNum === currentIssueId && data.senderId !== clientId) {{
+                                        console.warn(`Applying remote delta for issue ${{receivedIssueNum}} from ${{data.senderId}}. WARNING: NO OT!`);
+                                        try {{
                                             const delta = JSON.parse(data.delta);
                                             // Add ignore flag for local change listener
-                                            aceEditorInstance.getSession().getDocument().applyDeltas([{{{{...delta, ignore: true}}]);
-                                        }} catch (e) {{{{ console.error('Failed to parse or apply remote delta:', e, data.delta); }}
+                                            aceEditorInstance.getSession().getDocument().applyDeltas([{{...delta, ignore: true}}]);
+                                        }} catch (e) {{ console.error('Failed to parse or apply remote delta:', e, data.delta); }}
                                     }}
-                                }} else if (data.type === 'issues_updated') {{{{
+                                }} else if (data.type === 'issues_updated') {{
                                     console.log('Received notification: Issue list updated on server.');
                                     updateStatusBar('Issue list updated on server. Refreshing the page or re-scanning is recommended.');
                                     const crawlButton = document.getElementById('crawl_btn');
-                                    if (crawlButton) {{{{
+                                    if (crawlButton) {{
                                         crawlButton.style.backgroundColor = '#fef08a';
-                                        setTimeout(() => {{{{ crawlButton.style.backgroundColor = '' }}, 2000);
+                                        setTimeout(() => {{ crawlButton.style.backgroundColor = '' }}, 2000);
                                     }}
-                                }} else {{{{
+                                }} else {{
                                     console.warn("Received unknown WebSocket message type:", data.type, data);
                                 }}
-                            }} catch (e) {{{{
+                            }} catch (e) {{
                                 console.error('Failed to parse WebSocket message or update UI:', e, event.data);
                             }}
                         }};
-                        collabWs.onclose = function(event) {{{{
-                            console.warn(`WebSocket connection closed: Code=${{{{event.code}}, Reason='${{{{event.reason || 'N/A'}}', Clean=${{{{event.wasClean}}`);
+                        collabWs.onclose = function(event) {{
+                            console.warn(`WebSocket connection closed: Code=${{event.code}}, Reason='${{event.reason || 'N/A'}}', Clean=${{event.wasClean}}`);
                             handleWsClose(); // Centralize close handling
                         }};
-                        collabWs.onerror = function(error) {{{{
+                        collabWs.onerror = function(error) {{
                             console.error('WebSocket error event:', error);
                             updateStatusBar('Collaboration connection error.', true);
                             // onclose will likely fire after onerror.
                         }};
                     }}
-                    function handleWsClose() {{{{
+                    function handleWsClose() {{
                          const collabListDiv = document.getElementById('collab-list');
                          if (collabListDiv) collabListDiv.innerHTML = '<span style="color: #D32F2F; font-weight: bold;">Collaboration Disconnected</span>';
                          updateStatusBar('Collaboration disconnected.', true);
                          collabWs = null; window.collabWs = null;
                          aceEditorInstance = null; // Clear editor instance on disconnect
                          editorChangeListenerAttached = false; // Allow re-attaching on reconnect
-                         if (reconnectAttempts < maxReconnectAttempts) {{{{
+                         if (reconnectAttempts < maxReconnectAttempts) {{
                              const delay = Math.pow(2, reconnectAttempts) * 1500 + Math.random() * 1000;
-                             console.log(`Attempting to reconnect WebSocket in approx. ${{{{Math.round(delay / 1000)}} seconds...`);
+                             console.log(`Attempting to reconnect WebSocket in approx. ${{Math.round(delay / 1000)}} seconds...`);
                              setTimeout(connectWebSocket, delay);
                              reconnectAttempts++;
-                         }} else {{{{
+                         }} else {{
                              console.error('Max WebSocket reconnection attempts reached.');
                              updateStatusBar('Collaboration failed - Max reconnect attempts reached.', true);
                          }}
                     }}
-                    function sendWsMessage(message) {{{{
-                        if (collabWs && collabWs.readyState === WebSocket.OPEN) {{{{
-                            try {{{{
+                    function sendWsMessage(message) {{
+                        if (collabWs && collabWs.readyState === WebSocket.OPEN) {{
+                            try {{
                                 collabWs.send(JSON.stringify(message));
-                            }} catch (e) {{{{
+                            }} catch (e) {{
                                 console.error("Failed to stringify or send WebSocket message:", e, message);
                             }}
-                        }} else {{{{
+                        }} else {{
                             console.warn('WebSocket not connected. Cannot send message:', message);
                         }}
                     }}
                     window.sendWsMessage = sendWsMessage;
-                    function setupCodeEditorListener() {{{{
+                    function setupCodeEditorListener() {{
                         // Find the ACE editor instance managed by the Gradio component
                         // This relies on the internal structure of gradio_code_editor
                         const editorElement = document.querySelector('#code_editor_component .ace_editor');
-                        if (typeof ace === 'undefined' || !editorElement) {{{{
-                            if (editorSetupAttempts < maxEditorSetupAttempts) {{{{
-                                console.warn(`Ace library or editor element not found yet. Retrying editor setup (${{{{editorSetupAttempts + 1}}/${{{{maxEditorSetupAttempts}})...`);
+                        if (typeof ace === 'undefined' || !editorElement) {{
+                            if (editorSetupAttempts < maxEditorSetupAttempts) {{
+                                console.warn(`Ace library or editor element not found yet. Retrying editor setup (${{editorSetupAttempts + 1}}/${{maxEditorSetupAttempts}})...`);
                                 editorSetupAttempts++;
                                 setTimeout(setupCodeEditorListener, 1500 + Math.random() * 500);
-                            }} else {{{{
+                            }} else {{
                                 console.error("Ace library or editor element not found after multiple attempts. Code editor collaboration disabled.");
                                 updateStatusBar("Code editor library or UI element failed to load.", true);
                             }}
                             return;
                         }}
                         // Prevent double initialization
-                        if (editorElement.dataset.collabInitialized === 'true' && aceEditorInstance) {{{{
+                        if (editorElement.dataset.collabInitialized === 'true' && aceEditorInstance) {{
                             // Editor is already set up, just ensure the correct issue ID is tracked
                             updateTrackedIssueId();
                             return;
                         }}
-                        try {{{{
+                        try {{
                             // Get the ACE editor instance
                             aceEditorInstance = ace.edit(editorElement);
-                            if (!aceEditorInstance) {{{{ throw new Error("ace.edit(element) returned null or undefined."); }}
+                            if (!aceEditorInstance) {{ throw new Error("ace.edit(element) returned null or undefined."); }}
                             console.log('Ace Editor instance acquired successfully:', aceEditorInstance);
                             editorElement.dataset.collabInitialized = 'true'; // Mark as initialized
-                            if (!editorChangeListenerAttached) {{{{
+                            if (!editorChangeListenerAttached) {{
                                 console.log("Attaching Ace editor 'change' listener...");
-                                aceEditorInstance.getSession().on('change', function(delta) {{{{
+                                aceEditorInstance.getSession().on('change', function(delta) {{
                                     // Check for the custom 'ignore' flag added when applying remote deltas
-                                    if (delta.ignore) {{{{ return; }} // Ignore remote changes
-                                    if (currentIssueId !== null) {{{{
+                                    if (delta.ignore) {{ return; }} // Ignore remote changes
+                                    if (currentIssueId !== null) {{
                                         const now = Date.now();
                                         // Simple debounce to avoid flooding server
-                                        if (now - lastSentDeltaTimestamp > deltaSendDebounceMs) {{{{
-                                            console.debug(`User change detected on issue ${{{{currentIssueId}}. Sending delta:`, delta);
-                                            sendWsMessage({{{{
+                                        if (now - lastSentDeltaTimestamp > deltaSendDebounceMs) {{
+                                            console.debug(`User change detected on issue ${{currentIssueId}}. Sending delta:`, delta);
+                                            sendWsMessage({{
                                                 type: 'code_update',
                                                 issue_num: currentIssueId,
                                                 delta: JSON.stringify(delta),
@@ -2364,37 +2364,37 @@ def create_ui(manager: IssueManager) -> gr.Blocks:
                                     }}
                                 }});
                                 // Add focus/blur listeners for status updates
-                                aceEditorInstance.on('focus', () => {{{{
-                                    if(currentIssueId !== null) {{{{
-                                        sendWsMessage({{{{ type: 'status_update', clientId: clientId, status: `Editing Issue #${{{{currentIssueId}}`}});
+                                aceEditorInstance.on('focus', () => {{
+                                    if(currentIssueId !== null) {{
+                                        sendWsMessage({{ type: 'status_update', clientId: clientId, status: `Editing Issue #${{currentIssueId}}`}});
                                     }}
                                 }});
-                                aceEditorInstance.on('blur', () => {{{{
-                                    const status = currentIssueId !== null ? `Viewing Issue #${{{{currentIssueId}}` : 'Idle';
-                                    sendWsMessage({{{{ type: 'status_update', clientId: clientId, status: status}});
+                                aceEditorInstance.on('blur', () => {{
+                                    const status = currentIssueId !== null ? `Viewing Issue #${{currentIssueId}}` : 'Idle';
+                                    sendWsMessage({{ type: 'status_update', clientId: clientId, status: status}});
                                 }});
                                 editorChangeListenerAttached = true;
                                 console.log('Ace editor listeners attached successfully.');
                             }}
                             editorSetupAttempts = 0; // Reset attempts on success
                             updateTrackedIssueId(); // Ensure correct issue ID is tracked after setup
-                        }} catch (e) {{{{
+                        }} catch (e) {{
                              console.error('Failed to initialize Ace editor instance or attach listeners:', e);
                              if (editorElement) delete editorElement.dataset.collabInitialized; // Allow retry
                              aceEditorInstance = null;
                              editorChangeListenerAttached = false;
-                             if (editorSetupAttempts < maxEditorSetupAttempts) {{{{
-                                 console.warn(`Retrying editor setup after error (${{{{editorSetupAttempts + 1}}/${{{{maxEditorSetupAttempts}})...`);
+                             if (editorSetupAttempts < maxEditorSetupAttempts) {{
+                                 console.warn(`Retrying editor setup after error (${{editorSetupAttempts + 1}}/${{maxEditorSetupAttempts}})...`);
                                  editorSetupAttempts++;
                                  setTimeout(setupCodeEditorListener, 2000 + Math.random() * 500);
-                             }} else {{{{
+                             }} else {{
                                  console.error("Max editor setup attempts failed after error. Collaboration disabled.");
                                  updateStatusBar("Code editor setup failed repeatedly.", true);
                              }}
                         }}
                     }}
                     // Function to update the internally tracked issue ID
-                    function updateTrackedIssueId() {{{{
+                    function updateTrackedIssueId() {{
                         // This is the most fragile part, relying on Gradio's internal structure.
                         // We need to find the hidden input element that Gradio uses to store the
                         // state variable 'selected_issue_id_state'. Its exact location/attributes
@@ -2404,32 +2404,32 @@ def create_ui(manager: IssueManager) -> gr.Blocks:
                         // This is heuristic and might need adjustment if Gradio changes significantly.
                         let newIssueId = null;
                         const hiddenInputs = document.querySelectorAll('input[type="hidden"]');
-                        for (const input of hiddenInputs) {{{{
+                        for (const input of hiddenInputs) {{
                             const value = input.value;
-                            if (value && value !== 'null' && /^\d+$/.test(value)) {{{{
+                            if (value && value !== 'null' && /^\d+$/.test(value)) {{
                                 // Found a hidden input with an integer value.
                                 // Is it *our* hidden state input? Hard to tell definitively.
                                 // We'll assume the most recently updated one with an integer value
                                 // *might* be it, or just the first one we find.
                                 // A more robust way would require Gradio to expose component IDs to JS.
-                                try {{{{
+                                try {{
                                      // Check if it's likely the state variable by looking at nearby elements or parent structure if possible
                                      // This is still very hacky. Let's just parse the first plausible one for now.
                                      newIssueId = parseInt(value, 10);
                                      // Found a potential ID, stop searching
                                      break;
-                                }} catch (e) {{{{
+                                }} catch (e) {{
                                      console.debug("Could not parse hidden input value as int:", value, e);
                                 }}
                             }}
                         }}
-                        if (newIssueId !== currentIssueId) {{{{
-                            console.log(`Updating tracked issue ID: from ${{{{currentIssueId}} to ${{{{newIssueId}}`);
+                        if (newIssueId !== currentIssueId) {{
+                            console.log(`Updating tracked issue ID: from ${{currentIssueId}} to ${{newIssueId}}`);
                             currentIssueId = newIssueId;
-                            const status = currentIssueId !== null ? `Viewing Issue #${{{{currentIssueId}}` : 'Idle';
-                            sendWsMessage({{{{ type: 'status_update', clientId: clientId, status: status}});
+                            const status = currentIssueId !== null ? `Viewing Issue #${{currentIssueId}}` : 'Idle';
+                            sendWsMessage({{ type: 'status_update', clientId: clientId, status: status}});
                             // If we just got a new issue ID and the editor wasn't set up, try setting it up
-                            if (currentIssueId !== null && !aceEditorInstance) {{{{
+                            if (currentIssueId !== null && !aceEditorInstance) {{
                                 clearTimeout(window.setupEditorTimeout);
                                 window.setupEditorTimeout = setTimeout(setupCodeEditorListener, 250);
                             }}
@@ -2441,18 +2441,18 @@ def create_ui(manager: IssueManager) -> gr.Blocks:
                     // for changes that might indicate a new issue has been selected (which
                     // updates the hidden state variable and potentially the editor component).
                     const observerTargetNode = document.body; // Observe the entire body
-                    const observerConfig = {{{{ childList: true, subtree: true, attributes: true, attributeFilter: ['value'] }};
-                    const observerCallback = (mutationsList, observer) => {{{{
+                    const observerConfig = {{ childList: true, subtree: true, attributes: true, attributeFilter: ['value'] }};
+                    const observerCallback = (mutationsList, observer) => {{
                         let editorNeedsCheck = false;
                         let issueIdCheckNeeded = false;
-                        for (const mutation of mutationsList) {{{{
+                        for (const mutation of mutationsList) {{
                              // Check if the code editor component or its contents changed
                              if (mutation.target.closest('#code_editor_component') ||
-                                 (mutation.target.id === 'code_editor_component' && mutation.type === 'childList')) {{{{
+                                 (mutation.target.id === 'code_editor_component' && mutation.type === 'childList')) {{
                                  editorNeedsCheck = true;
                              }}
                              // Check if any hidden input's value changed
-                             if (mutation.type === 'attributes' && mutation.attributeName === 'value' && mutation.target.type === 'hidden') {{{{
+                             if (mutation.type === 'attributes' && mutation.attributeName === 'value' && mutation.target.type === 'hidden') {{
                                  // We can't be sure *which* hidden input changed is the one we care about
                                  // without more specific info, so we'll just trigger the check
                                  // of all hidden inputs whenever any hidden input value changes.
@@ -2460,27 +2460,27 @@ def create_ui(manager: IssueManager) -> gr.Blocks:
                              }}
                              // Also check childList changes on the main Gradio container, as this
                              // might indicate components being added/removed or updated.
-                             if (mutation.type === 'childList' && mutation.target.classList && mutation.target.classList.contains('gradio-container')) {{{{
+                             if (mutation.type === 'childList' && mutation.target.classList && mutation.target.classList.contains('gradio-container')) {{
                                   issueIdCheckNeeded = true; // Assume issue ID might have changed if main container children change
                                   editorNeedsCheck = true; // Editor might have been re-rendered
                              }}
                         }}
-                        if (editorNeedsCheck) {{{{
+                        if (editorNeedsCheck) {{
                             // Debounce editor setup check
                             clearTimeout(window.setupEditorTimeout);
                             window.setupEditorTimeout = setTimeout(setupCodeEditorListener, 250);
                         }}
-                        if (issueIdCheckNeeded) {{{{
+                        if (issueIdCheckNeeded) {{
                              // Debounce issue ID check
                              clearTimeout(window.issueIdCheckTimeout);
                              window.issueIdCheckTimeout = setTimeout(updateTrackedIssueId, 100); // Shorter debounce for responsiveness
                         }}
                     }};
                     const observer = new MutationObserver(observerCallback);
-                    if (observerTargetNode) {{{{
+                    if (observerTargetNode) {{
                         console.log("Starting MutationObserver to detect Gradio UI changes (incl. hidden state).");
                         observer.observe(observerTargetNode, observerConfig);
-                    }} else {{{{
+                    }} else {{
                         console.error("Could not find observer target node (document.body).");
                     }}
                     // Initial setup attempts
@@ -2662,7 +2662,7 @@ if __name__ == "__main__":
     except KeyboardInterrupt:
         logger.info("Gradio app interrupted. Initiating shutdown...")
     except Exception as e:
-        logger.exception(f"An unexpected error occurred: {{{{e}}")
+        logger.exception(f"An unexpected error occurred: {{e}}")
     finally:
         # Ensure graceful shutdown of tasks
         logger.info("Cancelling WebSocket server task...")
@@ -2673,7 +2673,7 @@ if __name__ == "__main__":
             except asyncio.CancelledError:
                 pass
             except Exception as e:
-                logger.error(f"Error during WebSocket cancellation: {{{{e}}")
+                logger.error(f"Error during WebSocket cancellation: {{e}}")
 
         # Stop the main asyncio loop
         if main_loop.is_running():