opencode_runtime.py

"""Official OpenCode UI/client; inference remains owned by llama-server."""

from __future__ import annotations

import hashlib
import json
import os
import shutil
import subprocess
import sys
import tarfile
import time
from pathlib import Path

import httpx
from opencode_history import HistoryStore
from opencode_mcp_auth import ensure_pc_mcp_auth

OPENCODE_VERSION = "1.18.35"
OPENCODE_ARCHIVE_URL = (
    "https://github.com/anomalyco/opencode/releases/download/"
    f"v{OPENCODE_VERSION}/opencode-linux-x64.tar.gz"
)
OPENCODE_ARCHIVE_SHA256 = "c8f888b451f5494a18f858fffb0e0b68f4e4baa9c241761c5f206884f0fa640d"
PROVIDER_ID = "llamacpp"
ZEN_FREE_PROVIDER = "opencode"
# Free-only mode (SKIP_LLAMA): OpenCode's own Zen models, key from the
# OPENCODE_ZEN_API_KEY space secret (alias of OPENCODE_API_KEY). Curated free
# IDs below were live on the Zen catalog at the Oct 10 audit; the picker
# resyncs when the catalog moves.
# Proven live Oct 14 with real tool calls through this exact stack; big-pickle
# role-plays tool calls as text instead of invoking them, so it stays out.
ZEN_DEFAULT_MODEL = "nemotron-3-ultra-free"
ZEN_SMALL_MODEL = "nemotron-3-ultra-free"


def ensure_opencode(root: Path) -> Path:
    """Install only the pinned official client, checking its release digest."""
    binary = root / "bin" / "opencode"
    manifest = root / "verified-binary.json"
    if binary.exists():
        try:
            saved = json.loads(manifest.read_text(encoding="utf-8"))
            with binary.open("rb") as cached:
                actual = hashlib.file_digest(cached, "sha256").hexdigest()
        except (OSError, ValueError) as exc:
            raise RuntimeError("Cached OpenCode has no readable integrity record") from exc
        if saved.get("archive_sha256") != OPENCODE_ARCHIVE_SHA256 or saved.get("binary_sha256") != actual:
            raise RuntimeError("Cached OpenCode integrity mismatch; refusing to execute")
    if not binary.exists():
        binary.parent.mkdir(parents=True, exist_ok=True)
        archive = root / "opencode.tar.gz.part"
        pending = binary.with_suffix(".part")
        digest = hashlib.sha256()
        print(f"[opencode] downloading official client v{OPENCODE_VERSION}", flush=True)
        try:
            with httpx.stream("GET", OPENCODE_ARCHIVE_URL, follow_redirects=True, timeout=90) as response:
                response.raise_for_status()
                size = 0
                with archive.open("wb") as output:
                    for chunk in response.iter_bytes():
                        size += len(chunk)
                        if size > 150_000_000:
                            raise RuntimeError("OpenCode archive exceeds the expected size limit")
                        digest.update(chunk)
                        output.write(chunk)
            if digest.hexdigest() != OPENCODE_ARCHIVE_SHA256:
                raise RuntimeError("OpenCode release SHA-256 mismatch; refusing to execute")
            with tarfile.open(archive, "r:gz") as bundle:
                members = [m for m in bundle.getmembers() if m.name in {"opencode", "./opencode"}]
                if len(members) != 1 or not members[0].isfile():
                    raise RuntimeError("Official OpenCode archive has an unexpected layout")
                source = bundle.extractfile(members[0])
                if source is None:
                    raise RuntimeError("OpenCode executable missing from archive")
                with source, pending.open("wb") as output:
                    shutil.copyfileobj(source, output)
            pending.chmod(0o755)
            pending.replace(binary)
            with binary.open("rb") as installed:
                binary_hash = hashlib.file_digest(installed, "sha256").hexdigest()
            manifest.write_text(json.dumps({"archive_sha256": OPENCODE_ARCHIVE_SHA256,
                                            "binary_sha256": binary_hash}), encoding="utf-8")
        finally:
            archive.unlink(missing_ok=True)
            pending.unlink(missing_ok=True)
    version = subprocess.check_output([str(binary), "--version"], text=True, timeout=30).strip()
    if version != OPENCODE_VERSION:
        raise RuntimeError(f"Unexpected OpenCode version: {version!r}")
    print(f"[opencode] official client version={version} archive_sha256={OPENCODE_ARCHIVE_SHA256}", flush=True)
    return binary


def make_config(*, model_id: str | None, context: int, api_port: int, ui_port: int, bridge: Path,
                mcp_url: str, token_url: str, free_only: bool = False) -> dict:
    if free_only:
        enabled_providers = [ZEN_FREE_PROVIDER]
        selected = f"{ZEN_FREE_PROVIDER}/{ZEN_DEFAULT_MODEL}"
        small_selected = f"{ZEN_FREE_PROVIDER}/{ZEN_SMALL_MODEL}"
        providers: dict = {
            ZEN_FREE_PROVIDER: {},
        }
    else:
        if not model_id or context < 8192:
            raise ValueError("Existing model ID and context are required")
        selected = f"{PROVIDER_ID}/{model_id}"
        enabled_providers = [PROVIDER_ID, ZEN_FREE_PROVIDER]
        providers = {
            PROVIDER_ID: {
                "npm": "@ai-sdk/openai-compatible",
                "name": "llama.cpp CPU-only",
                "whitelist": [model_id],
                "options": {"baseURL": f"http://127.0.0.1:{api_port}/v1", "timeout": 900000},
                "models": {
                    model_id: {
                        "name": "Naldo Coder (CPU)",
                        "tool_call": True,
                        "reasoning": True,
                        "limit": {"context": context, "output": 32768},
                    }
                },
            },
            ZEN_FREE_PROVIDER: {},
        }
    return {
        "$schema": "https://opencode.ai/config.json",
        "autoupdate": False,
        "share": "disabled",
        "enabled_providers": enabled_providers,
        "model": selected,
        "small_model": small_selected if free_only else selected,
        "default_agent": "1agent",
        "server": {"hostname": "127.0.0.1", "port": ui_port},
        "provider": providers,
        "mcp": {
            "naldo_pc": {
                "type": "remote",
                "url": "https://naldo-mcp-render.onrender.com/mcp",
                "enabled": True,
                "timeout": 180000,
            }
        },
        "lsp": False,
        "formatter": False,
        "permission": {
            "*": "deny",
            "external_directory": "deny",
            "edit": "allow",
            "glob": "allow",
            "grep": "allow",
            "list": "allow",
            "invalid": "allow",
            "read": "allow",
            "skill": {"*": "ask", "1agent-policy": "allow"},
            "bash": "allow",
            "naldo_pc_*": "allow",
            "websearch": "allow",
            "webfetch": "allow",
            "todowrite": "allow",
            "question": "allow",
        },
        "agent": {
            "1agent": {
                "description": "Agente personalizado 1agent.md para testes privados",
                "mode": "primary",
                "prompt": "{file:./prompts/1agent.md}",
                "temperature": 0.0,
            },
            "build": {
                "prompt": (
                    "Responda em portugues do Brasil. Voce e Naldo Agent. "
                    "O computador Windows do usuario e acessado pelas ferramentas naldo_pc. "
                    "O ambiente local deste servidor e o Space Linux, nao o PC do usuario. "
                    "Use naldo_pc_start_process com PowerShell puro; ele ja usa powershell.exe. "
                    "Quando receber um PID, acompanhe esse mesmo PID com read_process_output; "
                    "nao repita start_process para consultar o mesmo comando. "
                    "Use websearch para pesquisar e webfetch para ler URLs verificadas. "
                    "Nao invente resultados nem exponha segredos. "
                    "O modelo padrao e o llama.cpp CPU-only; alternativas Zen Free sao externas, nunca use a GPU do Space. "
                    "Quando a ferramenta responder ao pedido, conclua sem repetir chamadas."
                )
            }
        },
    }


def prepare_config(*, root: Path, expected_model: str, context: int, api_port: int,
                   ui_port: int, bridge: Path, mcp_url: str, token_url: str,
                   validate: bool = True, free_only: bool = False) -> tuple[Path, dict]:
    model_id: str | None = None
    if validate:
        response = httpx.get(f"http://127.0.0.1:{api_port}/v1/models", timeout=10)
        response.raise_for_status()
        ids = [m.get("id") for m in response.json().get("data", [])]
        if ids != [expected_model]:
            raise RuntimeError(f"Expected exactly the existing model {expected_model!r}; got {ids!r}")
        model_id = ids[0]
    else:
        print("[opencode] CONFIG=SKIP local model validation (SKIP_LLAMA free-only)", flush=True)
    config = make_config(model_id=model_id, context=context, api_port=api_port, ui_port=ui_port,
                         bridge=bridge, mcp_url=mcp_url, token_url=token_url, free_only=free_only)
    root.mkdir(parents=True, exist_ok=True)
    source_prompt = Path(__file__).resolve().parent / "agent_prompts" / "1agent.md"
    source_data = source_prompt.read_bytes()
    if hashlib.sha256(source_data).hexdigest() != "2c28b84910f9f9262460655c13347fb578d32cd2e2fdf9e65de971805de7ce65":
        raise RuntimeError("Original 1agent.md integrity check failed")
    prompt_dir = root / "prompts"
    prompt_dir.mkdir(parents=True, exist_ok=True)
    destination = prompt_dir / "1agent.md"
    if destination.exists() and destination.read_bytes() != source_data:
        raise RuntimeError("Unexpected existing OpenCode agent prompt")
    if not destination.exists():
        destination.write_bytes(source_data)
    # OPENCODE_CONFIG_CONTENT is parsed independently of OPENCODE_CONFIG:
    # relative {file:...} references resolve against request-specific directories
    # (for example /root/.local), not the source configuration file.
    # Absolute file reference keeps the original agent prompt unmodified.
    config["agent"]["1agent"]["prompt"] = "{file:" + str(destination.resolve()) + "}"
    config["instructions"] = [str(destination.resolve())]
    # V1 global AGENTS.md and an optional policy skill supplement instructions.
    # The canonical source remains the unchanged, SHA-256-verified 1agent.md.
    global_config = root / "config" / "opencode"
    global_config.mkdir(parents=True, exist_ok=True)
    global_rules = global_config / "AGENTS.md"
    global_rules_text = (
        "# Global OpenCode instructions\n"
        "The canonical project policy is loaded directly through the global "
        "opencode.json instructions setting from the integrity-checked "
        "1agent.md file. Apply those project instructions in every session "
        "and when changing models or agents. Keep the original file intact "
        "and respect provider rules and existing tool permissions.\n"
    )
    if global_rules.exists() and global_rules.read_text(encoding="utf-8") != global_rules_text:
        raise RuntimeError("Unexpected global AGENTS.md content")
    global_rules.write_text(global_rules_text, encoding="utf-8")
    policy_skill = global_config / "skills" / "1agent-policy" / "SKILL.md"
    policy_skill.parent.mkdir(parents=True, exist_ok=True)
    skill_text = (
        "---\n"
        "name: 1agent-policy\n"
        "description: Verify and apply the canonical OpenCode 1agent.md project policy across agent and model workflows.\n"
        "---\n"
        "The original 1agent.md is already loaded via global instructions. "
        "Apply it to the current engineering task, without altering the original. "
        "Verify configuration and relevant logs; do not claim model obedience "
        "without a real provider-backed test.\n"
    )
    if policy_skill.exists() and policy_skill.read_text(encoding="utf-8") != skill_text:
        raise RuntimeError("Unexpected policy SKILL.md content")
    policy_skill.write_text(skill_text, encoding="utf-8")
    target = root / "opencode.json"
    target.write_text(json.dumps(config, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
    target.chmod(0o600)
    print(f"[opencode] provider={config['provider'] and next(iter(config['provider']))} "
          f"model={config['model']} free_only={free_only}", flush=True)
    return target, config



def refresh_zen_models_if_idle(*, root: Path, ui_port: int, auth) -> None:
    """Rebuild the OpenCode model picker only when free Zen catalog IDs change."""
    cache_file = root / "cache" / "opencode" / "models.json"
    if not cache_file.is_file():
        return
    try:
        catalog = json.loads(cache_file.read_text(encoding="utf-8"))
        zen = catalog.get(ZEN_FREE_PROVIDER, {}).get("models", {})
        if not isinstance(zen, dict):
            return
        free_ids = {
            mid for mid, model in zen.items()
            if isinstance(model, dict)
            and model.get("cost", {}).get("input") == 0
            and model.get("cost", {}).get("output") == 0
            and model.get("status") != "deprecated"
        }
        if not free_ids:
            return
        base = f"http://127.0.0.1:{ui_port}"
        current = httpx.get(f"{base}/provider", auth=auth, timeout=10)
        current.raise_for_status()
        providers = current.json().get("all", [])
        existing = next((set(p.get("models", {})) for p in providers
                         if p.get("id") == ZEN_FREE_PROVIDER), None)
        if existing == free_ids:
            return
        if existing is None:
            print("[opencode] ZEN_CATALOG_SYNC=SKIPPED provider_unavailable", flush=True)
            return
        status = httpx.get(f"{base}/session/status", auth=auth, timeout=10)
        status.raise_for_status()
        if status.json():
            print("[opencode] ZEN_CATALOG_SYNC=DEFERRED active_session", flush=True)
            return
        result = httpx.post(f"{base}/instance/dispose", auth=auth, timeout=15)
        result.raise_for_status()
        verify = httpx.get(f"{base}/provider", auth=auth, timeout=15)
        verify.raise_for_status()
        updated = next((set(p.get("models", {})) for p in verify.json().get("all", [])
                        if p.get("id") == ZEN_FREE_PROVIDER), set())
        if updated == free_ids:
            print(f"[opencode] ZEN_CATALOG_SYNC=PASS old={len(existing)} new={len(updated)}", flush=True)
        else:
            print(f"[opencode] ZEN_CATALOG_SYNC=PENDING cached={len(updated)} catalog={len(free_ids)}", flush=True)
    except (OSError, ValueError, TypeError, KeyError, httpx.HTTPError) as error:
        print(f"[opencode] ZEN_CATALOG_SYNC=ERROR type={type(error).__name__}", flush=True)


def stop_process(process: subprocess.Popen) -> None:
    if process.poll() is not None:
        return
    process.terminate()
    try:
        process.wait(timeout=15)
    except subprocess.TimeoutExpired:
        process.kill()
        process.wait(timeout=5)


def run_opencode_ui(*, binary: Path, model_process: subprocess.Popen | None, root: Path,
                    expected_model: str, context: int, api_port: int, ui_port: int,
                    bridge: Path, mcp_url: str, token_url: str,
                    validate: bool = True, free_only: bool = False) -> None:
    config_path, config = prepare_config(root=root, expected_model=expected_model, context=context,
        api_port=api_port, ui_port=ui_port, bridge=bridge, mcp_url=mcp_url, token_url=token_url,
        validate=validate, free_only=free_only)
    private_mount = Path("/persistent")
    if not private_mount.is_dir():
        # Never silently create ephemeral projects that vanish at restart.
        raise RuntimeError("Private project bucket unavailable; refusing temporary workspace")
    persistence = HistoryStore(local_data=root / "data", mounted=private_mount)
    workspace = persistence.prepare()
    git_marker = workspace / ".git" / "HEAD"
    if not git_marker.is_file():
        raise RuntimeError("Persistent Git workspace missing; refusing global temporary project")
    verify = subprocess.run(["git", "-c", f"safe.directory={workspace}", "rev-parse", "--verify", "HEAD"],
                            cwd=workspace, capture_output=True, timeout=15, text=True)
    if verify.returncode != 0 or len(verify.stdout.strip()) != 40:
        print(f"[opencode] PROJECT_VCS_CHECK_FAIL rc={verify.returncode} "
              f"stdout_chars={len(verify.stdout.strip())} stderr={verify.stderr.strip()[:260]!r} "
              f"git_marker_bytes={git_marker.stat().st_size}", flush=True)
        raise RuntimeError("Persistent project Git revision invalid; refusing global fallback")
    print("[opencode] PROJECT_PERSISTENCE=PASS PRIVATE_BUCKET=ON", flush=True)
    print("[opencode] PROJECT_VCS=PASS", flush=True)
    # OPENCODE_CONFIG_CONTENT resolves {file:./...} relative to the process CWD.
    source_prompt = root / "prompts" / "1agent.md"
    target_prompt = workspace / "prompts" / "1agent.md"
    content = source_prompt.read_bytes()
    if hashlib.sha256(content).hexdigest() != "2c28b84910f9f9262460655c13347fb578d32cd2e2fdf9e65de971805de7ce65":
        raise RuntimeError("OpenCode agent prompt does not match original")
    target_prompt.parent.mkdir(parents=True, exist_ok=True)
    if target_prompt.exists() and target_prompt.read_bytes() != content:
        raise RuntimeError("Unexpected project 1agent.md content")
    if not target_prompt.exists():
        target_prompt.write_bytes(content)
    env = os.environ.copy()
    # Zen reads OPENCODE_API_KEY, accepting OPENCODE_ZEN_API_KEY as an alias.
    # The key lives only in the Space secret and the process env, never in files.
    zen_key = env.get("OPENCODE_ZEN_API_KEY") or env.get("OPENCODE_API_KEY")
    if zen_key:
        env["OPENCODE_API_KEY"] = zen_key
        env["OPENCODE_ZEN_API_KEY"] = zen_key
        print("[opencode] ZEN_KEY=PRESENT (from secret, not logged)", flush=True)
    elif free_only:
        print("[opencode] ZEN_KEY=MISSING add OPENCODE_ZEN_API_KEY as a Space secret", flush=True)
    # Enable OpenCode Basic Auth from Hugging Face Space Secrets.
    if not env.get("OPENCODE_SERVER_USERNAME") or not env.get("OPENCODE_SERVER_PASSWORD"):
        raise RuntimeError("Missing OpenCode login secrets")
    env.pop("OPENCODE_DISABLE_MODELS_FETCH", None)
    env.update({
        "OPENCODE_CONFIG": str(config_path),
        "OPENCODE_CONFIG_CONTENT": json.dumps(config),
        "OPENCODE_DISABLE_AUTOUPDATE": "1",
        "OPENCODE_DISABLE_PROJECT_CONFIG": "1",
        "OPENCODE_ENABLE_EXA": "1",
        "XDG_CONFIG_HOME": str(root / "config"),
        "XDG_DATA_HOME": str(root / "data"),
        "XDG_CACHE_HOME": str(root / "cache"),
        # Protected, narrow Git trust: only the user's private mounted workspace.
        "GIT_CONFIG_COUNT": "2",
        "GIT_CONFIG_KEY_0": "safe.directory",
        "GIT_CONFIG_VALUE_0": str(workspace),
        "GIT_CONFIG_KEY_1": "safe.directory",
        "GIT_CONFIG_VALUE_1": str(workspace) + "/*",
        "PYTHONIOENCODING": "utf-8",
    })
    import socket
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as probe:
        try:
            probe.bind(("127.0.0.1", ui_port))
        except OSError as error:
            raise RuntimeError(f"OpenCode port {ui_port} not available: {type(error).__name__} {error.errno}") from error
    print(f"[opencode] PORT_BIND_PROBE=PASS {ui_port}", flush=True)
    log_path = root / "opencode-serve.log"
    log_handle = log_path.open("ab", buffering=0)
    log_handle.write(f"\n=== boot {time.time()} free_only={free_only} ===\n".encode())
    ui = subprocess.Popen([str(binary), "--print-logs", "--log-level", "INFO",
                           "web", "--hostname", "127.0.0.1", "--port", str(ui_port)],
                          cwd=workspace, env=env, stdout=log_handle, stderr=subprocess.STDOUT)
    print(f"[opencode] LOG={log_path}", flush=True)
    deadline = time.monotonic() + 120
    ready = False
    last_snapshot = time.monotonic()
    last_catalog_sync = time.monotonic() - 120
    try:
        while True:
            if model_process is not None and model_process.poll() is not None:
                raise RuntimeError(f"llama-server exited: {model_process.returncode}")
            if ui.poll() is not None:
                raise RuntimeError(f"OpenCode exited: {ui.returncode}")
            if not ready:
                try:
                    password = env.get("OPENCODE_SERVER_PASSWORD")
                    auth = (env.get("OPENCODE_SERVER_USERNAME", "opencode"), password) if password else None
                    response = httpx.get(f"http://127.0.0.1:{ui_port}/global/health", timeout=2, auth=auth)
                    ready = response.status_code == 200 and response.json().get("healthy") is True
                except (httpx.HTTPError, ValueError):
                    pass
                if ready:
                    try:
                        mcp_ready = ensure_pc_mcp_auth(
                            base_url=f"http://127.0.0.1:{ui_port}",
                            data_home=root / "data", env=env)
                        print(f"[opencode] MCP_AUTH={'CONNECTED' if mcp_ready else 'NEEDS_AUTH'} "
                              "source=SpaceSecrets", flush=True)
                    except (httpx.HTTPError, OSError, ValueError, RuntimeError) as error:
                        print(f"[opencode] MCP_AUTH=ERROR type={type(error).__name__}", flush=True)
                    print(f"[opencode] official Web UI ready on 0.0.0.0:{ui_port}; MCP=naldo_pc "
                          "websearch=enabled webfetch=enabled", flush=True)
                elif time.monotonic() >= deadline:
                    raise TimeoutError("OpenCode Web did not become healthy within 120 seconds")
            if ready and time.monotonic() - last_catalog_sync >= 120:
                password = env.get("OPENCODE_SERVER_PASSWORD")
                auth = (env.get("OPENCODE_SERVER_USERNAME", "opencode"), password) if password else None
                refresh_zen_models_if_idle(root=root, ui_port=ui_port, auth=auth)
                last_catalog_sync = time.monotonic()
            if ready and persistence and time.monotonic() - last_snapshot >= 90:
                try:
                    persistence.snapshot()
                except (OSError, RuntimeError, ValueError) as error:
                    print(f"[opencode] SESSION_SNAPSHOT=ERROR type={type(error).__name__}", flush=True)
                last_snapshot = time.monotonic()
            time.sleep(1)
    finally:
        stop_process(ui)
        try:
            log_handle.close()
        except OSError:
            pass
        if persistence:
            try:
                persistence.snapshot()
            except (OSError, RuntimeError, ValueError) as error:
                print(f"[opencode] FINAL_SESSION_SNAPSHOT=ERROR type={type(error).__name__}", flush=True)