localcode 0.5.10__tar.gz → 0.5.11__tar.gz

{localcode-0.5.10/src/localcode.egg-info → localcode-0.5.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localcode
-Version: 0.5.10
+Version: 0.5.11
 Summary: High-performance AI coding on consumer hardware.
 Author: LocalCode contributors
 License-Expression: Apache-2.0

{localcode-0.5.10 → localcode-0.5.11}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "localcode"
-version = "0.5.10"
+version = "0.5.11"
 description = "High-performance AI coding on consumer hardware."
 readme = "README.md"
 requires-python = ">=3.10"

{localcode-0.5.10 → localcode-0.5.11}/src/localcode/__init__.py

@@ -8,4 +8,4 @@ from importlib.metadata import PackageNotFoundError, version as _pkg_version
 try:
     __version__ = _pkg_version("localcode")
 except PackageNotFoundError:  # not installed (e.g. raw source checkout)
-    __version__ = "0.5.10"
+    __version__ = "0.5.11"

{localcode-0.5.10 → localcode-0.5.11}/src/localcode/bin/localcode-ui

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
-name: localcode-0.5.10/src/localcode/bin/localcode-ui
+name: localcode-0.5.11/src/localcode/bin/localcode-ui
 size: 102460976 bytes
 sha256: 44c99212032f56e6453045fef245cbf6eeead1ac5b122fb983727d3980ab3e06

{localcode-0.5.10 → localcode-0.5.11}/src/localcode/ui/plugin/modes.ts

@@ -169,26 +169,46 @@ async function tui(api: TuiPluginApi) {
     api.ui.dialog.clear();
   } }));
   let changingPort = false;
+  let changingServer = false;
   async function server() {
     if (!control) return error("Start LocalCode to manage its model server");
     try {
       const response = await fetch(control + "/server", { headers, signal: AbortSignal.timeout(3000) });
       if (!response.ok) throw new Error(`Server status: HTTP ${response.status}`);
-      const info = await response.json() as { state: string; base_url: string; model?: string; port: number; preferred_port: number | string | null; server_ready: boolean };
+      const info = await response.json() as { state: string; base_url: string; model?: string; port: number; preferred_port: number | string | null; server_ready: boolean; server_running?: boolean; detail?: string };
       const copy = async (value: string, secret = false) => {
         const proc = Bun.spawn(["pbcopy"], { stdin: new Blob([value]), stdout: "ignore", stderr: "ignore" });
         if (await proc.exited !== 0) throw new Error("Could not copy to clipboard");
         api.ui.toast({ variant: "info", message: secret ? "Copied with API key. Keep the clipboard contents private." : "Copied to clipboard" });
       };
       api.ui.dialog.replace(() => api.ui.DialogSelect({ title: "Model server · " + info.state, options: [
+        { title: "Status", value: "status", description: info.detail || info.state },
         { title: "Base URL", value: "url", description: info.base_url },
         { title: "Model", value: "model", description: info.model ?? "No model loaded" },
         { title: "Copy API key", value: "key", description: "Private · only for clients you trust" },
         { title: "Copy curl example", value: "curl", description: "Includes your API key; lists available models" },
         { title: "Change API port now", value: "port", description: `Current: ${info.port} · saved: ${info.preferred_port ?? "automatic"}` },
+        ...(!["loading", "downloading", "stopping"].includes(info.state) ? [{
+          title: info.server_running ? "Stop model server" : "Start model server",
+          value: info.server_running ? "stop" : "start",
+          description: info.server_running ? "Frees model memory · affects all windows and API clients · chat stays open" : "Reloads the previous model · loading and context processing take time",
+        }] : []),
         { title: "Refresh", value: "refresh", description: "Loopback only · available to tools on this Mac" },
       ], onSelect(item) {
-        if (item.value === "refresh") return void server();
+        if (item.value === "refresh" || item.value === "status") return void server();
+        if (item.value === "start" || item.value === "stop") {
+          if (changingServer) return;
+          changingServer = true;
+          void fetch(control + "/server/" + item.value, { method: "POST", headers, body: "{}", signal: AbortSignal.timeout(5000) })
+            .then(async (r) => {
+              const result = await r.json() as { error?: string; state?: string };
+              if (!r.ok) throw new Error(result.error || `HTTP ${r.status}`);
+              api.ui.toast({ variant: "info", message: item.value === "stop" ? "Stopping shared model server. Chat history stays available." : "Loading model. Refresh /server to check progress.", duration: 8000 });
+              await server();
+            }).catch((e) => error(`Could not confirm server operation: ${String(e)}. Refresh /server before retrying.`))
+            .finally(() => { changingServer = false; });
+          return;
+        }
         if (item.value === "port") return api.ui.dialog.replace(() => api.ui.DialogPrompt({
           title: "New API port (1024–65535 or auto)", value: String(info.preferred_port ?? "auto"),
           onConfirm(value) {

{localcode-0.5.10 → localcode-0.5.11}/src/localcode/ui/supervisor.py

@@ -331,6 +331,7 @@ class Supervisor:
                 self.proc.wait(timeout=15)
             except subprocess.TimeoutExpired:
                 self.proc.kill()
+                self.proc.wait(timeout=5)
         self.proc = None
 
     def _probe_props(self) -> None:
@@ -406,6 +407,70 @@ class Supervisor:
             state.update(state="error", detail="Model server is unavailable")
         return dict(state, server_running=running, server_ready=ready)
 
+    def server_action(self, action: str) -> dict:
+        """Queue an explicit lifecycle action; retain session and selected model."""
+        if action not in ("start", "stop"):
+            return {"error": "Unknown server action"}
+        if not self.lock.acquire(blocking=False):
+            return {"error": "A model operation is in progress; wait and refresh /server"}
+        queued = False
+        previous = dict(self.state)
+        try:
+            if self.state["state"] in ("loading", "downloading", "stopping"):
+                return {"error": "A model operation is in progress; wait and refresh /server"}
+            running = self.proc is not None and self.proc.poll() is None
+            if action == "stop":
+                if running:
+                    phase = self.progress().get("phase")
+                    if phase != "idle":
+                        return {"error": "A request is active or server activity cannot be verified. Cancel requests in all clients, then retry."}
+                else:
+                    self.state = {"state": "stopped", "model": self.current, "detail": "Model server stopped. Use /server to start it.", "pct": None}
+                    return {"ok": True, "state": "stopped"}
+                self.state = {"state": "stopping", "model": self.current, "detail": "Stopping model server…", "pct": None}
+            else:
+                if running:
+                    return {"error": "Model server is already running. Stop it first to restart."}
+                if not self.current:
+                    return {"error": "No previous model. Select a model using /model first."}
+                if not _safe_filename(self.current + ".gguf") or not (self.models_dir / (self.current + ".gguf")).is_file():
+                    return {"error": "The previous model file is missing. Select an installed model using /model."}
+                self.state = {"state": "loading", "model": self.current, "detail": "Reloading model…", "pct": None}
+            threading.Thread(target=self._server_action_worker, args=(action,), daemon=True).start()
+            queued = True
+            return {"ok": True, "state": self.state["state"]}
+        except Exception:
+            self.state = previous
+            log("Could not start server lifecycle worker")
+            return {"error": "Could not begin the operation. Refresh /server and retry."}
+        finally:
+            if not queued:
+                self.lock.release()
+
+    def _server_action_worker(self, action: str) -> None:
+        try:
+            if action == "stop":
+                # Recheck immediately before stopping, including other API clients.
+                if self.proc is not None and self.proc.poll() is None and self.progress().get("phase") != "idle":
+                    self.state = {"state": "ready", "model": self.current, "detail": "Stop cancelled: a request started. Cancel it and retry.", "pct": None}
+                    return
+                self.stop()
+                self.state = {"state": "stopped", "model": self.current, "detail": "Model server stopped. Use /server to start it.", "pct": None}
+            elif self.start(self.current):
+                self.state = {"state": "ready", "model": self.current, "detail": "", "pct": None}
+            else:
+                self.stop()
+                self.state = {"state": "error", "model": self.current, "detail": "Model failed to load. Retry Start or select another model with /model.", "pct": None}
+        except Exception as exc:
+            log(f"Server {action} failed: {exc}")
+            try:
+                self.stop()
+            except Exception:
+                log("Could not clean up model process after lifecycle failure")
+            self.state = {"state": "error", "model": self.current, "detail": "Model operation failed. Refresh /server and retry; see supervisor.log.", "pct": None}
+        finally:
+            self.lock.release()
+
     # ---- catalog ------------------------------------------------------------
     def _rec_repo(self) -> str | None:
         try:
@@ -895,6 +960,11 @@ def make_handler(sup: Supervisor):
                 body = json.loads(self.rfile.read(n) or b"{}")
             except json.JSONDecodeError:
                 return self._json({"error": "bad json"}, 400)
+            if u.path in ("/server/start", "/server/stop"):
+                if not isinstance(body, dict):
+                    return self._json({"error": "Expected a JSON object"}, 400)
+                res = sup.server_action(u.path.rsplit("/", 1)[1])
+                return self._json(res, 409 if "error" in res else 200)
             if u.path == "/server/port":
                 from localcode.ui.gateway import PortChangeError
                 if not isinstance(body, dict) or "port" not in body:

{localcode-0.5.10 → localcode-0.5.11/src/localcode.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localcode
-Version: 0.5.10
+Version: 0.5.11
 Summary: High-performance AI coding on consumer hardware.
 Author: LocalCode contributors
 License-Expression: Apache-2.0

{localcode-0.5.10 → localcode-0.5.11}/src/localcode.egg-info/SOURCES.txt

@@ -1248,4 +1248,5 @@ tests/test_ui_context_budget.py
 tests/test_ui_gateway_live.py
 tests/test_ui_launch.py
 tests/test_ui_server.py
+tests/test_ui_server_lifecycle.py
 tests/test_ui_warmup.py

localcode-0.5.11/tests/test_ui_server_lifecycle.py

@@ -0,0 +1,129 @@
+"""Explicit model lifecycle: busy guards, failure recovery and HTTP authorization."""
+import threading
+from types import SimpleNamespace
+
+import pytest
+
+from localcode.ui.supervisor import Supervisor
+
+
+@pytest.fixture
+def sup(tmp_path):
+    s = Supervisor.__new__(Supervisor)
+    s.lock = threading.Lock()
+    s.current = 'test-model'
+    s.models_dir = tmp_path
+    (tmp_path / 'test-model.gguf').touch()
+    s.state = {'state': 'ready', 'model': s.current}
+    s.proc = SimpleNamespace(poll=lambda: None)
+    s.progress = lambda: {'phase': 'idle'}
+    s.healthy = lambda: True
+    def stop():
+        s.proc = None
+    def start(alias):
+        assert alias == 'test-model'
+        s.proc = SimpleNamespace(poll=lambda: None)
+        return True
+    s.stop = stop
+    s.start = start
+    return s
+
+
+def done(s):
+    assert s.lock.acquire(timeout=3), 'lifecycle worker did not release lock'
+    s.lock.release()
+
+
+def test_stop_start_preserves_selected_model_and_reports_liveness(sup):
+    assert sup.server_action('stop')['ok']
+    done(sup)
+    assert sup.current == 'test-model'
+    assert sup.server_status()['state'] == 'stopped'
+    assert not sup.server_status()['server_ready']
+    assert sup.server_action('stop')['state'] == 'stopped'  # idempotent
+    assert sup.server_action('start')['ok']
+    done(sup)
+    assert sup.server_status()['server_ready']
+
+
+@pytest.mark.parametrize('phase', ['generating', 'prefill', 'unknown', None])
+def test_stop_refuses_active_or_unverifiable_requests(sup, phase):
+    sup.progress = lambda: {'phase': phase}
+    assert 'error' in sup.server_action('stop')
+    assert sup.proc is not None
+    assert not sup.lock.locked()
+
+
+def test_stop_rechecks_activity_before_termination(sup):
+    phases = iter(['idle', 'generating'])
+    sup.progress = lambda: {'phase': next(phases)}
+    assert sup.server_action('stop')['ok']
+    done(sup)
+    assert sup.proc is not None
+    assert 'cancelled' in sup.state['detail']
+
+
+@pytest.mark.parametrize('action', ['start', 'stop'])
+def test_operations_serialize_with_model_switch(sup, action):
+    sup.lock.acquire()
+    try:
+        assert 'error' in sup.server_action(action)
+    finally:
+        sup.lock.release()
+
+
+@pytest.mark.parametrize('reason', ['missing', 'no-model', 'running'])
+def test_invalid_start_leaves_current_state_intact(sup, reason):
+    if reason != 'running':
+        sup.proc = None
+    if reason == 'missing':
+        (sup.models_dir / 'test-model.gguf').unlink()
+    if reason == 'no-model':
+        sup.current = None
+    before = dict(sup.state)
+    assert 'error' in sup.server_action('start')
+    assert sup.state == before
+    assert not sup.lock.locked()
+
+
+@pytest.mark.parametrize('raises', [False, True])
+def test_failed_load_cleans_up_and_can_retry(sup, raises):
+    sup.proc = None
+    def fail(_):
+        sup.proc = SimpleNamespace(poll=lambda: None)
+        if raises:
+            raise OSError('load failed')
+        return False
+    good = sup.start
+    sup.start = fail
+    assert sup.server_action('start')['ok']
+    done(sup)
+    assert sup.state['state'] == 'error' and sup.proc is None
+    sup.start = good
+    assert sup.server_action('start')['ok']
+    done(sup)
+    assert sup.state['state'] == 'ready'
+
+
+def test_thread_start_failure_restores_state(sup, monkeypatch):
+    before = dict(sup.state)
+    monkeypatch.setattr(threading.Thread, 'start', lambda _: (_ for _ in ()).throw(RuntimeError('no threads')))
+    assert 'error' in sup.server_action('stop')
+    assert sup.state == before and not sup.lock.locked()
+
+
+def test_lifecycle_routes_require_auth_and_object_payload(monkeypatch):
+    from tests.test_ui_server import control_request
+    # control_request's fake supervisor needs the same entry point.
+    import localcode.ui.supervisor as module
+    original = module.make_handler
+    calls = []
+    def handler(s):
+        s.server_action = lambda action: calls.append(action) or {'ok': True, 'state': 'loading'}
+        return original(s)
+    monkeypatch.setattr(module, 'make_handler', handler)
+    for action in ('start', 'stop'):
+        assert control_request('/server/'+action, method='POST', token='bad', body={})[0] == 403
+        assert control_request('/server/'+action, method='POST', body=[])[0] == 400
+        assert control_request('/server/'+action, method='POST', body={})[0] == 200
+    assert calls == ['start', 'stop']