local-coding-agent 1.1.0__py3-none-any.whl

local_coding_agent/desktop/server/_models.py

@@ -0,0 +1,204 @@
+"""Model discovery, profile resolution and availability checks for the Desktop Harness."""
+
+from __future__ import annotations
+
+import json
+import urllib.request
+from pathlib import Path
+from typing import Any
+
+from ...model_scanner import get_model_registry
+from ...ollama_adapter import OllamaError, OpenAICompatibleClient, classify_backend_error as _classify_backend_error
+from ...profiles import ModelProfile, get_profile
+
+# NOTE: `discover_local_ollama_models` and `profile_model_is_available` are
+# imported at call time from the `server` package (re-exports) so that tests
+# that patch `local_coding_agent.desktop.server.<name>` take effect.
+
+
+def discover_local_ollama_models() -> list[str]:
+    """Query live Ollama API and scan local disk manifests for installed models."""
+    models: list[str] = []
+    # 1. Probe live endpoint
+    try:
+        req = urllib.request.Request("http://127.0.0.1:11434/api/tags")
+        with urllib.request.urlopen(req, timeout=0.3) as resp:
+            if resp.status == 200:
+                tags_data = json.loads(resp.read().decode("utf-8"))
+                for m in tags_data.get("models", []):
+                    if isinstance(m, dict) and "name" in m:
+                        models.append(m["name"])
+                if models:
+                    return sorted(list(set(models)))
+    except Exception:
+        pass
+
+    # 2. Disk manifests inspection in ~/.ollama/models/manifests
+    manifest_root = Path.home() / ".ollama" / "models" / "manifests"
+    if manifest_root.exists():
+        try:
+            for reg in manifest_root.iterdir():
+                if reg.is_dir():
+                    for user_or_lib in reg.iterdir():
+                        if user_or_lib.is_dir():
+                            for model_dir in user_or_lib.iterdir():
+                                if model_dir.is_dir():
+                                    for tag_file in model_dir.iterdir():
+                                        if tag_file.is_file():
+                                            prefix = "" if user_or_lib.name == "library" else f"{user_or_lib.name}/"
+                                            models.append(f"{prefix}{model_dir.name}:{tag_file.name}")
+        except Exception:
+            pass
+
+    return sorted(list(set(models)))
+
+
+def resolve_model_profile(name: str, registry: Any = None) -> ModelProfile:
+    """Resolve a profile by known profile name, installed Ollama tag, or discovered GGUF model."""
+    if registry is None:
+        registry = get_model_registry()
+    clean_name = name.strip()
+
+    # 1. Exact known profile (carries correct provider/endpoint)
+    try:
+        return get_profile(clean_name)
+    except ValueError:
+        pass
+
+    # 2. Installed Ollama tag
+    from ..server import discover_local_ollama_models
+    ollama_models = discover_local_ollama_models()
+    if clean_name in ollama_models:
+        matched = clean_name
+        return ModelProfile(
+            name=clean_name,
+            model=matched,
+            provider="ollama",
+            endpoint="http://127.0.0.1:11434",
+            num_ctx=8192,
+        )
+    # An untagged local name is an alias only when exactly one served tag has
+    # that basename. Never select a similarly named namespace/tag implicitly.
+    if ":" not in clean_name and "/" not in clean_name:
+        aliases = [model for model in ollama_models if model.split(":", 1)[0] == clean_name]
+        if len(aliases) == 1:
+            matched = aliases[0]
+        else:
+            matched = None
+    else:
+        matched = None
+    if matched is not None:
+        return ModelProfile(
+            name=clean_name,
+            model=matched,
+            provider="ollama",
+            endpoint="http://127.0.0.1:11434",
+            num_ctx=8192,
+        )
+
+    # 3. Discovered GGUF model — exact stable path-id wins over ambiguous basename
+    for discovered in registry.get_models(auto_scan=True):
+        if clean_name == discovered.to_dict().get("id"):
+            return ModelProfile(
+                name=clean_name,
+                model=discovered.display_name,
+                provider="openai",
+                endpoint="http://127.0.0.1:8080",
+                num_ctx=8192,
+            )
+    for discovered in registry.get_models(auto_scan=True):
+        if clean_name.lower() in (discovered.name.lower(), discovered.display_name.lower()):
+            return ModelProfile(
+                name=clean_name,
+                model=discovered.display_name,
+                provider="openai",
+                endpoint="http://127.0.0.1:8080",
+                num_ctx=8192,
+            )
+
+    # 4. Fallback to Ollama profile using name as model
+    return ModelProfile(
+        name=clean_name,
+        model=clean_name,
+        provider="ollama",
+        endpoint="http://127.0.0.1:11434",
+        num_ctx=8192,
+    )
+
+
+def profile_model_is_available(profile: ModelProfile) -> bool:
+    """Return True if the profile's model is actually installed/available on a live backend."""
+    from ..server import discover_local_ollama_models
+    try:
+        if profile.provider == "ollama":
+            ollama_models = discover_local_ollama_models()
+            target = profile.model
+            if target in ollama_models:
+                return True
+            if ":" in target or "/" in target:
+                return False
+            return sum(model.split(":", 1)[0] == target for model in ollama_models) == 1
+        if profile.provider == "openai":
+            try:
+                avail = OpenAICompatibleClient(profile).available_models()
+                live_names = {m["name"] for m in avail.get("models", []) if isinstance(m, dict) and "name" in m}
+                if profile.model in live_names:
+                    return True
+            except Exception:
+                pass
+            gguf_names = {m.display_name for m in get_model_registry().get_models(auto_scan=True)}
+            gguf_names.update(m.name for m in get_model_registry().get_models(auto_scan=True))
+            return profile.model in gguf_names
+        return False
+    except Exception:
+        return False
+
+
+def select_available_profile(preferred: str) -> str:
+    """Return a profile name whose model is actually installed, falling back to discovered models."""
+    from ..server import discover_local_ollama_models, profile_model_is_available
+    try:
+        if _is_known_profile(preferred) and profile_model_is_available(resolve_model_profile(preferred)):
+            return preferred
+    except Exception:
+        pass
+    try:
+        ollama_models = discover_local_ollama_models()
+        if ollama_models:
+            return ollama_models[0]
+    except Exception:
+        pass
+    try:
+        discovered = get_model_registry().get_models(auto_scan=True)
+        if discovered:
+            return discovered[0].display_name
+    except Exception:
+        pass
+    return preferred
+
+
+def _is_known_profile(name: str) -> bool:
+    try:
+        get_profile(name)
+        return True
+    except ValueError:
+        return False
+
+
+def find_discovered_gguf(name: str, registry: Any = None) -> dict[str, Any] | None:
+    """Return the registry entry (incl. on-disk path) for a discovered GGUF model.
+
+    Resolution order: exact stable path-id first (two models may share a
+    basename), then legacy case-insensitive basename/display-name first-match.
+    """
+    if registry is None:
+        registry = get_model_registry()
+    clean = name.strip()
+    discovered_list = registry.get_models(auto_scan=True)
+    for discovered in discovered_list:
+        if clean == discovered.to_dict().get("id"):
+            return discovered.to_dict()
+    for discovered in discovered_list:
+        if clean.lower() in (discovered.name.lower(), discovered.display_name.lower()):
+            return discovered.to_dict()
+    return None

local_coding_agent/desktop/server/_server.py

@@ -0,0 +1,347 @@
+"""Desktop Harness embedded HTTP server with persistent storage and process orchestration."""
+
+from __future__ import annotations
+
+import ipaddress
+import json
+import os
+import secrets
+import subprocess
+import threading
+import time
+from http.server import ThreadingHTTPServer
+from pathlib import Path
+from typing import Any
+
+from ...stats import DelegationStats
+from ...task import TaskEnvelope
+from ._handlers import (
+    DesktopRequestHandler,
+    build_queue_controller,
+    detect_relevant_files,
+    detect_test_checks,
+)
+
+# How often the background task worker polls the store for queued records.
+_TASK_POLL_INTERVAL = 0.3
+
+
+class PersistenceError(RuntimeError):
+    """A desktop state file could not be read or durably replaced."""
+
+
+class DesktopServer:
+    """Desktop Harness embedded HTTP server with persistent storage and process orchestration."""
+
+    def __init__(
+        self,
+        host: str = "127.0.0.1",
+        port: int = 0,
+        workspace: str | Path = ".",
+        default_profile: str = "qwen2.5-coder",
+        stats: DelegationStats | None = None,
+    ) -> None:
+        self.host = host
+        self.port = port
+        # Hard security boundary: the mutation token is injected into the served
+        # HTML, so a non-loopback bind would hand it to every LAN peer.
+        self._require_loopback(host)
+        self.workspace = str(Path(workspace).resolve())
+        self.default_profile = default_profile
+        self.mutation_token = secrets.token_urlsafe(32)
+        self.stats = stats or DelegationStats()
+        self.started_at = time.monotonic()
+        self.spawned_processes: dict[str, subprocess.Popen[Any]] = {}
+        # ponytail: single-slot "last apply" tracking — a second apply overwrites
+        # the first, so rollback undoes only the most recent apply, not a full
+        # undo stack.
+        self.last_applied_files: list[str] = []
+        self.last_applied_patch: str = ""
+        self.apply_lock = threading.Lock()
+        # ponytail: monotonically-increasing counter drives the hybrid classifier's
+        # periodic re-evaluation cadence (classify_mode counter % n_every == 0).
+        self.hybrid_counter = 0
+        # Context window used when spawning llama-server (-c). Overridable per
+        # chat/model-load request; the running server must be relaunched to
+        # apply a change, so remember what is currently loaded.
+        self.llama_num_ctx = 8192
+        self.llama_gguf_path: str | None = None
+        self.llama_gguf_label: str | None = None
+        # Read back from llama-server /props after launch: what the server
+        # actually serves may be clamped to the model's native context length.
+        self.llama_effective_ctx: int | None = None
+        self.sessions_file = Path(self.workspace) / ".local_agent_sessions.json"
+        self.sessions_lock = threading.Lock()
+        # Background task queue (R23): persisted proposal-only delegation jobs.
+        self.tasks_file = Path(self.workspace) / ".local_agent_tasks.json"
+        self.task_queue_lock = threading.Lock()
+        self._task_events: dict[str, threading.Event] = {}
+        self._task_stop = threading.Event()
+        self._task_thread: threading.Thread | None = None
+        # Test seam: when set, the worker builds its controller through
+        # controller_factory(profile, workspace, cancel_event=...) -> object
+        # with .run(task). When None it mirrors /api/delegate's construction.
+        self.controller_factory: Any = None
+        self._recover_interrupted_tasks()
+        self._httpd = ThreadingHTTPServer((host, port), DesktopRequestHandler)
+        self._httpd.desktop_server = self  # type: ignore[attr-defined]
+        self._thread: threading.Thread | None = None
+
+    @staticmethod
+    def _require_loopback(host: str) -> None:
+        candidate = "127.0.0.1" if host == "localhost" else host
+        try:
+            addr = ipaddress.ip_address(candidate)
+        except ValueError as error:
+            raise ValueError(f"Desktop server host must be a loopback address, got {host!r}") from error
+        if not addr.is_loopback:
+            raise ValueError(
+                f"Desktop server refuses non-loopback bind ({host}); the UI page embeds "
+                "the mutation token and must stay local-only"
+            )
+
+    @property
+    def actual_port(self) -> int:
+        return self._httpd.server_address[1]
+
+    @property
+    def url(self) -> str:
+        return f"http://{self.host}:{self.actual_port}"
+
+    def load_sessions(self) -> list[dict[str, Any]]:
+        with self.sessions_lock:
+            return self._load_sessions_unlocked()
+
+    def _load_sessions_unlocked(self) -> list[dict[str, Any]]:
+        if not self.sessions_file.exists():
+            return []
+        try:
+            data = json.loads(self.sessions_file.read_text(encoding="utf-8-sig"))
+        except (OSError, UnicodeError, json.JSONDecodeError) as error:
+            raise PersistenceError(f"Cannot read session history without data loss: {error}") from error
+        if not isinstance(data, list) or not all(isinstance(item, dict) for item in data):
+            raise PersistenceError("Session history must be a JSON array of objects")
+        return data
+
+    def save_session(self, session: dict[str, Any]) -> None:
+        with self.sessions_lock:
+            sessions = self._load_sessions_unlocked()
+            sessions = [s for s in sessions if s.get("id") != session.get("id")]
+            sessions.insert(0, session)
+            self._atomic_write_json(self.sessions_file, sessions[:50])
+
+    @staticmethod
+    def _atomic_write_json(path: Path, value: Any) -> None:
+        temporary = path.with_name(f".{path.name}.{os.getpid()}.tmp")
+        try:
+            temporary.write_text(json.dumps(value, indent=2, ensure_ascii=False), encoding="utf-8")
+            temporary.replace(path)
+        except Exception as error:
+            try:
+                temporary.unlink()
+            except OSError:
+                pass
+            raise PersistenceError(f"Cannot atomically write {path.name}: {error}") from error
+
+    # ---- Background task queue store (newest first, capped at 100) ----
+
+    def load_tasks(self) -> list[dict[str, Any]]:
+        if self.tasks_file.exists():
+            try:
+                data = json.loads(self.tasks_file.read_text(encoding="utf-8"))
+                if isinstance(data, list):
+                    return data
+            except Exception:
+                pass
+        return []
+
+    def _write_tasks(self, tasks: list[dict[str, Any]]) -> None:
+        try:
+            self.tasks_file.write_text(json.dumps(tasks[:100], indent=2, ensure_ascii=False), encoding="utf-8")
+        except Exception:
+            pass
+
+    def save_task(self, task: dict[str, Any]) -> None:
+        tasks = [t for t in self.load_tasks() if t.get("id") != task.get("id")]
+        tasks.insert(0, task)
+        self._write_tasks(tasks)
+
+    def get_task(self, task_id: str) -> dict[str, Any] | None:
+        return next((t for t in self.load_tasks() if t.get("id") == task_id), None)
+
+    def update_task(self, task_id: str, **fields: Any) -> dict[str, Any] | None:
+        """Patch a stored record; callers hold ``task_queue_lock``."""
+        tasks = self.load_tasks()
+        updated: dict[str, Any] | None = None
+        for index, record in enumerate(tasks):
+            if record.get("id") == task_id:
+                record.update(fields)
+                tasks[index] = record
+                updated = record
+                break
+        if updated is not None:
+            self._write_tasks(tasks)
+        return updated
+
+    def _recover_interrupted_tasks(self) -> None:
+        """Fail records left 'running' by a previous process.
+
+        Queued tasks stay queued and are picked up on start() (persistence
+        gives this for free); a running Controller cannot survive its process,
+        so its record fails honestly instead of hanging forever.
+        """
+        tasks = self.load_tasks()
+        stuck = [t for t in tasks if t.get("status") == "running"]
+        if not stuck:
+            return
+        for record in stuck:
+            record["status"] = "failed"
+            record["finished_at"] = time.time()
+            record["error"] = "server restarted while the task was running"
+        self._write_tasks(tasks)
+
+    # ---- Background task worker ----
+
+    def _task_worker_loop(self) -> None:
+        """Sequential background executor: one queued task at a time.
+
+        # ponytail: sequential queue — concurrent pool only when batch
+        throughput measurably matters. Survives any exception by failing the
+        record and continuing. Polls every 0.3s; queued tasks persist across
+        restarts, so anything left queued is simply picked up next start().
+        """
+        while not self._task_stop.wait(_TASK_POLL_INTERVAL):
+            with self.task_queue_lock:
+                queued = [t for t in self.load_tasks() if t.get("status") == "queued"]
+                record = dict(queued[-1]) if queued else None  # newest-first -> last is oldest
+            if record is None:
+                continue
+            try:
+                self._execute_task(record)
+            except Exception as error:  # never let the worker thread die
+                with self.task_queue_lock:
+                    self.update_task(record["id"], status="failed", finished_at=time.time(), error=str(error))
+
+    def _execute_task(self, record: dict[str, Any]) -> None:
+        """Run one delegated task proposal-only and store the outcome."""
+        task_id = record["id"]
+        cancel_event = threading.Event()
+        with self.task_queue_lock:
+            current = self.get_task(task_id)
+            if current is None or current.get("status") != "queued":
+                return  # cancelled between pick-up and execution
+            self._task_events[task_id] = cancel_event
+            self.update_task(task_id, status="running", started_at=time.time())
+        try:
+            files = [str(f) for f in (record.get("files") or [])]
+            if not files:
+                files = detect_relevant_files(self.workspace, record["goal"])
+            checks = [str(c) for c in (record.get("checks") or [])]
+            if not checks:
+                checks = detect_test_checks(self.workspace)
+            if not files:
+                with self.task_queue_lock:
+                    self.update_task(
+                        task_id,
+                        status="failed",
+                        finished_at=time.time(),
+                        error={
+                            "kind": "needs_context",
+                            "message": "No unambiguous existing file scope was provided for this build task.",
+                        },
+                    )
+                return
+            envelope = TaskEnvelope(
+                id=task_id,
+                goal=record["goal"],
+                files=tuple(files),
+                checks=tuple(checks),
+            )
+            factory = self.controller_factory or build_queue_controller
+            controller = factory(
+                record.get("profile") or self.default_profile,
+                self.workspace,
+                cancel_event=cancel_event,
+            )
+            result = controller.run(envelope) or {}
+            if cancel_event.is_set():
+                final_status = "cancelled"
+            elif result.get("status") == "accepted":
+                final_status = "accepted"
+            else:
+                final_status = "failed"
+            error = result.get("error") or ""
+            if final_status == "failed" and not error:
+                error = str(result.get("summary") or f"task ended with status {result.get('status')}")
+            with self.task_queue_lock:
+                self.update_task(
+                    task_id,
+                    status=final_status,
+                    finished_at=time.time(),
+                    files=files,
+                    summary=str(result.get("summary") or ""),
+                    patch=str(result.get("patch") or ""),
+                    checks_results=result.get("checks") if isinstance(result.get("checks"), list) else [],
+                    error=error,
+                )
+        except Exception as error:
+            status = "cancelled" if cancel_event.is_set() else "failed"
+            with self.task_queue_lock:
+                self.update_task(task_id, status=status, finished_at=time.time(), error=str(error))
+        finally:
+            with self.task_queue_lock:
+                self._task_events.pop(task_id, None)
+
+    def start(self) -> None:
+        if self._thread is not None:
+            return
+        self._thread = threading.Thread(
+            target=self._httpd.serve_forever,
+            name="local-agent-desktop-http",
+            daemon=True,
+        )
+        self._thread.start()
+        self._task_stop.clear()
+        self._task_thread = threading.Thread(
+            target=self._task_worker_loop,
+            name="local-agent-desktop-tasks",
+            daemon=True,
+        )
+        self._task_thread.start()
+
+    def stop(self) -> None:
+        # Wake/join the task worker briefly: a running Controller finishes in
+        # its daemon thread (never killed mid-write); queued tasks remain
+        # queued on restart via the persisted store.
+        self._task_stop.set()
+        if self._task_thread is not None:
+            self._task_thread.join(timeout=2.0)
+            self._task_thread = None
+
+        for name, proc in list(self.spawned_processes.items()):
+            try:
+                if os.name == "nt":
+                    subprocess.run(["taskkill", "/F", "/T", "/PID", str(proc.pid)], capture_output=True, check=False)
+                else:
+                    proc.terminate()
+                    proc.wait(timeout=2.0)
+            except Exception:
+                try:
+                    proc.kill()
+                except Exception:
+                    pass
+        self.spawned_processes.clear()
+
+        if self._thread is None:
+            return
+        self._httpd.shutdown()
+        self._httpd.server_close()
+        self._thread.join(timeout=3.0)
+        self._thread = None
+
+    def __enter__(self) -> DesktopServer:
+        self.start()
+        return self
+
+    def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+        self.stop()

local_coding_agent/desktop/server/_telemetry.py

@@ -0,0 +1,87 @@
+"""Real hardware GPU telemetry for the Desktop Harness (from nvidia-smi)."""
+
+from __future__ import annotations
+
+import subprocess
+import math
+from typing import Any
+
+
+def get_nvidia_gpu_telemetry() -> dict[str, Any] | None:
+    """Query live single-device GPU metrics directly from ``nvidia-smi``.
+
+    The VRAM fitter is intentionally single-device.  A multi-GPU response is
+    therefore reported as unsupported instead of silently selecting the first
+    row and applying that device's capacity to an unspecified backend.
+    """
+    try:
+        res = subprocess.run(
+            [
+                "nvidia-smi",
+                "--query-gpu=index,uuid,memory.used,memory.total,utilization.gpu,name,temperature.gpu",
+                "--format=csv,noheader,nounits",
+            ],
+            capture_output=True,
+            text=True,
+            check=False,
+            timeout=1.5,
+        )
+        if res.returncode != 0 or not res.stdout.strip():
+            detail = (res.stderr or "nvidia-smi returned no telemetry").strip()
+            return _unavailable(detail)
+        lines = [line for line in res.stdout.splitlines() if line.strip()]
+        if len(lines) != 1:
+            return _unavailable(
+                f"nvidia-smi reported {len(lines)} GPUs; single-device VRAM attribution is unsupported",
+                status="unsupported",
+            )
+        parts = [p.strip() for p in lines[0].split(",")]
+        if len(parts) < 7:
+            return _unavailable("nvidia-smi returned an incomplete telemetry row")
+        index, uuid, used_raw, total_raw, util_raw, name, temp_raw = parts[:7]
+        used_mb = float(used_raw)
+        total_mb = float(total_raw)
+        util_gpu = float(util_raw)
+        temp_c = float(temp_raw)
+        if not all(math.isfinite(value) for value in (used_mb, total_mb, util_gpu, temp_c)):
+            return _unavailable("nvidia-smi returned non-finite telemetry")
+        if total_mb <= 0 or used_mb < 0 or used_mb > total_mb:
+            return _unavailable("nvidia-smi returned invalid VRAM totals")
+        return {
+            "status": "ok",
+            "gpu_index": index,
+            "gpu_uuid": uuid,
+            "gpu_name": name,
+            "used_mb": round(used_mb, 1),
+            "total_mb": round(total_mb, 1),
+            "used_gb": round(used_mb / 1024, 1),
+            "total_gb": round(total_mb / 1024, 1),
+            "percent": round((used_mb / total_mb) * 100, 1),
+            "utilization_pct": round(util_gpu, 1),
+            "temp_c": round(temp_c, 1),
+            "source": "nvidia-smi",
+        }
+    except subprocess.TimeoutExpired:
+        return _unavailable("nvidia-smi telemetry timed out")
+    except FileNotFoundError:
+        return _unavailable("nvidia-smi executable is unavailable")
+    except (OSError, ValueError) as error:
+        return _unavailable(f"nvidia-smi telemetry is invalid: {error}")
+
+
+def _unavailable(error: str, *, status: str = "unavailable") -> dict[str, Any]:
+    return {
+        "status": status,
+        "source": "nvidia-smi",
+        "error": error,
+        "gpu_index": None,
+        "gpu_uuid": None,
+        "gpu_name": None,
+        "used_mb": None,
+        "total_mb": None,
+        "used_gb": None,
+        "total_gb": None,
+        "percent": None,
+        "utilization_pct": None,
+        "temp_c": None,
+    }