Coderabbit fixes

Author: Tooru

gui/qa/main.js

@@ -244,7 +244,13 @@ function listenToRun(runId) {
   };
 
   socket.onmessage = (event) => {
-    const data = JSON.parse(event.data);
+    let data;
+    try {
+      data = JSON.parse(event.data);
+    } catch (e) {
+      console.error('Failed to parse WebSocket message', e);
+      return;
+    }
     switch (data.type) {
       case 'init':
         setupRunView(data.metadata, runId);
@@ -329,19 +335,25 @@ function updateAttemptRow(event) {
     row = document.createElement('tr');
     row.classList.add('fade-in');
     const levelLabel = levelKey && levelKey !== 'base' ? levelKey : '—';
-    row.innerHTML = `
-      <td>${event.question_number ?? '—'}</td>
-      <td>${event.model || '—'}</td>
-      <td>${levelLabel}</td>
-      <td class="status-cell"></td>
-      <td>-</td>
-      <td>-</td>
-      <td>-</td>
-      <td>-</td>
-      <td class="breakable"></td>
-      <td class="breakable"></td>
-      <td></td>
-    `;
+    const cellData = [
+      { text: event.question_number ?? '—' },
+      { text: event.model || '—' },
+      { text: levelLabel },
+      { text: '', className: 'status-cell' },
+      { text: '-' },
+      { text: '-' },
+      { text: '-' },
+      { text: '-' },
+      { text: '', className: 'breakable' },
+      { text: '', className: 'breakable' },
+      { text: '' },
+    ];
+    cellData.forEach((cell) => {
+      const td = document.createElement('td');
+      td.textContent = cell.text;
+      if (cell.className) td.className = cell.className;
+      row.appendChild(td);
+    });
     // Track ordering metadata
     row.dataset.question = String(event.question_number ?? '0');
     row.dataset.level = levelKey;
@@ -516,15 +528,26 @@ async function refreshLeaderboard() {
       const levelLabel = row.thinking_level && row.thinking_level !== 'base'
         ? row.thinking_level
         : '—';
-      tr.innerHTML = `
-        <td>${row.model_id}</td>
-        <td>${formatAccuracy(row.accuracy)}</td>
-        <td>${formatCost(row.cost_usd)}</td>
-        <td>${row.duration_seconds != null ? Number(row.duration_seconds).toFixed(2) : '—'}</td>
-        <td>${row.runs ?? '—'}</td>
-        <td>${levelLabel}</td>
-        <td><button class="danger" data-model="${row.model_id}">Clear</button></td>
-      `;
+      const cellValues = [
+        row.model_id,
+        formatAccuracy(row.accuracy),
+        formatCost(row.cost_usd),
+        row.duration_seconds != null ? Number(row.duration_seconds).toFixed(2) : '—',
+        row.runs ?? '—',
+        levelLabel,
+      ];
+      cellValues.forEach((text) => {
+        const td = document.createElement('td');
+        td.textContent = text;
+        tr.appendChild(td);
+      });
+      const btnCell = document.createElement('td');
+      const btn = document.createElement('button');
+      btn.className = 'danger';
+      btn.dataset.model = row.model_id;
+      btn.textContent = 'Clear';
+      btnCell.appendChild(btn);
+      tr.appendChild(btnCell);
       leaderboardBody.appendChild(tr);
     });
   } catch (error) {
@@ -575,25 +598,38 @@ async function refreshHistory() {
     const rows = Array.isArray(data.runs) ? data.runs : [];
     if (!rows.length) {
       const emptyRow = document.createElement('tr');
-      emptyRow.innerHTML = '<td colspan="6" class="empty-state">No question runs yet.</td>';
+      const emptyTd = document.createElement('td');
+      emptyTd.colSpan = 6;
+      emptyTd.className = 'empty-state';
+      emptyTd.textContent = 'No question runs yet.';
+      emptyRow.appendChild(emptyTd);
       historyBody.appendChild(emptyRow);
       return;
     }
     rows.forEach((row) => {
       const tr = document.createElement('tr');
-      tr.innerHTML = `
-        <td>${row.run_id}</td>
-        <td>${formatTimestamp(row.timestamp_utc)}</td>
-        <td>${row.model_id || '—'}</td>
-        <td>${formatAccuracy(row.accuracy)}</td>
-        <td>${formatCost(row.total_cost_usd)}</td>
-        <td>${row.total_duration_seconds != null ? Number(row.total_duration_seconds).toFixed(2) : '—'}</td>
-      `;
+      const cells = [
+        row.run_id,
+        formatTimestamp(row.timestamp_utc),
+        row.model_id || '—',
+        formatAccuracy(row.accuracy),
+        formatCost(row.total_cost_usd),
+        row.total_duration_seconds != null ? Number(row.total_duration_seconds).toFixed(2) : '—',
+      ];
+      cells.forEach((text) => {
+        const td = document.createElement('td');
+        td.textContent = text;
+        tr.appendChild(td);
+      });
       historyBody.appendChild(tr);
     });
   } catch (error) {
     const row = document.createElement('tr');
-    row.innerHTML = `<td colspan="6" class="error">Failed to load history: ${error.message}</td>`;
+    const td = document.createElement('td');
+    td.colSpan = 6;
+    td.className = 'error';
+    td.textContent = `Failed to load history: ${error.message}`;
+    row.appendChild(td);
     historyBody.appendChild(row);
   }
 }

harness/async_client.py

@@ -29,17 +29,23 @@ def __init__(
         self._timeout = timeout_seconds
         self._session: Optional[aiohttp.ClientSession] = None
 
+    async def __aenter__(self) -> "ResilientOpenRouterClient":
+        if self._session is None:
+            timeout = aiohttp.ClientTimeout(total=self._timeout)
+            connector = aiohttp.TCPConnector(limit=10)
+            self._session = aiohttp.ClientSession(timeout=timeout, connector=connector)
+        return self
+
+    async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+        await self.close()
+
     @asynccontextmanager
     async def session(self) -> AsyncIterator[aiohttp.ClientSession]:
         if self._session is None:
             timeout = aiohttp.ClientTimeout(total=self._timeout)
             connector = aiohttp.TCPConnector(limit=10)
             self._session = aiohttp.ClientSession(timeout=timeout, connector=connector)
-        try:
-            yield self._session
-        finally:
-            # caller is responsible for closing via close()
-            ...
+        yield self._session
 
     async def close(self) -> None:
         if self._session is not None:

harness/run_harness.py

@@ -637,7 +637,7 @@ def wrap_content(content: str):
             else:
                 try:
                     data = response.json()
-                except (requests.exceptions.JSONDecodeError, ValueError) as exc:
+                except (requests.exceptions.JSONDecodeError, ValueError):
                     content_type = response.headers.get("content-type", "unknown")
                     body_preview = response.text.strip()
                     if len(body_preview) > 512:
@@ -801,8 +801,8 @@ def _run_patch_command(args: List[str], patch_bytes: bytes, workspace_path: Path
             check=False,
             timeout=timeout,
         )
-    except subprocess.TimeoutExpired:
-        raise HarnessError("Failed to apply patch: patch command timed out")
+    except subprocess.TimeoutExpired as exc:
+        raise HarnessError("Failed to apply patch: patch command timed out") from exc
 
 
 def _normalize_patch_path(path: str) -> Optional[str]:
@@ -829,7 +829,6 @@ def _extract_full_file_rewrites(cleaned_patch: str) -> Optional[Dict[str, str]]:
         if not line.startswith('--- '):
             i += 1
             continue
-        old_path = line[4:].strip()
         i += 1
         if i >= len(lines) or not lines[i].startswith('+++ '):
             return None

harness/secure_execution.py

@@ -2,11 +2,14 @@
 
 from __future__ import annotations
 
+import logging
 import resource
 import subprocess
 from pathlib import Path
 from typing import Iterable, Optional
 
+logger = logging.getLogger(__name__)
+
 
 def _resolve_command(command: Iterable[str]) -> list[str]:
     resolved: list[str] = []
@@ -38,11 +41,11 @@ def set_limits() -> None:
         try:
             resource.setrlimit(resource.RLIMIT_AS, (memory_bytes, memory_bytes))
         except (ValueError, OSError):
-            pass
+            logger.warning("Failed to set memory limit to %dMB", max_memory_mb)
         try:
             resource.setrlimit(resource.RLIMIT_CPU, (timeout, timeout + 1))
         except (ValueError, OSError):
-            pass
+            logger.warning("Failed to set CPU limit to %ds", timeout)
 
     process_env = env.copy() if env else None
 

server/caching.py

@@ -4,7 +4,7 @@
 
 import asyncio
 from dataclasses import dataclass
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 from typing import Any, Dict, Optional
 
 
@@ -14,7 +14,7 @@ class CacheEntry:
     expires_at: datetime
 
     def is_expired(self) -> bool:
-        return datetime.utcnow() > self.expires_at
+        return datetime.now(timezone.utc) > self.expires_at
 
 
 class AsyncCache:
@@ -33,7 +33,7 @@ async def get(self, key: str) -> Optional[Any]:
 
     async def set(self, key: str, value: Any, ttl_seconds: int = 300) -> None:
         async with self._lock:
-            expires_at = datetime.utcnow() + timedelta(seconds=ttl_seconds)
+            expires_at = datetime.now(timezone.utc) + timedelta(seconds=ttl_seconds)
             self._cache[key] = CacheEntry(value=value, expires_at=expires_at)
 
     async def invalidate(self, key: str) -> None:

server/database.py

@@ -4,7 +4,7 @@
 import json
 from contextlib import contextmanager
 from pathlib import Path
-from typing import Any, Dict, Iterable, List, Optional
+from typing import Any, Dict, Iterable, Iterator, List, Optional
 
 from sqlalchemy import Column, DateTime, Float, ForeignKey, Integer, String, Text, create_engine, select
 from sqlalchemy.orm import Mapped, Session, declarative_base, mapped_column, relationship, sessionmaker
@@ -70,7 +70,7 @@ def init_db() -> None:
 
 
 @contextmanager
-def get_session() -> Session:
+def get_session() -> Iterator[Session]:
     session = SessionLocal()
     try:
         yield session
@@ -233,8 +233,6 @@ def _is_better(candidate: Dict[str, Any], incumbent: Optional[Dict[str, Any]]) -
         if not attempts:
             continue
         default_level = summary.get("thinking_level")
-        metrics = summary.get("metrics") or {}
-        accuracy_map = metrics.get("model_accuracy") or {}
         # Group attempts per (model, thinking level)
         per_model_level: Dict[tuple[str, str], List[Dict[str, Any]]] = {}
         for attempt in attempts:

server/qa_database.py

@@ -66,8 +66,6 @@ class QAAttemptRecord(Base):
 
 engine = create_engine(
     f"sqlite:///{DB_PATH}",
-    pool_size=settings.database.pool_size,
-    max_overflow=settings.database.max_overflow,
     echo=settings.database.echo,
 )
 SessionLocal = sessionmaker(bind=engine, expire_on_commit=False, class_=Session)

server/qa_progress.py

@@ -4,6 +4,7 @@
 
 import asyncio
 import datetime as dt
+import threading
 import uuid
 from typing import Any, Dict
 
@@ -12,6 +13,7 @@ class ProgressManager:
     def __init__(self) -> None:
         self._runs: Dict[str, Dict[str, Any]] = {}
         self._lock = asyncio.Lock()
+        self._sync_lock = threading.RLock()
 
     def generate_run_id(self) -> str:
         timestamp = dt.datetime.now(dt.timezone.utc).strftime("qa_%Y%m%dT%H%M%SZ")
@@ -52,28 +54,31 @@ async def unsubscribe(self, run_id: str, queue: asyncio.Queue) -> None:
                 del self._runs[run_id]
 
     def _publish(self, run_id: str, event: Dict[str, Any]) -> None:
-        run = self._runs.get(run_id)
-        if not run:
-            return
-        run["events"].append(event)
-        for queue in list(run["queues"]):
-            queue.put_nowait(event)
+        with self._sync_lock:
+            run = self._runs.get(run_id)
+            if not run:
+                return
+            run["events"].append(event)
+            for queue in list(run["queues"]):
+                queue.put_nowait(event)
 
     def publish_attempt(self, run_id: str, event: Dict[str, Any]) -> None:
         payload = {"type": "attempt", **event}
         self._publish(run_id, payload)
 
     def complete(self, run_id: str, summary: Dict[str, Any]) -> None:
-        self._publish(run_id, {"type": "complete", "summary": summary})
-        run = self._runs.get(run_id)
-        if run:
-            run["done"] = True
+        with self._sync_lock:
+            self._publish(run_id, {"type": "complete", "summary": summary})
+            run = self._runs.get(run_id)
+            if run:
+                run["done"] = True
 
     def fail(self, run_id: str, message: str) -> None:
-        self._publish(run_id, {"type": "error", "message": message})
-        run = self._runs.get(run_id)
-        if run:
-            run["done"] = True
+        with self._sync_lock:
+            self._publish(run_id, {"type": "error", "message": message})
+            run = self._runs.get(run_id)
+            if run:
+                run["done"] = True
 
 
 qa_progress_manager = ProgressManager()

server/routes/qa_router.py

@@ -25,6 +25,7 @@
 logger = structlog.get_logger(__name__)
 
 router = APIRouter(prefix="/qa", tags=["qa"])
+_background_tasks: set = set()
 
 
 class QARunLaunchResponse(BaseModel):
@@ -221,7 +222,9 @@ async def runner() -> None:
             save_run(summary)
             qa_progress_manager.complete(run_id, summary)
 
-    asyncio.create_task(runner())
+    task = asyncio.create_task(runner())
+    _background_tasks.add(task)
+    task.add_done_callback(_background_tasks.discard)
     return QARunLaunchResponse(run_id=run_id)
 
 

server/routes/router.py

@@ -23,6 +23,7 @@
 settings = get_settings()
 logger = structlog.get_logger(__name__)
 HARNESS_SETTINGS = get_harness_settings()
+_background_tasks: set = set()
 DEFAULT_ALLOW_INCOMPLETE_DIFFS = HARNESS_SETTINGS.allow_incomplete_diffs
 DEFAULT_ALLOW_DIFF_REWRITE_FALLBACK = HARNESS_SETTINGS.allow_diff_rewrite_fallback
 DEFAULT_MAX_TOKENS = HARNESS_SETTINGS.default_max_tokens
@@ -203,7 +204,9 @@ async def runner() -> None:
             database.save_run(summary)
             progress_manager.complete(run_id, summary)
 
-    asyncio.create_task(runner())
+    task = asyncio.create_task(runner())
+    _background_tasks.add(task)
+    task.add_done_callback(_background_tasks.discard)
     return RunLaunchResponse(run_id=run_id)