omega-code 0.4.0__py3-none-any.whl

omega/server/worker.py

@@ -0,0 +1,186 @@
+"""The child process spawned per running task (see manager.py). One process =
+one task, so the process-wide globals `tools.CONFIRM`/`ASK_USER`/`SESSION_ID`
+and `os.getcwd()` are safe to set here without racing any other task.
+
+Wire protocol, newline-delimited JSON both ways:
+
+Parent -> child (stdin):
+  {"cmd": "prompt", "text": str}
+  {"cmd": "answer", "request_id": str, "answer": str}
+  {"cmd": "confirm", "request_id": str, "allow": bool}
+  {"cmd": "cancel"}
+  {"cmd": "set_model", "model": str | None}
+  {"cmd": "set_mode", "mode": str}
+  {"cmd": "shutdown"}
+
+Child -> parent (stdout), one JSON object per line:
+  {"type": "worker_ready"}
+  {"type": <events.Event dataclass name>, ...fields, "t": epoch, "turn": n}
+  {"type": "ask_user_request", "request_id", "question", "options", "multi_select"}
+  {"type": "confirm_request", "request_id", "tool", "args_preview", "why"}
+  {"type": "fatal", "message": str}   -- unrecoverable startup failure
+"""
+from __future__ import annotations
+
+import asyncio
+import dataclasses
+import json
+import os
+import secrets
+import sys
+import time
+from typing import Any
+
+from .. import config, events, loop, session, tasks, tools
+from ..session import Message
+from ..ui import format
+
+
+class Worker:
+    def __init__(self, task_id: str) -> None:
+        self.task_id = task_id
+        self.turn = 0
+        self.mode = "build"
+        self.model: str | None = None
+        self.history: list[Message] = []
+        self.cfg: config.Config | None = None
+        self.sess: session.Session | None = None
+        self._pending: dict[str, asyncio.Future[Any]] = {}
+        self._turn_task: asyncio.Task[None] | None = None
+
+    def _emit_line(self, obj: dict[str, Any]) -> None:
+        sys.stdout.write(json.dumps(obj) + "\n")
+        sys.stdout.flush()
+
+    def emit(self, ev: events.Event) -> None:
+        self._emit_line({"type": type(ev).__name__, **dataclasses.asdict(ev),
+                         "t": time.time(), "turn": self.turn})
+
+    async def confirm(self, name: str, args: dict[str, Any], why: str) -> bool:
+        request_id = secrets.token_hex(8)
+        fut: asyncio.Future[bool] = asyncio.get_event_loop().create_future()
+        self._pending[request_id] = fut
+        try:
+            preview = format.describe_call(name, args)
+        except Exception:
+            preview = str(args)
+        self._emit_line({"type": "confirm_request", "request_id": request_id,
+                         "tool": name, "args_preview": preview, "why": why})
+        return await fut
+
+    async def ask_user(self, question: str, options: list[events.Option],
+                       multi_select: bool) -> str:
+        request_id = secrets.token_hex(8)
+        fut: asyncio.Future[str] = asyncio.get_event_loop().create_future()
+        self._pending[request_id] = fut
+        self._emit_line({"type": "ask_user_request", "request_id": request_id,
+                         "question": question, "options": list(options),
+                         "multi_select": multi_select})
+        return await fut
+
+    def _resolve(self, request_id: object, value: Any) -> None:
+        if not isinstance(request_id, str):
+            return
+        fut = self._pending.pop(request_id, None)
+        if fut is not None and not fut.done():
+            fut.set_result(value)
+
+    async def _run_turn(self, text: str) -> None:
+        assert self.cfg is not None and self.sess is not None
+        self.turn += 1
+        self.history.append({"role": "user", "content": text})
+        interrupted = False
+        try:
+            await loop.run_turn(self.cfg, self.history, mode=self.mode,
+                                emit=self.emit, model=self.model)
+        except asyncio.CancelledError:
+            interrupted = True
+        except Exception as e:
+            self.emit(events.Error(message=f"{type(e).__name__}: {e}"))
+        finally:
+            try:
+                self.sess.close_turn(self.history, self.mode, interrupted)
+            except Exception as e:
+                self._emit_line({"type": "fatal", "message": f"could not save session: {e}"})
+            self._turn_task = None
+
+    async def _dispatch(self, cmd: dict[str, Any]) -> bool:
+        """Returns False when the worker should exit."""
+        kind = cmd.get("cmd")
+        if kind == "prompt":
+            if self._turn_task is not None and not self._turn_task.done():
+                self._emit_line({"type": "error", "message": "a turn is already running"})
+            else:
+                self._turn_task = asyncio.create_task(self._run_turn(str(cmd.get("text", ""))))
+        elif kind == "answer":
+            self._resolve(cmd.get("request_id"), str(cmd.get("answer", "")))
+        elif kind == "confirm":
+            self._resolve(cmd.get("request_id"), bool(cmd.get("allow", False)))
+        elif kind == "cancel":
+            if self._turn_task is not None:
+                self._turn_task.cancel()
+        elif kind == "set_mode":
+            self.mode = str(cmd.get("mode", self.mode))
+        elif kind == "set_model":
+            self.model = cmd.get("model") or None
+        elif kind == "jobs":
+            self._emit_line({"type": "jobs", "request_id": cmd.get("request_id"),
+                             "jobs": tools.list_jobs()})
+        elif kind == "shutdown":
+            if self._turn_task is not None:
+                self._turn_task.cancel()
+                await asyncio.gather(self._turn_task, return_exceptions=True)
+            return False
+        return True
+
+    async def run(self) -> None:
+        task = tasks.get(self.task_id)
+        if task is None:
+            self._emit_line({"type": "fatal", "message": f"no such task {self.task_id!r}"})
+            return
+        os.chdir(task.cwd)
+        self.cfg = config.load()
+        self.mode = task.mode
+        self.model = task.model
+        self.sess = session.load(self.task_id)
+        self.history = self.sess.history
+        tools.SESSION_ID = self.sess.id
+        tools.CONFIRM = self.confirm
+        tools.ASK_USER = self.ask_user
+        self.turn = self.sess.turns
+
+        reader = await _stdin_reader()
+        self._emit_line({"type": "worker_ready"})
+        while True:
+            raw = await reader.readline()
+            if not raw:
+                break
+            try:
+                cmd = json.loads(raw)
+            except json.JSONDecodeError:
+                continue
+            if not await self._dispatch(cmd):
+                break
+
+
+async def _stdin_reader() -> asyncio.StreamReader:
+    reader = asyncio.StreamReader()
+    protocol = asyncio.StreamReaderProtocol(reader)
+    loop_ = asyncio.get_event_loop()
+    await loop_.connect_read_pipe(lambda: protocol, sys.stdin)
+    return reader
+
+
+async def _amain(task_id: str) -> None:
+    await Worker(task_id).run()
+
+
+def main() -> None:
+    if len(sys.argv) < 2:
+        print("usage: python -m omega.server.worker <task_id>", file=sys.stderr)
+        raise SystemExit(2)
+    asyncio.run(_amain(sys.argv[1]))
+
+
+if __name__ == "__main__":
+    main()

omega/session.py

@@ -0,0 +1,209 @@
+import json
+import os
+import time
+import uuid
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+from typing import Any
+
+Message = dict[str, Any]
+
+DIR = Path.home() / ".omega" / "sessions"
+
+# Shared with __main__'s resumed-session marker so UIs can identify and
+# exclude it from turn/message counts shown to the user.
+RESUME_PREFIX = "[session resumed"
+
+
+@dataclass
+class Session:
+    id: str = ""
+    cwd: str = ""
+    mode: str = "build"
+    created: float = 0.0
+    updated: float = 0.0
+    history: list[Message] = field(default_factory=list)
+    compactions: int = 0
+    model_override: str | None = None
+    # Set by load() when the turn log (.jsonl) held more messages than the
+    # last saved .json -- i.e. the process crashed mid-turn. Never persisted:
+    # it describes this one load, not the session itself.
+    recovered: int = 0
+
+    @classmethod
+    def new(cls, cwd: str | None = None, mode: str = "build") -> "Session":
+        now = time.time()
+        sid = time.strftime("%Y%m%d-%H%M%S") + "-" + uuid.uuid4().hex[:4]
+        return cls(id=sid, cwd=cwd or os.getcwd(), mode=mode, created=now, updated=now)
+
+    @property
+    def path(self) -> Path:
+        return DIR / f"{self.id}.json"
+
+    @property
+    def jsonl_path(self) -> Path:
+        return DIR / f"{self.id}.jsonl"
+
+    def append(self, msg: Message) -> None:
+        """Add one message to history AND durably log it immediately -- unlike
+        `save()` (a full rewrite that only happens at turn boundaries), this
+        makes a crash mid-turn resumable: see `load()`'s jsonl-vs-json check."""
+        self.history.append(msg)
+        log_message(self.id, msg)
+
+    @property
+    def turns(self) -> int:
+        return sum(1 for m in self.history if m.get("role") == "user")
+
+    def first_prompt(self, width: int = 70) -> str:
+        for m in self.history:
+            if m.get("role") == "user":
+                text = " ".join((m.get("content") or "").split())
+                return text[:width - 1] + "…" if len(text) > width else text
+        return "(empty)"
+
+    def save(self) -> None:
+        DIR.mkdir(parents=True, exist_ok=True)
+        self.updated = time.time()
+        data = asdict(self)
+        data.pop("recovered", None)  # a fact about this load, not the session
+        tmp = self.path.with_suffix(".tmp")
+        tmp.write_text(json.dumps(data, indent=1))
+        tmp.replace(self.path)
+
+    def close_turn(self, history: list[dict[str, Any]], mode: str, interrupted: bool) -> None:
+        """Shared by every UI: whatever ran the turn, the session must land in
+        the same state afterwards."""
+        self.mode = mode
+        repair(history)
+        if interrupted:
+            history.append({"role": "user",
+                            "content": "[previous turn interrupted by user]"})
+        self._sync_jsonl(history)
+        self.save()
+
+    def _sync_jsonl(self, history: list[Message]) -> None:
+        """Nothing in this codebase yet calls `append()` per-message during a
+        turn, so bring the turn log up to date at the turn boundary instead --
+        the log is then complete as of every close_turn(), even before a
+        caller is wired to append() live. A no-op once the log has caught up."""
+        path = self.jsonl_path
+        existing = len(_read_jsonl(path)) if path.exists() else 0
+        if existing >= len(history):
+            return
+        DIR.mkdir(parents=True, exist_ok=True)
+        tmp = path.with_suffix(".jsonl.tmp")
+        with tmp.open("w") as f:
+            for msg in history:
+                f.write(json.dumps(msg) + "\n")
+        tmp.replace(path)
+
+
+def log_message(session_id: str, msg: Message) -> None:
+    """Append one message to `<session_id>.jsonl` without needing a `Session`
+    object loaded -- the primitive `Session.append` builds on."""
+    DIR.mkdir(parents=True, exist_ok=True)
+    with (DIR / f"{session_id}.jsonl").open("a") as f:
+        f.write(json.dumps(msg) + "\n")
+
+
+def _read_jsonl(path: Path) -> list[Message]:
+    """Tolerates a truncated trailing line -- the shape a hard crash mid-write
+    leaves, since appends are not fsynced. Anything after the first bad line
+    is dropped rather than raising, since the log is append-only sequential."""
+    messages: list[Message] = []
+    for line in path.read_text().splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            messages.append(json.loads(line))
+        except json.JSONDecodeError:
+            break
+    return messages
+
+
+def load(sid: str) -> Session:
+    p = DIR / f"{sid}.json"
+    if not p.exists():
+        matches = sorted(DIR.glob(f"{sid}*.json")) if DIR.exists() else []
+        if not matches:
+            raise SystemExit(f"omega: no session {sid!r}")
+        p = matches[-1]
+    raw = json.loads(p.read_text())
+    known = set(Session.__dataclass_fields__)
+    sess = Session(**{k: v for k, v in raw.items() if k in known})
+    sess.recovered = 0
+
+    jsonl = DIR / f"{sess.id}.jsonl"
+    if jsonl.exists():
+        logged = _read_jsonl(jsonl)
+        if len(logged) > len(sess.history):
+            sess.recovered = len(logged) - len(sess.history)
+            sess.history = logged
+
+    repair(sess.history)
+    return sess
+
+
+def repair(history: list[Message]) -> list[Message]:
+    """Drop a trailing assistant message whose tool_calls were never answered.
+    Providers hard-400 on that shape, which would brick the session forever."""
+    while history:
+        last = history[-1]
+        if last.get("role") == "assistant" and last.get("tool_calls"):
+            answered = {m.get("tool_call_id") for m in history if m.get("role") == "tool"}
+            if any(c["id"] not in answered for c in last["tool_calls"]):
+                history.pop()
+                continue
+        break
+    return history
+
+
+def all_sessions() -> list[Session]:
+    if not DIR.exists():
+        return []
+    out = []
+    for p in DIR.glob("*.json"):
+        try:
+            out.append(Session(**json.loads(p.read_text())))
+        except Exception:
+            continue
+    return sorted(out, key=lambda s: s.updated, reverse=True)
+
+
+def latest(cwd: str | None = None) -> Session | None:
+    cwd = cwd or os.getcwd()
+    # Never fall back to another directory's session: bash and relative paths
+    # resolve against the real cwd, so the model would edit the wrong project.
+    here = [s for s in all_sessions() if s.cwd == cwd]
+    return here[0] if here else None
+
+
+def render_list(limit: int = 20, cwd: str | None = None) -> str:
+    """One session per line: wrapped rows make the list unparseable. `cwd`
+    filters to that directory's sessions only (used by `omega resume` with
+    no id, and `sessions --resume`'s hint)."""
+    rows = all_sessions()
+    if cwd is not None:
+        rows = [s for s in rows if s.cwd == cwd]
+    rows = rows[:limit]
+    if not rows:
+        return "no sessions yet"
+    now = time.time()
+    import shutil
+    cols = shutil.get_terminal_size((80, 24)).columns
+    lines = [f"{'ID':<22}{'AGE':>6}{'TURNS':>6}  {'CWD':<24}PROMPT"]
+    for s in rows:
+        age = now - s.updated
+        ago = (f"{age/86400:.0f}d" if age > 86400 else
+               f"{age/3600:.0f}h" if age > 3600 else f"{age/60:.0f}m")
+        cwd = s.cwd.replace(str(Path.home()), "~")
+        if len(cwd) > 23:
+            cwd = "…" + cwd[-22:]
+        lines.append(f"{s.id:<22}{ago:>6}{s.turns:>6}  {cwd:<24}"
+                     f"{s.first_prompt(200)}")
+    # hard-truncate: a wrapped row makes the list unreadable and unparseable
+    # Stay strictly under the terminal width: a line of exactly `cols` chars
+    # still wraps in some terminals.
+    return "\n".join(l[:cols - 2] + "…" if len(l) >= cols - 1 else l for l in lines)

omega/setup.html

@@ -0,0 +1,281 @@
+<!doctype html>
+<meta charset="utf-8"><title>omega setup</title>
+<style>
+:root{--bg:#fbfbfa;--fg:#1a1a19;--dim:#6b6b68;--line:#e4e4e1;--card:#fff;--soft:#f4f4f2;
+ --ok:#1a7f4b;--err:#b3261e;--accent:#2b6cb0}
+@media(prefers-color-scheme:dark){:root{--bg:#191918;--fg:#e8e8e5;--dim:#96968f;--line:#33332f;
+ --card:#212120;--soft:#262625;--ok:#4ade80;--err:#f87171;--accent:#7cb3ea}}
+*{box-sizing:border-box}
+body{margin:0;padding:0;background:var(--bg);color:var(--fg);
+ font:14px/1.55 ui-sans-serif,-apple-system,system-ui,sans-serif}
+main{max-width:680px;margin:0 auto;padding:48px 24px 80px}
+h1{font-size:26px;margin:0 0 6px;letter-spacing:-.02em}
+h2{font-size:19px;margin:0 0 6px;letter-spacing:-.01em}
+.sub{color:var(--dim);margin:0 0 26px}
+.steps{display:flex;gap:6px;margin-bottom:34px}
+.steps div{height:3px;flex:1;background:var(--line);border-radius:2px;transition:background .25s}
+.steps div.done{background:var(--ok)}.steps div.now{background:var(--accent)}
+.card{background:var(--card);border:1px solid var(--line);border-radius:12px;padding:26px}
+label{display:block;font-size:12px;color:var(--dim);margin:14px 0 5px}
+input,select{width:100%;padding:9px 11px;border:1px solid var(--line);border-radius:7px;
+ background:var(--bg);color:var(--fg);font:13px ui-monospace,SFMono-Regular,Menlo,monospace}
+input:focus,select:focus{outline:2px solid var(--accent);outline-offset:-1px}
+button{padding:9px 16px;border:1px solid var(--line);border-radius:7px;background:var(--bg);
+ color:var(--fg);font-size:13px;cursor:pointer}
+button:hover:not(:disabled){border-color:var(--accent);color:var(--accent)}
+button.primary{background:var(--accent);color:#fff;border-color:var(--accent)}
+button.primary:hover:not(:disabled){opacity:.9;color:#fff}
+button:disabled{opacity:.45;cursor:default}
+.nav{display:flex;justify-content:space-between;margin-top:26px}
+.ok{color:var(--ok)}.err{color:var(--err)}.dim{color:var(--dim)}
+.mono{font:12px ui-monospace,SFMono-Regular,Menlo,monospace}
+.msg{margin-top:12px;font-size:13px;min-height:20px}
+table{width:100%;border-collapse:collapse;font-size:13px;margin-top:6px}
+td,th{padding:7px 4px;border-bottom:1px solid var(--line);text-align:left}
+th{font-size:11px;text-transform:uppercase;letter-spacing:.06em;color:var(--dim);font-weight:600}
+tr.best td{background:var(--soft)}
+.role{display:grid;grid-template-columns:120px 1fr;gap:10px;align-items:center;margin-bottom:9px}
+.role .n{font-size:12px}.role .n b{display:block;font:12px ui-monospace,monospace}
+pre{background:var(--soft);border:1px solid var(--line);border-radius:7px;padding:13px;
+ overflow-x:auto;font:12px ui-monospace,monospace;margin:12px 0 0}
+.pill{display:inline-block;padding:2px 8px;border-radius:20px;font-size:11px;
+ background:var(--soft);border:1px solid var(--line);margin:2px 4px 2px 0}
+h3.sec{margin:20px 0 6px;font-size:13px;text-transform:uppercase;letter-spacing:.05em;color:var(--dim)}
+.cathead{font-size:11px;text-transform:uppercase;letter-spacing:.06em;color:var(--dim);
+ margin:16px 0 4px;font-weight:600}
+.introw{display:flex;align-items:center;gap:10px;padding:8px 2px;border-bottom:1px solid var(--line)}
+.introw .meta{flex:1;min-width:0}
+.introw .meta .b{font-size:12px;color:var(--dim);margin-top:1px}
+#catSearch{margin:8px 0}
+button.small{padding:5px 10px;font-size:12px}
+</style>
+<main>
+<h1>omega</h1><p class="sub" id="tagline">Let's get you running.</p>
+<div class="steps" id="steps"></div>
+<div class="card" id="card"></div>
+<div class="nav"><button id="back" onclick="go(-1)">Back</button>
+<button id="next" class="primary" onclick="go(1)">Continue</button></div>
+</main>
+<script>
+const T = new URLSearchParams(location.search).get("t");
+// /api/* is POST-only: GET dispatch was a CSRF-reachable RCE.
+const api=(p,b)=>fetch(p+"?t="+T,{method:"POST",headers:{"Content-Type":"application/json",
+  "X-Omega-Token":T},body:JSON.stringify(b||{})}).then(r=>r.json());
+const $=s=>document.querySelector(s);
+let cfg=null, models=[], bench=[], step=0, keyOk=false, ranTest=false;
+
+const ROLES={main:["Main","drives your session — pick the smartest"],
+  plan:["Planning","read-only research and plans"],
+  subagent_fast:["Fast subagent","bounded lookups — pick the quickest"],
+  subagent_mid:["Mid subagent","reasoning across files"],
+  compact:["Compaction","summarises old context"]};
+
+const STEPS=[
+{t:"Provider",r:()=>`<h2>Connect a provider</h2>
+ <p class="dim">omega talks to Anthropic natively, or any OpenAI-compatible endpoint.</p>
+ <label>Provider type</label>
+ <select id="providerType" onchange="onProviderTypeChange()">
+   <option value="openai"${Object.values(cfg.providers)[0].type!=='anthropic'?' selected':''}>OpenAI-compatible</option>
+   <option value="anthropic"${Object.values(cfg.providers)[0].type==='anthropic'?' selected':''}>Anthropic (native)</option>
+ </select>
+ <div id="baseUrlRow" style="${Object.values(cfg.providers)[0].type==='anthropic'?'display:none':''}">
+ <label>Base URL</label><input id="baseUrl" value="${Object.values(cfg.providers)[0].baseUrl||''}"></div>
+ <label>API key ${Object.values(cfg.providers)[0].hasKey?'<span class="ok">· already stored</span>':''}</label>
+ <input id="apiKey" type="password" placeholder="${Object.values(cfg.providers)[0].hasKey?'•••••••••••• (stored)':'sk-…'}">
+ <div class="msg" id="m"></div>`,
+ enter(){ if(Object.values(cfg.providers)[0].hasKey) verify(); },
+ next:()=>keyOk||verify()},
+
+{t:"Models",r:()=>`<h2>Pick your models</h2>
+ <p class="dim">${models.length} available. Measure them, then assign roles.</p>
+ <button onclick="runBench()" id="bb">Measure latency</button>
+ <span class="mono dim" id="bs"></span>
+ <div id="bt"></div><div id="rs" style="margin-top:20px"></div>`,
+ enter(){ renderRoles(); }},
+
+{t:"Tools",r:()=>`<h2>Connect tools</h2>
+ <p class="dim">Connect from the catalog, import what Claude Code already has, or manage
+ what omega is already using. Tools stay out of the prompt until the model searches for them.</p>
+ <div id="mc" class="dim">loading…</div>`,
+ enter(){ loadConnections(); }},
+
+{t:"Test",r:()=>`<h2>Take it for a spin</h2>
+ <p class="dim">Runs one real turn against your config — proof it works end to end.</p>
+ <button onclick="drive()" id="db" class="primary">Run test</button>
+ <div id="dr"></div>`},
+
+{t:"Done",r:()=>`<h2>You're set</h2>
+ <p class="dim">Config written to <span class="mono">~/.omega/config.json</span>.</p>
+ <pre>omega                      # interactive
+omega "fix the failing test"
+omega --plan "add caching"  # read-only planning
+omega --mcp "list my Linear issues"</pre>
+ <p class="dim" style="margin-top:16px">Re-run this anytime with
+ <span class="mono">omega setup</span>.</p>`}];
+
+function render(){
+  $("#steps").innerHTML = STEPS.map((_,i)=>
+    `<div class="${i<step?'done':i===step?'now':''}"></div>`).join("");
+  $("#card").innerHTML = STEPS[step].r();
+  $("#back").style.visibility = step? "visible":"hidden";
+  $("#next").textContent = step===STEPS.length-1? "Finish":"Continue";
+  $("#tagline").textContent = STEPS[step].t;
+  STEPS[step].enter?.();
+}
+async function go(d){
+  if(d>0 && STEPS[step].next && !(await STEPS[step].next())) return;
+  if(d>0 && step===STEPS.length-1){ await save(); $("#next").textContent="Saved"; return; }
+  if(d>0) await save();
+  step=Math.max(0,Math.min(STEPS.length-1,step+d)); render();
+}
+function onProviderTypeChange(){
+  const p=Object.values(cfg.providers)[0], isAnthropic=$("#providerType").value==="anthropic";
+  p.type=$("#providerType").value;
+  $("#baseUrlRow").style.display = isAnthropic ? "none" : "";
+}
+async function verify(){
+  const m=$("#m"); m.textContent="checking…"; m.className="msg dim";
+  const p=Object.values(cfg.providers)[0];
+  p.type=$("#providerType").value;
+  const body={}; const k=$("#apiKey")?.value; if(k) body.apiKey=k;
+  if(p.type!=='anthropic' && $("#baseUrl")) p.baseUrl=$("#baseUrl").value;
+  if(k) p.apiKey=k;
+  else delete p.apiKey;  // never write back a redacted key
+  const r=await api("/api/models",body);
+  if(r.error){ m.textContent="✗ "+r.error.slice(0,90); m.className="msg err"; return keyOk=false; }
+  models=r.models; keyOk=true;
+  m.innerHTML=`<span class="ok">✓ connected — ${models.length} models available</span>`;
+  return true;
+}
+async function runBench(){
+  const b=$("#bb"); b.disabled=true; $("#bs").textContent=" measuring one at a time…";
+  const r=await api("/api/benchmark",{});
+  bench=r.results||[]; b.disabled=false; $("#bs").textContent="";
+  $("#bt").innerHTML=`<table><tr><th>Model</th><th>Round trip</th></tr>`+
+    bench.map((x,i)=>`<tr class="${i===0&&x.ok?'best':''}"><td class="mono">${x.model}</td>
+    <td class="${x.ok?'ok':'err'} mono">${x.ok?x.ms+"ms":x.error}</td></tr>`).join("")+`</table>`;
+  renderRoles();
+}
+function renderRoles(){
+  const fast=bench.filter(b=>b.ok)[0]?.model;
+  $("#rs").innerHTML=Object.entries(ROLES).map(([k,[n,d]])=>`<div class="role">
+    <span class="n">${n}<b>${k}</b></span>
+    <select data-role="${k}">${(models.length?models:[cfg.roles[k].model])
+      .map(m=>`<option${m===cfg.roles[k].model?" selected":""}>${m}</option>`).join("")}</select>
+    </div><p class="dim" style="margin:-4px 0 12px;font-size:12px">${d}${
+      fast&&k.includes("fast")?` — fastest measured: <b>${fast}</b>`:""}</p>`).join("");
+}
+let connData=null, catFilter="";
+
+async function loadConnections(){
+  connData=await api("/api/connections/list");
+  renderConnections();
+}
+function connStateBadge(r){
+  if(r.state==="connected") return `<span class="ok">connected</span> <span class="dim">(${r.tools})</span>`;
+  if(r.state==="needs_auth") return `<span class="err">needs auth</span>`;
+  if(r.state==="error") return `<span class="err">error</span>`;
+  if(r.state==="disabled") return `<span class="dim">disabled</span>`;
+  return `<span class="dim">configured</span>`;
+}
+function renderConnections(){
+  let html="";
+  if(connData.configured.length){
+    html+=`<h3 class="sec">Connected</h3><table><tr><th>Name</th><th>State</th><th></th></tr>`+
+      connData.configured.map(r=>`<tr><td>${r.name}</td><td>${connStateBadge(r)}</td>
+        <td style="width:260px">
+        <button class="small" onclick="connectServer('${r.name}')">connect</button>
+        <button class="small" onclick="testServer('${r.name}')">test</button>
+        <button class="small" onclick="toggleServer('${r.name}',${r.enabled?"false":"true"})">${r.enabled?"disable":"enable"}</button>
+        <button class="small" onclick="removeServer('${r.name}')">remove</button>
+        </td></tr>`).join("")+`</table>`;
+  }
+  if(connData.claudeCode.length){
+    html+=`<h3 class="sec">Found in Claude Code</h3><table><tr><th>Name</th><th></th><th></th></tr>`+
+      connData.claudeCode.map(c=>`<tr><td>${c.name}</td>
+        <td class="mono dim">${c.transport==="stdio"?c.command:c.url}</td>
+        <td style="width:100px"><button class="small" onclick="importClaude('${c.name}')">import</button></td>
+        </tr>`).join("")+`</table>`;
+  }
+  html+=`<h3 class="sec">Catalog</h3>
+    <input id="catSearch" placeholder="Search integrations…" value="${catFilter}"
+     oninput="catFilter=this.value;renderCatalog()">
+    <div id="catList"></div>
+    <div class="msg" id="connMsg"></div>`;
+  $("#mc").innerHTML=html;
+  renderCatalog();
+}
+function renderCatalog(){
+  const q=catFilter.trim().toLowerCase();
+  const groups={};
+  connData.catalog.forEach(i=>{
+    if(q && !(i.name.toLowerCase().includes(q) || i.blurb.toLowerCase().includes(q) || i.key.includes(q))) return;
+    (groups[i.category]=groups[i.category]||[]).push(i);
+  });
+  const cats=Object.keys(groups).sort();
+  $("#catList").innerHTML=cats.length ? cats.map(cat=>`
+    <div class="cathead">${cat}</div>
+    ${groups[cat].map(i=>`<div class="introw">
+       <div class="meta"><b>${i.name}</b>${i.verified?"":' <span class="dim">unverified</span>'}
+       <div class="b">${i.blurb}</div></div>
+       <span class="pill">${i.auth}</span>
+       <button class="small" onclick="addFromCatalog('${i.key}')">connect</button>
+     </div>`).join("")}`).join("")
+    : `<p class="dim">no matches</p>`;
+}
+function connMsg(text,ok){
+  const m=$("#connMsg"); if(!m) return;
+  m.textContent=text; m.className="msg "+(ok?"ok":"err");
+}
+async function addFromCatalog(key){
+  const entry=connData.catalog.find(i=>i.key===key);
+  const env={};
+  for(const k of (entry?.env||[])){
+    const v=window.prompt(`${entry.name} needs ${k}:`);
+    if(v===null) return;  // cancelled
+    if(v) env[k]=v;
+  }
+  const r=await api("/api/connections/add",{name:key,key,env});
+  if(r.error){ connMsg(`${key}: ${r.error}`,false); return; }
+  await connectServer(key);
+}
+async function importClaude(name){
+  const r=await api("/api/connections/add",{name,source:"claude-code"});
+  if(r.error){ connMsg(`${name}: ${r.error}`,false); return; }
+  connData=await api("/api/connections/list"); renderConnections();
+}
+async function connectServer(name){
+  const st=await api("/api/connections/connect",{name});
+  if(st.state==="needs_auth") connMsg(`${name}: open ${st.error} to authorise, then click connect again`,false);
+  else if(st.state==="connected") connMsg(`${name}: connected (${st.tools} tools)`,true);
+  else connMsg(`${name}: ${st.state}${st.error?" — "+st.error:""}`,false);
+  connData=await api("/api/connections/list"); renderConnections();
+}
+async function testServer(name){
+  const st=await api("/api/connections/test",{name});
+  connMsg(`${name}: ${st.state==="connected"?`ok (${st.tools} tools)`:(st.error||st.state)}`,st.state==="connected");
+  connData=await api("/api/connections/list"); renderConnections();
+}
+async function toggleServer(name,val){
+  await api("/api/connections/toggle",{name,enabled:val});
+  connData=await api("/api/connections/list"); renderConnections();
+}
+async function removeServer(name){
+  await api("/api/connections/remove",{name});
+  connData=await api("/api/connections/list"); renderConnections();
+}
+async function drive(){
+  const b=$("#db"); b.disabled=true; b.textContent="running…";
+  const r=await api("/api/agent",{prompt:"Run 'pwd' and 'date' with bash, then say in one short sentence where you are and what day it is."});
+  b.disabled=false; b.textContent="Run again"; ranTest=r.ok;
+  $("#dr").innerHTML=r.ok
+    ?`<p style="margin-top:14px">${r.tools.map(t=>`<span class="pill">⏺ ${t}</span>`).join("")}</p>
+      <pre>${r.text.replace(/[<>]/g,"")}</pre><p class="ok" style="margin-top:10px">✓ working</p>`
+    :`<pre class="err">${(r.error||"failed").replace(/[<>]/g,"")}</pre>`;
+}
+async function save(){
+  document.querySelectorAll("select[data-role]").forEach(s=>cfg.roles[s.dataset.role].model=s.value);
+  await api("/api/save",cfg);
+}
+api("/api/config").then(c=>{cfg=c; render();});
+</script>