Convert Claude Code or Codex into the most intelligent Deep Research Agent. Collect, search, and synthesize web research into a persistent, searchable wiki that builds on itself. Hosted API + MCP: hyperresearch.ai
Python agentsagentskillscitationsclaude-codecodexcodex-plugincodex-skilldeep-researchdeep-research-agentdeepresearchmcp-serverresearchresearch-agentresearch-tools
fix: keep the viewer responsive with idle browser connections (#96)
Maxim Gagiev4a504016690b
diff --git a/src/hyperresearch/serve/server.py b/src/hyperresearch/serve/server.pyindex 7ddef3a..d53c1df 100644--- a/src/hyperresearch/serve/server.py+++ b/src/hyperresearch/serve/server.py@@ -4,8 +4,9 @@ from __future__ import annotationsimport html as html_modimport json+import sqlite3import urllib.parse-from http.server import BaseHTTPRequestHandler, HTTPServer+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServerfrom hyperresearch.serve.renderer import render_markdown@@ -339,16 +340,26 @@ GRAPH_JS = """class HyperresearchHandler(BaseHTTPRequestHandler):+ # Bound reads from browser preconnections that never send a request.+ timeout = 30vault = None- _db = None+ _db: sqlite3.Connection | None = None@property- def db(self):- if self.__class__._db is None:- import sqlite3- self.__class__._db = sqlite3.connect(str(self.__class__.vault.db_path), check_same_thread=False)- self.__class__._db.row_factory = sqlite3.Row- return self.__class__._db+ def db(self) -> sqlite3.Connection:+ # A handler runs in its own thread; never share its connection with other handlers.+ if self._db is None:+ self._db = sqlite3.connect(str(self.__class__.vault.db_path))+ self._db.row_factory = sqlite3.Row+ return self._db++ def finish(self) -> None:+ try:+ super().finish()+ finally:+ if self._db is not None:+ self._db.close()+ self._db = Nonedef do_GET(self):parsed = urllib.parse.urlparse(self.path)@@ -577,7 +588,7 @@ def run_server(vault, port: int = 8080, open_browser: bool = False):import sysHyperresearchHandler.vault = vault- server = HTTPServer(("127.0.0.1", port), HyperresearchHandler)+ server = ThreadingHTTPServer(("127.0.0.1", port), HyperresearchHandler)server.timeout = 0.5 # Check for Ctrl+C every 500msurl = f"http://127.0.0.1:{port}"print(f"Serving at {url}")@@ -595,9 +606,11 @@ def run_server(vault, port: int = 8080, open_browser: bool = False):signal.signal(signal.SIGINT, _shutdown)- while running:- server.handle_request()+ try:+ while running:+ server.handle_request()+ finally:+ server.server_close()print("\nStopped.")- server.server_close()sys.exit(0)diff --git a/tests/test_serve/test_server.py b/tests/test_serve/test_server.pynew file mode 100644index 0000000..7063451--- /dev/null+++ b/tests/test_serve/test_server.py@@ -0,0 +1,149 @@+"""Exercise the real viewer with idle browser preconnections and concurrent clients."""++import json+import multiprocessing+import os+import signal+import socket+import sqlite3+import sys+from concurrent.futures import ThreadPoolExecutor+from contextlib import contextmanager+from http.client import HTTPConnection+from http.server import BaseHTTPRequestHandler+from socketserver import TCPServer+from threading import Lock++import pytest++from hyperresearch.core.vault import Vault+from hyperresearch.serve.server import HyperresearchHandler, run_server+++def _serve(vault_path, events, timeout):+ """Report the OS-selected port and accepted sockets without replacing request handling."""+ activate = TCPServer.server_activate+ setup = HyperresearchHandler.setup+ event_lock = Lock()++ def report_address(server):+ activate(server)+ events.send(("ready", server.server_address))++ def report_client(handler):+ setup(handler)+ with event_lock:+ events.send(("accepted", handler.client_address))++ TCPServer.server_activate = report_address+ HyperresearchHandler.setup = report_client+ if timeout is not None and HyperresearchHandler.timeout is not None:+ HyperresearchHandler.timeout = min(timeout, HyperresearchHandler.timeout)+ run_server(Vault(vault_path), port=0)+++def _wait_for(events, kind):+ while True:+ assert events.poll(5), f"server did not report {kind}"+ event, value = events.recv()+ if event == kind:+ return value+++@contextmanager+def _running_server(vault, *, timeout=None):+ context = multiprocessing.get_context("spawn")+ events, sender = context.Pipe(duplex=False)+ process = context.Process(target=_serve, args=(vault.root, sender, timeout))+ process.start()+ sender.close()+ try:+ address = _wait_for(events, "ready")+ yield address, process, events+ finally:+ if process.is_alive():+ process.terminate()+ process.join(5)+ if process.is_alive():+ process.kill()+ process.join(5)+ events.close()+++def _get(address, path):+ client = HTTPConnection(*address, timeout=2)+ try:+ client.request("GET", path)+ response = client.getresponse()+ return response.status, response.read()+ finally:+ client.close()+++def test_idle_preconnection_does_not_block_pages_or_graph(seeded_vault):+ with (+ _running_server(seeded_vault) as (address, _process, events),+ socket.create_connection(address, timeout=2),+ ):+ _wait_for(events, "accepted")+ status, body = _get(address, "/")+ assert status == 200+ assert b"Python Async Patterns" in body+ status, body = _get(address, "/api/graph")+ assert status == 200+ assert any(node["title"] == "Python Async Patterns" for node in json.loads(body)["nodes"])+++def test_concurrent_pages_and_searches_render_from_vault(seeded_vault):+ paths = ["/", "/search?q=Python", "/api/graph", "/note/python-async-patterns"] * 3+ with (+ _running_server(seeded_vault) as (address, _process, _events),+ ThreadPoolExecutor(max_workers=4) as clients,+ ):+ results = list(clients.map(lambda path: _get(address, path), paths))+ for status, body in results:+ assert status == 200+ assert b"Python Async Patterns" in body+++def test_idle_connection_is_closed_after_read_timeout(seeded_vault):+ with (+ _running_server(seeded_vault, timeout=0.1) as (address, _process, events),+ socket.create_connection(address, timeout=2) as idle,+ ):+ _wait_for(events, "accepted")+ assert idle.recv(1) == b""++[email protected](sys.platform == "win32", reason="os.kill(SIGINT) requires POSIX signal delivery")+def test_shutdown_does_not_wait_for_idle_preconnection(seeded_vault):+ with (+ _running_server(seeded_vault) as (address, process, events),+ socket.create_connection(address, timeout=2),+ ):+ _wait_for(events, "accepted")+ os.kill(process.pid, signal.SIGINT)+ process.join(3)+ assert process.exitcode == 0+++def test_handlers_own_and_close_their_database_connections(seeded_vault, monkeypatch):+ monkeypatch.setattr(HyperresearchHandler, "vault", seeded_vault)+ monkeypatch.setattr(HyperresearchHandler, "_db", None)+ # No sockets are needed to check ownership; socket cleanup belongs to the base handler.+ monkeypatch.setattr(BaseHTTPRequestHandler, "finish", lambda self: None)+ first = object.__new__(HyperresearchHandler)+ second = object.__new__(HyperresearchHandler)+ first_db, second_db = first.db, second.db+ try:+ assert first_db is not second_db+ first.finish()+ with pytest.raises(sqlite3.ProgrammingError, match="closed"):+ first_db.execute("SELECT 1")+ assert second_db.execute("SELECT 1").fetchone()[0] == 1+ second.finish()+ with pytest.raises(sqlite3.ProgrammingError, match="closed"):+ second_db.execute("SELECT 1")+ finally:+ first_db.close()+ second_db.close()