plugin.py

"""Workbench plugin that installs, configures, and launches Codex CLI instances.

Codex is an agent *harness*: it supplies the tools, sandbox, and edit loop while
the reasoning comes from a backing model. Here the model is served by the local
EmuLLM relay (``router/gpt-5.6-sol`` over its keyless OpenAI-compatible ``/v1``
surface at ``http://127.0.0.1:8801/v1``). **Codex is only a client of EmuLLM**;
this plugin never starts, stops, or reconfigures EmuLLM.

The plugin manages any number of *instances*. Each instance is an isolated
``CODEX_HOME`` under ``homes/<name>/`` with its own ``config.toml``, auth, and
history, plus a target model, base URL, and workspace directory. Two surfaces
manage them:

* a dedicated manager page served at ``/codex_cli/manage`` (a table of instances
  with per-row install / configure / launch / delete and a create form), and
* the native administration descriptor (an instance selector plus
  create / launch / delete actions for one-at-a-time management).

Only routes are added to the workbench API process; there is no standalone
server. Secrets are never persisted: the launcher exports a placeholder key
because EmuLLM's ``/v1`` surface is keyless.
"""

from __future__ import annotations

import asyncio
import contextlib
import json
import os
import re
import shutil
import subprocess
import threading
import time
import uuid
from pathlib import Path
from typing import Any

import httpx
from fastapi import APIRouter, Body, HTTPException, Request, WebSocket, WebSocketDisconnect
from fastapi.responses import HTMLResponse, JSONResponse, StreamingResponse

import plugin_admin

try:  # Cross-platform PTY for the in-browser codex terminal (Launch).
    if os.name == "nt":
        from winpty import PtyProcess  # type: ignore  # pywinpty (Windows ConPTY)
    else:
        from ptyprocess import PtyProcessUnicode as PtyProcess  # type: ignore  # POSIX pty
    _PTY_IMPORT_ERROR = ""
except Exception as _err:  # noqa: BLE001 - the terminal degrades with a clear message
    PtyProcess = None  # type: ignore
    _PTY_IMPORT_ERROR = str(_err)


# Per-instance defaults. The model is served by the local EmuLLM relay; Codex is
# only a client of it, so nothing here starts, stops, or reconfigures EmuLLM.
INSTANCE_DEFAULTS: dict[str, str] = {
    "model": "router/gpt-5.6-sol",
    "providerId": "emullm",
    "providerLabel": "EmuLLM Router",
    "baseUrl": "http://127.0.0.1:8801/v1",
    "wireApi": "responses",
    "envKey": "EMULLM_API_KEY",
    "workspaceDir": r"C:\snet\PeTTa\repos\symbolic_learner_workbench",
}
WIRE_API_CHOICES = ("responses", "chat")
DEFAULT_INSTANCE = "default"
# Codex 0.152.1 speaks only the Responses API, but most LAN models expose
# chat/completions. The plugin runs a local Responses<->chat adapter that Codex
# points at; it forwards to the instance's real upstream (any OpenAI-compatible
# LAN model, EmuLLM included -- no endpoint is special-cased). This is where the
# workbench API answers, used to build the adapter URL written into config.toml.
DEFAULT_API_BASE = "http://127.0.0.1:8000"
# EmuLLM's /v1 surface is keyless, but Codex still expects the provider's
# env_key variable to hold *some* value, so the launcher exports this placeholder.
EMULLM_PLACEHOLDER_KEY = "emullm-local"
_NAME_RE = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$")

# Populated by _check_codex()/initialize() so the pages can show the version
# without spawning Codex on every render.
_VERSION_CACHE: dict[str, str] = {}


# --- filesystem / binary resolution ------------------------------------------


def _plugin_dir(manifest: dict[str, Any]) -> Path:
    return plugin_admin.plugin_directory(manifest)


def _homes_dir(manifest: dict[str, Any]) -> Path:
    return _plugin_dir(manifest) / "homes"


def _codex_entry(manifest: dict[str, Any]) -> Path:
    """Path to the CLI's Node entrypoint inside the local install."""

    return _plugin_dir(manifest) / "node_modules" / "@openai" / "codex" / "bin" / "codex.js"


def _node() -> str | None:
    return shutil.which("node")


def _codex_installed(manifest: dict[str, Any]) -> bool:
    return _codex_entry(manifest).is_file()


def _run_codex(manifest: dict[str, Any], args: list[str], *, timeout: float = 30.0) -> tuple[bool, str]:
    """Run ``codex <args>`` through the local Node install; return (ok, output)."""

    node = _node()
    if node is None:
        return False, "Node.js was not found on PATH (Codex requires Node.js 22+)."
    entry = _codex_entry(manifest)
    if not entry.is_file():
        return False, "Codex CLI is not installed. Use Launch or Install (npm install)."
    try:
        result = subprocess.run(  # noqa: S603 - fixed node executable and local entrypoint
            [node, str(entry), *args],
            capture_output=True, text=True, timeout=timeout,
            cwd=str(_plugin_dir(manifest)), check=False,
        )
    except (OSError, subprocess.SubprocessError) as error:
        return False, f"Failed to launch Codex: {error}"
    output = (result.stdout or "").strip() or (result.stderr or "").strip()
    return result.returncode == 0, output


def _check_codex(manifest: dict[str, Any]) -> dict[str, Any]:
    ok, output = _run_codex(manifest, ["--version"], timeout=30.0)
    if ok and output:
        _VERSION_CACHE[str(_plugin_dir(manifest))] = output
    return {"ok": ok, "version": output if ok else "", "entrypoint": str(_codex_entry(manifest)), "detail": output}


def _ensure_installed(manifest: dict[str, Any]) -> dict[str, Any]:
    """Install the vendored Codex CLI (npm install) if it is not present yet.

    All instances share the one vendored binary and differ only by CODEX_HOME.
    """

    if _codex_installed(manifest):
        return {"ok": True, "installed": True, "ranInstall": False}
    npm = shutil.which("npm") or shutil.which("npm.cmd")
    if npm is None:
        return {"ok": False, "installed": False, "ranInstall": False,
                "detail": "npm was not found on PATH (Node.js 22+ is required)."}
    try:
        result = subprocess.run(  # noqa: S603 - fixed npm executable, no shell
            [npm, "install", "--no-audit", "--no-fund"],
            capture_output=True, text=True, timeout=600,
            cwd=str(_plugin_dir(manifest)), check=False,
        )
    except (OSError, subprocess.SubprocessError) as error:
        return {"ok": False, "installed": False, "ranInstall": True, "detail": str(error)}
    ok = result.returncode == 0 and _codex_installed(manifest)
    detail = "" if ok else (result.stderr or result.stdout or "npm install failed").strip()[-2000:]
    return {"ok": ok, "installed": _codex_installed(manifest), "ranInstall": True, "detail": detail}


# --- in-browser codex terminal (Launch) --------------------------------------


async def _bridge_codex_terminal(ws: WebSocket, manifest: dict[str, Any], name: str) -> None:
    """Run ``node codex.js`` for one instance under a PTY, bridged to xterm.js.

    The instance's CODEX_HOME, workspace cwd, and keyless placeholder key are
    applied, so the browser terminal is the same Codex session the OS launcher
    would start -- served in the workbench instead of a separate console.
    """

    async def fail(text: str) -> None:
        with contextlib.suppress(Exception):
            await ws.send_text(f"\r\n[codex] {text}\r\n")
            await ws.close()

    if PtyProcess is None:
        await fail(f"PTY backend unavailable: {_PTY_IMPORT_ERROR or 'winpty/ptyprocess not installed'}")
        return
    install = _ensure_installed(manifest)
    if not install.get("ok"):
        await fail(f"install failed: {install.get('detail')}")
        return
    cfg = _instance_config(manifest, name)
    workspace = cfg.get("workspaceDir") or str(_plugin_dir(manifest))
    if not Path(workspace).is_dir():
        await fail(f"workspace directory does not exist: {workspace}")
        return
    node = shutil.which("node")
    entry = _codex_entry(manifest)
    if not node or not entry.is_file():
        await fail("Node.js or the Codex CLI is not available")
        return
    _write_instance_config(manifest, name)
    env = dict(os.environ)
    env["CODEX_HOME"] = str(_home_dir(manifest, name))
    env[cfg.get("envKey") or "EMULLM_API_KEY"] = EMULLM_PLACEHOLDER_KEY

    try:
        proc = PtyProcess.spawn([node, str(entry)], cwd=str(workspace), env=env, dimensions=(30, 100))
    except Exception as error:  # noqa: BLE001
        await fail(f"failed to start codex: {error}")
        return

    loop = asyncio.get_running_loop()
    outq: asyncio.Queue = asyncio.Queue()

    def reader() -> None:
        while True:
            try:
                data = proc.read(65536)
            except EOFError:
                break
            except Exception:  # noqa: BLE001
                break
            if data:
                loop.call_soon_threadsafe(outq.put_nowait, data)
        loop.call_soon_threadsafe(outq.put_nowait, None)

    threading.Thread(target=reader, daemon=True).start()

    async def sender() -> None:
        while True:
            data = await outq.get()
            if data is None:
                break
            with contextlib.suppress(Exception):
                await ws.send_text(data)
        with contextlib.suppress(Exception):
            await ws.send_text("\r\n[codex exited]\r\n")
        with contextlib.suppress(Exception):
            await ws.close()

    send_task = loop.create_task(sender())

    def _clamp(value: Any, fallback: int, hi: int) -> int:
        try:
            return max(1, min(hi, int(value)))
        except (TypeError, ValueError):
            return fallback

    try:
        while True:
            message = await ws.receive_text()
            control: Any = None
            with contextlib.suppress(Exception):
                control = json.loads(message)
            if isinstance(control, dict) and control.get("t") == "i":
                with contextlib.suppress(Exception):
                    proc.write(control.get("d", ""))
            elif isinstance(control, dict) and control.get("t") == "r":
                with contextlib.suppress(Exception):
                    proc.setwinsize(_clamp(control.get("r"), 30, 200), _clamp(control.get("c"), 100, 500))
            else:
                with contextlib.suppress(Exception):
                    proc.write(message)
    except WebSocketDisconnect:
        pass
    finally:
        with contextlib.suppress(Exception):
            proc.terminate(force=True)
        send_task.cancel()


def _codex_terminal_html(name: str) -> str:
    return _CODEX_TERM_HTML.replace("__NAME__", name)


# --- Responses <-> chat/completions adapter ----------------------------------
# Codex 0.152.1 speaks only the Responses API. Most LAN models expose
# chat/completions (often with OpenAI tool-calling). This adapter presents a
# Responses surface to Codex and forwards to the instance's upstream via
# chat/completions -- so ANY OpenAI-chat LAN model works as an agentic Codex.
# It is model-agnostic: EmuLLM is treated exactly like any other upstream, gets
# no special path, and tool-calls only flow if the upstream actually emits them.
# Tools are NEVER executed here -- tool-calls are relayed to Codex, which runs
# them locally in its workspace.


def _rid(prefix: str) -> str:
    return f"{prefix}-{uuid.uuid4().hex[:24]}"


def _flatten_text(content: Any) -> str:
    """Collapse a Responses/chat content value into plain text."""

    if isinstance(content, str):
        return content
    if isinstance(content, list):
        parts: list[str] = []
        for item in content:
            if isinstance(item, str):
                parts.append(item)
            elif isinstance(item, dict):
                if isinstance(item.get("text"), str):
                    parts.append(item["text"])
                elif isinstance(item.get("content"), (list, str)):
                    nested = _flatten_text(item["content"])
                    if nested:
                        parts.append(nested)
        return "\n".join(p for p in parts if p)
    if content is None:
        return ""
    return str(content)


def _stringify(value: Any) -> str:
    if isinstance(value, str):
        return value
    if isinstance(value, list):
        return _flatten_text(value)
    try:
        return json.dumps(value, ensure_ascii=False)
    except (TypeError, ValueError):
        return str(value)


def _responses_input_to_messages(body: dict[str, Any]) -> list[dict[str, Any]]:
    """Convert a Responses request (instructions + input items) to chat messages."""

    messages: list[dict[str, Any]] = []
    instructions = body.get("instructions")
    instr_text = _flatten_text(instructions) if instructions else ""
    if instr_text:
        messages.append({"role": "system", "content": instr_text})

    inp = body.get("input")
    if isinstance(inp, str):
        if inp:
            messages.append({"role": "user", "content": inp})
        return messages
    if not isinstance(inp, list):
        return messages

    for item in inp:
        if isinstance(item, str):
            messages.append({"role": "user", "content": item})
            continue
        if not isinstance(item, dict):
            continue
        itype = item.get("type")
        if itype in (None, "message"):
            role = item.get("role") or "user"
            if role == "developer":
                role = "system"
            messages.append({"role": role, "content": _flatten_text(item.get("content"))})
        elif itype == "function_call":
            messages.append({
                "role": "assistant",
                "content": None,
                "tool_calls": [{
                    "id": item.get("call_id") or item.get("id") or _rid("call"),
                    "type": "function",
                    "function": {"name": item.get("name") or "", "arguments": item.get("arguments") or "{}"},
                }],
            })
        elif itype == "function_call_output":
            messages.append({
                "role": "tool",
                "tool_call_id": item.get("call_id") or item.get("id") or "",
                "content": _stringify(item.get("output")),
            })
        # Other item types (reasoning, etc.) carry no chat-relevant text; skip.
    return messages


def _responses_tools_to_chat(tools: Any) -> list[dict[str, Any]] | None:
    """Convert Responses function tools to chat/completions tool definitions."""

    out: list[dict[str, Any]] = []
    for tool in tools or []:
        if not isinstance(tool, dict):
            continue
        if tool.get("type") != "function":
            # Non-function built-in tool types are not expressible as chat
            # functions; skip them (captured for later refinement if needed).
            continue
        fn = tool.get("function") if isinstance(tool.get("function"), dict) else {
            key: tool.get(key) for key in ("name", "description", "parameters", "strict")
        }
        name = fn.get("name")
        if not name:
            continue
        out.append({"type": "function", "function": {
            "name": name,
            "description": fn.get("description") or "",
            "parameters": fn.get("parameters") or {"type": "object", "properties": {}},
        }})
    return out or None


def _chat_to_responses_result(chat: dict[str, Any], model: str) -> dict[str, Any]:
    """Convert a chat/completions response into a Responses result object."""

    choice = (chat.get("choices") or [{}])[0]
    message = choice.get("message") if isinstance(choice.get("message"), dict) else {}
    output: list[dict[str, Any]] = []

    for call in message.get("tool_calls") or []:
        if not isinstance(call, dict):
            continue
        fn = call.get("function") if isinstance(call.get("function"), dict) else {}
        output.append({
            "id": _rid("fc"),
            "type": "function_call",
            "status": "completed",
            "name": fn.get("name") or "",
            "arguments": fn.get("arguments") or "{}",
            "call_id": call.get("id") or _rid("call"),
        })

    text = message.get("content")
    text = _flatten_text(text) if not isinstance(text, str) else text
    if text:
        output.append({
            "id": _rid("msg"),
            "type": "message",
            "role": "assistant",
            "status": "completed",
            "content": [{"type": "output_text", "text": text, "annotations": []}],
        })

    usage_in = (chat.get("usage") or {}).get("prompt_tokens", 0)
    usage_out = (chat.get("usage") or {}).get("completion_tokens", 0)
    return {
        "id": _rid("resp"),
        "object": "response",
        "created_at": int(time.time()),
        "model": model,
        "status": "completed",
        "output_text": text or "",
        "output": output,
        "usage": {"input_tokens": usage_in, "output_tokens": usage_out,
                  "total_tokens": usage_in + usage_out},
    }


def _responses_sse(result: dict[str, Any]) -> Any:
    """Yield a spec-compliant Responses SSE stream for message + function_call items."""

    seq = 0

    def frame(event_type: str, payload: dict[str, Any]) -> str:
        nonlocal seq
        data = {**payload, "type": event_type, "sequence_number": seq}
        seq += 1
        return f"event: {event_type}\ndata: {json.dumps(data, ensure_ascii=False)}\n\n"

    started = {**result, "status": "in_progress", "output": [], "output_text": ""}
    yield frame("response.created", {"response": started})
    yield frame("response.in_progress", {"response": started})
    for index, item in enumerate(result["output"]):
        if item["type"] == "message":
            text = item["content"][0]["text"] if item.get("content") else ""
            yield frame("response.output_item.added",
                        {"output_index": index, "item": {**item, "status": "in_progress", "content": []}})
            yield frame("response.content_part.added", {
                "item_id": item["id"], "output_index": index, "content_index": 0,
                "part": {"type": "output_text", "text": "", "annotations": []}})
            yield frame("response.output_text.delta", {
                "item_id": item["id"], "output_index": index, "content_index": 0, "delta": text})
            yield frame("response.output_text.done", {
                "item_id": item["id"], "output_index": index, "content_index": 0, "text": text})
            yield frame("response.content_part.done", {
                "item_id": item["id"], "output_index": index, "content_index": 0,
                "part": {"type": "output_text", "text": text, "annotations": []}})
            yield frame("response.output_item.done", {"output_index": index, "item": item})
        elif item["type"] == "function_call":
            args = item.get("arguments") or "{}"
            yield frame("response.output_item.added",
                        {"output_index": index, "item": {**item, "status": "in_progress", "arguments": ""}})
            yield frame("response.function_call_arguments.delta",
                        {"item_id": item["id"], "output_index": index, "delta": args})
            yield frame("response.function_call_arguments.done",
                        {"item_id": item["id"], "output_index": index, "arguments": args})
            yield frame("response.output_item.done", {"output_index": index, "item": item})
    yield frame("response.completed", {"response": result})


async def _adapter_complete(manifest: dict[str, Any], name: str, body: dict[str, Any]) -> dict[str, Any]:
    """Forward a Responses request to the instance's upstream via chat/completions."""

    cfg = _instance_config(manifest, name)
    upstream = (cfg.get("baseUrl") or "").rstrip("/")
    if not upstream:
        raise HTTPException(status_code=400, detail=f"Instance '{name}' has no upstream baseUrl configured")
    payload: dict[str, Any] = {
        "model": body.get("model") or cfg["model"],
        "messages": _responses_input_to_messages(body),
        "stream": False,
    }
    tools = _responses_tools_to_chat(body.get("tools"))
    if tools:
        payload["tools"] = tools
        choice = body.get("tool_choice")
        if choice is not None:
            payload["tool_choice"] = choice
    if body.get("temperature") is not None:
        payload["temperature"] = body["temperature"]

    headers = {"content-type": "application/json"}
    key = os.environ.get(cfg.get("envKey") or "", "")
    if key:
        headers["authorization"] = f"Bearer {key}"
    try:
        async with httpx.AsyncClient(timeout=600) as client:
            response = await client.post(f"{upstream}/chat/completions", json=payload, headers=headers)
    except httpx.HTTPError as error:
        raise HTTPException(status_code=502, detail=f"upstream request failed: {error}") from error
    if response.status_code >= 400:
        raise HTTPException(status_code=response.status_code,
                            detail=f"upstream {response.status_code}: {response.text[:800]}")
    try:
        chat = response.json()
    except ValueError as error:
        raise HTTPException(status_code=502, detail=f"upstream returned non-JSON: {error}") from error
    return _chat_to_responses_result(chat, payload["model"])


# --- instance registry -------------------------------------------------------


def _safe_name(name: str) -> str:
    name = (name or "").strip()
    if not _NAME_RE.match(name):
        raise HTTPException(
            status_code=400,
            detail="Instance name must be 1-64 chars: letters, digits, dot, dash, underscore, "
            "and start alphanumeric.",
        )
    return name


def _registry(manifest: dict[str, Any]) -> dict[str, dict[str, Any]]:
    stored = manifest.get("instances")
    return dict(stored) if isinstance(stored, dict) else {}


def _home_dir(manifest: dict[str, Any], name: str) -> Path:
    return _homes_dir(manifest) / name


def _instance_config(manifest: dict[str, Any], name: str) -> dict[str, str]:
    """Effective config for one instance: defaults overlaid with its registry entry."""

    entry = _registry(manifest).get(name)
    merged = dict(INSTANCE_DEFAULTS)
    if isinstance(entry, dict):
        for key in INSTANCE_DEFAULTS:
            value = entry.get(key)
            if isinstance(value, str) and value.strip():
                merged[key] = value.strip()
    if merged["wireApi"] not in WIRE_API_CHOICES:
        merged["wireApi"] = "responses"
    return merged


def _instance_names(manifest: dict[str, Any]) -> list[str]:
    """Union of registered instances and on-disk home directories, sorted.

    Scanning ``homes/`` means a home created outside the workbench still shows up.
    """

    names = set(_registry(manifest))
    homes = _homes_dir(manifest)
    if homes.is_dir():
        for child in homes.iterdir():
            if child.is_dir() and _NAME_RE.match(child.name):
                names.add(child.name)
    if not names:
        names.add(DEFAULT_INSTANCE)
    return sorted(names)


def _active_name(manifest: dict[str, Any]) -> str:
    active = str(manifest.get("activeInstance") or "").strip()
    names = _instance_names(manifest)
    if active in names:
        return active
    return names[0] if names else DEFAULT_INSTANCE


# --- config.toml & launcher --------------------------------------------------


def _config_path(manifest: dict[str, Any], name: str) -> Path:
    return _home_dir(manifest, name) / "config.toml"


def _launcher_path(manifest: dict[str, Any], name: str) -> Path:
    return _home_dir(manifest, name) / "launch_codex.bat"


def _toml_str(value: str) -> str:
    return '"' + value.replace("\\", "\\\\").replace('"', '\\"') + '"'


def _api_base(manifest: dict[str, Any]) -> str:
    return str(manifest.get("apiBase") or DEFAULT_API_BASE).rstrip("/")


def _adapter_url(manifest: dict[str, Any], name: str) -> str:
    """The local Responses<->chat adapter URL Codex points at for this instance."""

    return f"{_api_base(manifest)}/codex_cli/v1/{name}"


def _render_config_toml(cfg: dict[str, str], name: str, base_url: str) -> str:
    lines = [
        f"# Generated by the workbench codex_cli plugin for instance '{name}'.",
        "# base_url is the plugin's local Responses<->chat adapter, which forwards",
        f"# to the instance's upstream model ({cfg.get('baseUrl') or 'unset'}).",
        "",
    ]
    if cfg["model"]:
        lines.append(f"model = {_toml_str(cfg['model'])}")
    provider = cfg["providerId"] or "lan"
    lines.append(f"model_provider = {_toml_str(provider)}")
    lines.append("")
    lines.append(f"[model_providers.{provider}]")
    lines.append(f"name = {_toml_str(cfg['providerLabel'] or provider)}")
    lines.append(f"base_url = {_toml_str(base_url)}")
    lines.append(f"wire_api = {_toml_str(cfg['wireApi'])}")
    if cfg["envKey"]:
        lines.append(f"env_key = {_toml_str(cfg['envKey'])}")
    return "\n".join(lines) + "\n"


def _write_instance_config(manifest: dict[str, Any], name: str) -> Path:
    cfg = _instance_config(manifest, name)
    home = _home_dir(manifest, name)
    home.mkdir(parents=True, exist_ok=True)
    target = _config_path(manifest, name)
    target.write_text(_render_config_toml(cfg, name, _adapter_url(manifest, name)), encoding="utf-8")
    return target


def _write_instance_launcher(manifest: dict[str, Any], name: str) -> Path:
    cfg = _instance_config(manifest, name)
    home = _home_dir(manifest, name)
    home.mkdir(parents=True, exist_ok=True)
    entry = _codex_entry(manifest)
    workspace = cfg.get("workspaceDir") or str(_plugin_dir(manifest))
    env_key = cfg.get("envKey") or "EMULLM_API_KEY"
    lines = [
        "@echo off",
        f"REM Generated by the workbench codex_cli plugin for instance '{name}'.",
        f'set "CODEX_HOME={home}"',
        f'set "{env_key}={EMULLM_PLACEHOLDER_KEY}"',
        f'cd /d "{workspace}"',
        f'node "{entry}" %*',
    ]
    target = _launcher_path(manifest, name)
    target.write_text("\r\n".join(lines) + "\r\n", encoding="utf-8")
    return target


# --- instance operations -----------------------------------------------------


def _persist_registry(manifest: dict[str, Any], registry: dict[str, dict[str, Any]],
                      *, active: str | None = None) -> None:
    values: dict[str, Any] = {"instances": registry}
    if active is not None:
        values["activeInstance"] = active
    plugin_admin.write_manifest_values(manifest, values)
    manifest["instances"] = registry
    if active is not None:
        manifest["activeInstance"] = active


def _create_instance(manifest: dict[str, Any], name: str, overrides: dict[str, Any]) -> dict[str, Any]:
    name = _safe_name(name)
    registry = _registry(manifest)
    if name in registry or _home_dir(manifest, name).exists():
        raise HTTPException(status_code=409, detail=f"Instance already exists: {name}")
    entry = {key: str(overrides[key]).strip() for key in INSTANCE_DEFAULTS
             if key in overrides and isinstance(overrides[key], str) and str(overrides[key]).strip()}
    registry[name] = entry
    _persist_registry(manifest, registry, active=name)
    _write_instance_config(manifest, name)
    return {"ok": True, "name": name, "config": _instance_config(manifest, name)}


def _update_instance(manifest: dict[str, Any], name: str, overrides: dict[str, Any]) -> dict[str, Any]:
    name = _safe_name(name)
    registry = _registry(manifest)
    entry = dict(registry.get(name) or {})
    for key in INSTANCE_DEFAULTS:
        if key in overrides and isinstance(overrides[key], str):
            entry[key] = overrides[key].strip()
    if entry.get("wireApi") and entry["wireApi"] not in WIRE_API_CHOICES:
        entry["wireApi"] = "responses"
    registry[name] = entry
    _persist_registry(manifest, registry)
    _write_instance_config(manifest, name)
    return {"ok": True, "name": name, "config": _instance_config(manifest, name)}


def _delete_instance(manifest: dict[str, Any], name: str) -> dict[str, Any]:
    name = _safe_name(name)
    registry = _registry(manifest)
    registry.pop(name, None)
    home = _home_dir(manifest, name)
    removed = False
    if home.is_dir():
        shutil.rmtree(home, ignore_errors=True)
        removed = True
    active = _active_name({**manifest, "instances": registry, "activeInstance": ""})
    _persist_registry(manifest, registry, active=active)
    return {"ok": True, "name": name, "homeRemoved": removed}


def _launch_instance(manifest: dict[str, Any], name: str) -> dict[str, Any]:
    name = _safe_name(name)
    cfg = _instance_config(manifest, name)
    workspace = Path(cfg.get("workspaceDir") or "")
    if not workspace.is_dir():
        return {"ok": False, "detail": f"Workspace directory does not exist: {workspace}"}

    install = _ensure_installed(manifest)
    if not install.get("ok"):
        return {"ok": False, "stage": "install", "detail": install.get("detail", "install failed")}

    # Record the instance if it existed only as an on-disk home.
    registry = _registry(manifest)
    if name not in registry:
        registry[name] = {}
        _persist_registry(manifest, registry)

    config_path = _write_instance_config(manifest, name)
    launcher = _write_instance_launcher(manifest, name)

    spawned, spawn_detail = False, ""
    try:
        subprocess.Popen(  # noqa: S603 - fixed cmd, argument list, no user shell string
            ["cmd", "/c", "start", f"Codex - {name}", "cmd", "/k", str(launcher)],
            cwd=str(workspace), close_fds=True,
        )
        spawned = True
    except (OSError, subprocess.SubprocessError) as error:
        spawn_detail = str(error)

    return {
        "ok": True, "name": name, "installed": install.get("installed"),
        "ranInstall": install.get("ranInstall"), "configPath": str(config_path),
        "launcher": str(launcher), "workspace": str(workspace),
        "model": cfg["model"], "baseUrl": cfg["baseUrl"], "spawnedConsole": spawned,
        "detail": "Codex launched in a new console."
        if spawned else f"Config and launcher written; run {launcher} in a terminal."
        + (f" (console launch failed: {spawn_detail})" if spawn_detail else ""),
    }


def _instance_status(manifest: dict[str, Any], name: str) -> dict[str, Any]:
    cfg = _instance_config(manifest, name)
    return {
        "name": name,
        "model": cfg["model"],
        "baseUrl": cfg["baseUrl"],
        "wireApi": cfg["wireApi"],
        "providerId": cfg["providerId"],
        "providerLabel": cfg["providerLabel"],
        "envKey": cfg["envKey"],
        "workspaceDir": cfg["workspaceDir"],
        "homeExists": _home_dir(manifest, name).is_dir(),
        "configWritten": _config_path(manifest, name).is_file(),
        "launcherWritten": _launcher_path(manifest, name).is_file(),
        "workspaceExists": bool(cfg["workspaceDir"]) and Path(cfg["workspaceDir"]).is_dir(),
    }


def _list_instances(manifest: dict[str, Any]) -> dict[str, Any]:
    names = _instance_names(manifest)
    return {
        "instances": [_instance_status(manifest, name) for name in names],
        "active": _active_name(manifest),
        "installed": _codex_installed(manifest),
        "codexVersion": _VERSION_CACHE.get(str(_plugin_dir(manifest)), ""),
        "node": _node() or "",
    }


# --- administration descriptor (option B) ------------------------------------


def _describe(manifest: dict[str, Any]) -> dict[str, Any]:
    node = _node()
    installed = _codex_installed(manifest)
    version = _VERSION_CACHE.get(str(_plugin_dir(manifest)), "")
    names = _instance_names(manifest)
    active = _active_name(manifest)
    st = _instance_status(manifest, active)

    status_items = [
        plugin_admin.status("Route prefix", plugin_admin.admin_prefix(manifest), "neutral"),
        plugin_admin.status("Node.js", node or "not found", "ok" if node else "error",
                            detail="" if node else "Codex requires Node.js 22+ on PATH."),
        plugin_admin.status("Codex CLI", "installed" if installed else "not installed",
                            "ok" if installed else "warn",
                            detail="" if installed else "Use Launch or Install."),
        plugin_admin.status("Codex version", version or "unknown", "ok" if version else "neutral"),
        plugin_admin.status("Instances", len(names), "ok"),
        plugin_admin.status("Active instance", active, "ok"),
        plugin_admin.status("Model (served by EmuLLM)", st["model"] or "(unset)", "ok" if st["model"] else "warn"),
        plugin_admin.status("EmuLLM base URL", st["baseUrl"] or "(unset)", "ok" if st["baseUrl"] else "warn",
                            detail="Codex is only a client of EmuLLM; EmuLLM is not modified."),
        plugin_admin.status("Workspace", st["workspaceDir"] or "(unset)",
                            "ok" if st["workspaceExists"] else "warn"),
        plugin_admin.status("config.toml", "written" if st["configWritten"] else "not written",
                            "ok" if st["configWritten"] else "warn", detail=str(_config_path(manifest, active))),
    ]

    instance_section = plugin_admin.section(
        "instance", "Active instance",
        [
            plugin_admin.field("activeInstance", "Instance", "select", active,
                               help_text="Which instance the fields and actions below apply to.",
                               options=names),
            plugin_admin.field("model", "Model", "text", st["model"],
                               help_text="Model served by EmuLLM's router, e.g. router/gpt-5.6-sol.",
                               placeholder="router/gpt-5.6-sol"),
            plugin_admin.field("baseUrl", "Base URL", "text", st["baseUrl"],
                               help_text="EmuLLM's keyless OpenAI-compatible base URL, including /v1.",
                               placeholder="http://127.0.0.1:8801/v1"),
            plugin_admin.field("wireApi", "Wire API", "select", st["wireApi"], options=WIRE_API_CHOICES),
            plugin_admin.field("workspaceDir", "Workspace directory", "text", st["workspaceDir"],
                               help_text="Directory Codex runs in for this instance.",
                               placeholder=r"C:\snet\PeTTa\repos\symbolic_learner_workbench"),
            plugin_admin.field("providerId", "Provider id", "text", st["providerId"], placeholder="emullm"),
            plugin_admin.field("providerLabel", "Provider label", "text", st["providerLabel"],
                               placeholder="EmuLLM Router"),
            plugin_admin.field("envKey", "API key env var", "text", st["envKey"],
                               help_text="EmuLLM is keyless; the launcher sets a placeholder. Never stored here.",
                               placeholder="EMULLM_API_KEY"),
        ],
        description="Select an instance and edit it. Save settings to persist and write its config.toml.",
    )
    create_section = plugin_admin.section(
        "create", "Create instance",
        [
            plugin_admin.field("newInstanceName", "New instance name", "text",
                               str(manifest.get("newInstanceName") or ""),
                               help_text="Type a name, Save settings, then use the Create instance action.",
                               placeholder="scratch"),
        ],
        description="New instances start from the EmuLLM defaults; edit them after creating.",
    )

    return plugin_admin.descriptor(
        manifest,
        title="Codex CLI",
        summary="Install, configure, and launch Codex instances (served by EmuLLM router/gpt-5.6-sol).",
        status_items=status_items,
        sections=[instance_section, create_section],
        actions=[
            plugin_admin.action("launch", "Launch active", tone="primary",
                                description="Install if needed, write config, open Codex for the active instance."),
            plugin_admin.action("createInstance", "Create instance",
                                description="Create the instance named above from EmuLLM defaults."),
            plugin_admin.action("deleteInstance", "Delete active",
                                description="Remove the active instance's home directory and registry entry."),
            plugin_admin.action("checkCodex", "Check Codex", description="Run codex --version."),
            plugin_admin.action("writeConfig", "Write active config",
                                description="Regenerate the active instance's config.toml."),
        ],
    )


def _apply_settings(manifest: dict[str, Any], values: dict[str, Any]) -> dict[str, Any]:
    # Switch the active instance first, so field edits apply to the intended one.
    requested = str(values.get("activeInstance") or "").strip()
    active = requested if requested in _instance_names(manifest) else _active_name(manifest)

    registry = _registry(manifest)
    entry = dict(registry.get(active) or {})
    for key in INSTANCE_DEFAULTS:
        if key in values and isinstance(values[key], str):
            entry[key] = values[key].strip()
    if entry.get("wireApi") and entry["wireApi"] not in WIRE_API_CHOICES:
        entry["wireApi"] = "responses"
    registry[active] = entry

    new_name = ""
    if "newInstanceName" in values and isinstance(values["newInstanceName"], str):
        new_name = values["newInstanceName"].strip()

    plugin_admin.write_manifest_values(
        manifest, {"instances": registry, "activeInstance": active, "newInstanceName": new_name}
    )
    manifest["instances"] = registry
    manifest["activeInstance"] = active
    manifest["newInstanceName"] = new_name
    _write_instance_config(manifest, active)
    return {"ok": True, "active": active, "config": _instance_config(manifest, active)}


# --- routers -----------------------------------------------------------------


def create_admin_router(manifest: dict[str, Any]) -> APIRouter:
    """Build the Codex CLI configure descriptor page (option B)."""

    def describe() -> dict[str, Any]:
        return _describe(manifest)

    def apply_settings(values: dict[str, Any]) -> dict[str, Any]:
        return _apply_settings(manifest, values)

    def launch_action(_body: dict[str, Any]) -> dict[str, Any]:
        return _launch_instance(manifest, _active_name(manifest))

    def create_action(_body: dict[str, Any]) -> dict[str, Any]:
        name = str(manifest.get("newInstanceName") or "").strip()
        if not name:
            raise HTTPException(status_code=400,
                                detail="Set 'New instance name' and Save settings before creating.")
        result = _create_instance(manifest, name, {})
        plugin_admin.write_manifest_values(manifest, {"newInstanceName": ""})
        manifest["newInstanceName"] = ""
        return result

    def delete_action(_body: dict[str, Any]) -> dict[str, Any]:
        return _delete_instance(manifest, _active_name(manifest))

    def check_action(_body: dict[str, Any]) -> dict[str, Any]:
        return _check_codex(manifest)

    def write_action(_body: dict[str, Any]) -> dict[str, Any]:
        return {"ok": True, "path": str(_write_instance_config(manifest, _active_name(manifest)))}

    return plugin_admin.build_admin_router(
        manifest,
        describe=describe,
        apply_settings=apply_settings,
        actions={
            "launch": launch_action,
            "createInstance": create_action,
            "deleteInstance": delete_action,
            "checkCodex": check_action,
            "writeConfig": write_action,
        },
        initialize=lambda _body: initialize(manifest),
    )


def create_router(manifest: dict[str, Any]) -> APIRouter:
    """Serve the instances REST API and the dedicated manager page (option A)."""

    router = APIRouter()
    prefix = str(manifest.get("routePrefix") or "/codex_cli").rstrip("/")

    @router.get(f"{prefix}/instances")
    def list_instances() -> dict[str, Any]:
        return _list_instances(manifest)

    @router.post(f"{prefix}/instances")
    def create_instance(body: dict[str, Any] = Body(default_factory=dict)) -> dict[str, Any]:
        return _create_instance(manifest, str(body.get("name") or ""), body)

    @router.put(f"{prefix}/instances/{{name}}")
    def update_instance(name: str, body: dict[str, Any] = Body(default_factory=dict)) -> dict[str, Any]:
        return _update_instance(manifest, name, body)

    @router.delete(f"{prefix}/instances/{{name}}")
    def delete_instance(name: str) -> dict[str, Any]:
        return _delete_instance(manifest, name)

    @router.post(f"{prefix}/instances/{{name}}/launch")
    def launch_instance(name: str) -> dict[str, Any]:
        return _launch_instance(manifest, name)

    @router.post(f"{prefix}/instances/{{name}}/install")
    def install_instance(name: str) -> dict[str, Any]:
        _safe_name(name)
        return _ensure_installed(manifest)

    @router.get(f"{prefix}/manage", response_class=HTMLResponse)
    def manage_page() -> HTMLResponse:
        return HTMLResponse(_MANAGER_HTML)

    @router.post(f"{prefix}/v1/{{name}}/responses")
    async def adapter_responses(name: str, request: Request) -> Any:
        safe = _safe_name(name)
        try:
            body = await request.json()
        except Exception as error:  # noqa: BLE001
            raise HTTPException(status_code=400, detail=f"invalid JSON body: {error}") from error
        result = await _adapter_complete(manifest, safe, body if isinstance(body, dict) else {})
        if body.get("stream") if isinstance(body, dict) else False:
            return StreamingResponse(_responses_sse(result), media_type="text/event-stream")
        return JSONResponse(result)

    @router.get(f"{prefix}/v1/{{name}}/models")
    async def adapter_models(name: str) -> Any:
        cfg = _instance_config(manifest, _safe_name(name))
        upstream = (cfg.get("baseUrl") or "").rstrip("/")
        if upstream:
            try:
                async with httpx.AsyncClient(timeout=30) as client:
                    response = await client.get(f"{upstream}/models")
                return JSONResponse(status_code=response.status_code, content=response.json())
            except Exception:  # noqa: BLE001 - fall back to the configured model id
                pass
        return JSONResponse({"object": "list", "data": [{"id": cfg["model"], "object": "model"}]})

    @router.get(f"{prefix}/term/{{name}}", response_class=HTMLResponse)
    def codex_terminal_page(name: str) -> HTMLResponse:
        _safe_name(name)
        return HTMLResponse(_codex_terminal_html(name))

    @router.websocket(f"{prefix}/term/{{name}}")
    async def codex_terminal_ws(ws: WebSocket, name: str) -> None:
        await ws.accept()
        host = ws.client.host if ws.client else None
        if host not in {"127.0.0.1", "::1", "localhost", None}:
            await ws.close(code=1008)
            return
        try:
            safe = _safe_name(name)
        except HTTPException:
            with contextlib.suppress(Exception):
                await ws.send_text("\r\n[codex] invalid instance name\r\n")
                await ws.close(code=1008)
            return
        await _bridge_codex_terminal(ws, manifest, safe)

    return router


# --- lifecycle ---------------------------------------------------------------


def initialize(manifest: dict[str, Any]) -> dict[str, Any]:
    """Seed the registry, migrating any legacy single-instance ``codex`` config."""

    report = plugin_admin.initialization_report(manifest)
    if not isinstance(manifest.get("instances"), dict) or not manifest.get("instances"):
        legacy = manifest.get("codex") if isinstance(manifest.get("codex"), dict) else {}
        base = {key: legacy[key] for key in INSTANCE_DEFAULTS
                if isinstance(legacy.get(key), str) and legacy[key].strip()} or dict(INSTANCE_DEFAULTS)
        plugin_admin.write_manifest_values(
            manifest, {"instances": {DEFAULT_INSTANCE: base}, "activeInstance": DEFAULT_INSTANCE}
        )
        manifest["instances"] = {DEFAULT_INSTANCE: base}
        manifest["activeInstance"] = DEFAULT_INSTANCE
    probe = _check_codex(manifest) if _codex_installed(manifest) else {"version": ""}
    return {
        "ready": report["ready"], "checks": report["checks"],
        "codexInstalled": _codex_installed(manifest),
        "codexVersion": probe.get("version", ""),
        "instances": _instance_names(manifest),
    }


# --- dedicated manager page (option A) ---------------------------------------

_MANAGER_HTML = """<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Codex Instances</title>
<style>
  :root { color-scheme: dark; }
  body { margin: 0; font: 14px/1.5 system-ui, sans-serif; background: #0e1116; color: #e6edf3; }
  header { padding: 16px 20px; border-bottom: 1px solid #232a33; }
  header h1 { margin: 0 0 4px; font-size: 18px; }
  header p { margin: 0; color: #9aa7b4; font-size: 12px; }
  .bar { padding: 12px 20px; display: flex; gap: 8px; align-items: center; flex-wrap: wrap; border-bottom: 1px solid #232a33; }
  .bar input { background: #161b22; border: 1px solid #30363d; color: #e6edf3; padding: 6px 8px; border-radius: 6px; }
  button { background: #21262d; border: 1px solid #30363d; color: #e6edf3; padding: 6px 10px; border-radius: 6px; cursor: pointer; }
  button:hover { background: #2a3038; }
  button.primary { background: #1f6feb; border-color: #1f6feb; }
  button.danger { background: #4b1113; border-color: #6e2427; }
  .wrap { padding: 12px 20px; overflow: auto; }
  table { border-collapse: collapse; width: 100%; min-width: 900px; }
  th, td { text-align: left; padding: 8px 10px; border-bottom: 1px solid #232a33; vertical-align: top; }
  th { color: #9aa7b4; font-weight: 600; font-size: 12px; text-transform: uppercase; }
  td input, td select { width: 100%; box-sizing: border-box; background: #161b22; border: 1px solid #30363d; color: #e6edf3; padding: 4px 6px; border-radius: 6px; }
  .pill { font-size: 11px; padding: 1px 7px; border-radius: 999px; border: 1px solid #30363d; }
  .ok { color: #3fb950; border-color: #23502b; } .no { color: #d29922; border-color: #5a4415; }
  .row-actions { display: flex; gap: 6px; flex-wrap: wrap; }
  .msg { padding: 8px 20px; font-size: 12px; color: #9aa7b4; min-height: 18px; }
  code { color: #79c0ff; }
</style>
</head>
<body>
<header>
  <h1>Codex Instances</h1>
  <p>Each instance is an isolated CODEX_HOME served by EmuLLM. Codex is only a client of EmuLLM &mdash; EmuLLM is never modified.</p>
</header>
<div class="bar">
  <input id="newName" placeholder="new instance name (e.g. scratch)" />
  <button class="primary" onclick="createInstance()">Create instance</button>
  <button onclick="load()">Refresh</button>
  <span id="env" style="color:#9aa7b4;font-size:12px;"></span>
</div>
<div class="msg" id="msg"></div>
<div class="wrap">
  <table>
    <thead><tr>
      <th>Instance</th><th>Model</th><th>Base URL</th><th>Workspace</th><th>Wire</th><th>State</th><th>Actions</th>
    </tr></thead>
    <tbody id="rows"></tbody>
  </table>
</div>
<script>
const $ = (id) => document.getElementById(id);
function msg(t, err) { const m = $("msg"); m.textContent = t || ""; m.style.color = err ? "#f85149" : "#9aa7b4"; }
async function api(path, opts) {
  const r = await fetch(path, opts);
  const body = await r.json().catch(() => ({}));
  if (!r.ok) throw new Error(body.detail || r.statusText);
  return body;
}
function esc(s) { return (s == null ? "" : String(s)); }
function pill(ok, label) { return `<span class="pill ${ok ? "ok" : "no"}">${label}</span>`; }
function row(it) {
  const n = esc(it.name);
  return `<tr data-name="${n}">
    <td><b>${n}</b></td>
    <td><input value="${esc(it.model)}" data-f="model"></td>
    <td><input value="${esc(it.baseUrl)}" data-f="baseUrl"></td>
    <td><input value="${esc(it.workspaceDir)}" data-f="workspaceDir"></td>
    <td><select data-f="wireApi">
      <option ${it.wireApi==="responses"?"selected":""}>responses</option>
      <option ${it.wireApi==="chat"?"selected":""}>chat</option>
    </select></td>
    <td>${pill(it.homeExists,"home")} ${pill(it.configWritten,"config")} ${pill(it.workspaceExists,"ws")}</td>
    <td class="row-actions">
      <button onclick="save('${n}')">Save</button>
      <button class="primary" onclick="launchUI('${n}')">Launch</button>
      <button onclick="launchConsole('${n}')">Console</button>
      <button onclick="install('${n}')">Install</button>
      <button class="danger" onclick="del('${n}')">Delete</button>
    </td>
  </tr>`;
}
function collect(name) {
  const tr = document.querySelector(`tr[data-name="${CSS.escape(name)}"]`);
  const out = {};
  tr.querySelectorAll("[data-f]").forEach(el => out[el.getAttribute("data-f")] = el.value);
  return out;
}
async function load() {
  try {
    const data = await api("instances");
    $("rows").innerHTML = data.instances.map(row).join("");
    $("env").textContent = `Codex: ${data.installed ? (data.codexVersion || "installed") : "not installed"} \u00b7 active: ${data.active}`;
    msg("");
  } catch (e) { msg(e.message, true); }
}
async function createInstance() {
  const name = $("newName").value.trim();
  if (!name) return msg("Enter a name first.", true);
  try { await api("instances", { method: "POST", headers: {"content-type":"application/json"}, body: JSON.stringify({ name }) });
    $("newName").value = ""; msg(`Created ${name}.`); load(); }
  catch (e) { msg(e.message, true); }
}
async function save(name) {
  try { await api(`instances/${encodeURIComponent(name)}`, { method: "PUT", headers: {"content-type":"application/json"}, body: JSON.stringify(collect(name)) });
    msg(`Saved ${name}.`); load(); }
  catch (e) { msg(e.message, true); }
}
async function launchUI(name) {
  // Save any inline edits first so the terminal uses current config, then open
  // the in-browser Codex terminal for this instance.
  try { await api(`instances/${encodeURIComponent(name)}`, { method: "PUT", headers: {"content-type":"application/json"}, body: JSON.stringify(collect(name)) }); } catch (e) { /* non-fatal */ }
  window.open(`/codex_cli/term/${encodeURIComponent(name)}`, "_blank");
}
async function launchConsole(name) {
  msg(`Launching ${name} in an OS console\u2026`);
  try { const r = await api(`instances/${encodeURIComponent(name)}/launch`, { method: "POST" });
    msg(r.detail || `Launched ${name}.`); load(); }
  catch (e) { msg(e.message, true); }
}
async function install(name) {
  msg(`Installing Codex\u2026`);
  try { const r = await api(`instances/${encodeURIComponent(name)}/install`, { method: "POST" });
    msg(r.ok ? "Codex installed." : (r.detail || "install failed"), !r.ok); load(); }
  catch (e) { msg(e.message, true); }
}
async function del(name) {
  if (!confirm(`Delete instance "${name}" and its home directory?`)) return;
  try { await api(`instances/${encodeURIComponent(name)}`, { method: "DELETE" }); msg(`Deleted ${name}.`); load(); }
  catch (e) { msg(e.message, true); }
}
load();
</script>
</body>
</html>
"""


# --- in-browser codex terminal page ------------------------------------------

_CODEX_TERM_HTML = """<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Codex - __NAME__</title>
<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@xterm/xterm@5.5.0/css/xterm.min.css">
<style>
  :root { color-scheme: dark; }
  html, body { margin: 0; height: 100%; background: #0e1116; color: #e6edf3; font: 13px/1.4 system-ui, sans-serif; }
  #bar { padding: 8px 12px; border-bottom: 1px solid #232a33; display: flex; gap: 10px; align-items: center; }
  #bar b { color: #e6edf3; } #bar span { color: #9aa7b4; }
  #status { margin-left: auto; color: #d29922; } #status.on { color: #3fb950; }
  #term { position: absolute; top: 41px; left: 0; right: 0; bottom: 0; padding: 6px; }
</style>
</head>
<body>
<div id="bar">
  <b>Codex</b> <span>instance: __NAME__ &middot; via EmuLLM router</span>
  <span id="status">connecting\u2026</span>
</div>
<div id="term"></div>
<script src="https://cdn.jsdelivr.net/npm/@xterm/xterm@5.5.0/lib/xterm.min.js"></script>
<script src="https://cdn.jsdelivr.net/npm/@xterm/addon-fit@0.10.0/lib/addon-fit.min.js"></script>
<script>
  const name = "__NAME__";
  const term = new Terminal({ cursorBlink: true, fontSize: 13,
    fontFamily: 'Consolas, "Cascadia Mono", "DejaVu Sans Mono", monospace',
    theme: { background: "#0e1116", foreground: "#e6edf3" } });
  const fit = new FitAddon.FitAddon();
  term.loadAddon(fit);
  term.open(document.getElementById("term"));
  fit.fit();
  const status = document.getElementById("status");
  const proto = window.location.protocol === "https:" ? "wss" : "ws";
  const ws = new WebSocket(`${proto}://${window.location.host}/codex_cli/term/${encodeURIComponent(name)}`);
  ws.onopen = () => {
    status.textContent = "connected"; status.className = "on";
    ws.send(JSON.stringify({ t: "r", c: term.cols, r: term.rows }));
    term.focus();
  };
  ws.onmessage = (e) => term.write(e.data);
  ws.onclose = () => { status.textContent = "disconnected"; status.className = ""; };
  ws.onerror = () => { status.textContent = "error"; status.className = ""; };
  term.onData((d) => { if (ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify({ t: "i", d })); });
  const onResize = () => { fit.fit(); if (ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify({ t: "r", c: term.cols, r: term.rows })); };
  window.addEventListener("resize", onResize);
</script>
</body>
</html>
"""