localcode 0.5.6__tar.gz → 0.5.7__tar.gz

{localcode-0.5.6/src/localcode.egg-info → localcode-0.5.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localcode
-Version: 0.5.6
+Version: 0.5.7
 Summary: High-performance AI coding on consumer hardware.
 Author: LocalCode contributors
 License-Expression: Apache-2.0
@@ -101,7 +101,7 @@ See [Chat and Decisions](https://mjwsolo.github.io/localcode/guides/decisions).
 
 Docs: [mjwsolo.github.io/localcode](https://mjwsolo.github.io/localcode/)
 
-To use the running model from another local app, run `localcode api` for its
+To use the running model from another local app, open `/server` or run `localcode api` for its
 OpenAI compatible endpoint. See the [Local API guide](https://mjwsolo.github.io/localcode/guides/local-api/).
 
 ## What it does

{localcode-0.5.6 → localcode-0.5.7}/README.md

@@ -53,7 +53,7 @@ See [Chat and Decisions](https://mjwsolo.github.io/localcode/guides/decisions).
 
 Docs: [mjwsolo.github.io/localcode](https://mjwsolo.github.io/localcode/)
 
-To use the running model from another local app, run `localcode api` for its
+To use the running model from another local app, open `/server` or run `localcode api` for its
 OpenAI compatible endpoint. See the [Local API guide](https://mjwsolo.github.io/localcode/guides/local-api/).
 
 ## What it does

{localcode-0.5.6 → localcode-0.5.7}/pyproject.toml

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

{localcode-0.5.6 → localcode-0.5.7}/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.6"
+    __version__ = "0.5.7"

localcode-0.5.7/src/localcode/bin/localcode-ui

@@ -0,0 +1,4 @@
+[diffend] Oversized file quarantined before diffing.
+name: localcode-0.5.7/src/localcode/bin/localcode-ui
+size: 102460976 bytes
+sha256: a09d854109bdb8e9b346777e8fa306afcae9edb32ade0780ccd15a0e15fe3c05

localcode-0.5.7/src/localcode/ui/api.py

@@ -0,0 +1,85 @@
+"""Discover the authenticated local model API for use by other tools."""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+import urllib.request
+import urllib.error
+
+from . import run_dir
+from .auth import read_auth_file, control_headers
+from .ports import find_running, save_port
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="localcode api",
+        description="Show the OpenAI compatible API of a running LocalCode session.",
+    )
+    parser.add_argument("--json", action="store_true", help="Print machine readable connection details")
+    parser.add_argument("--show-key", action="store_true", help="Include the server API key in the output")
+    parser.add_argument("--port", help="Change the live API port, or save it for startup (1024–65535 or auto)")
+    args = parser.parse_args(argv)
+    if args.port is not None:
+        try:
+            port = None if args.port == "auto" else int(args.port)
+            if port is not None and not 1024 <= port <= 65535:
+                raise ValueError("Port must be between 1024 and 65535, or auto")
+            running = find_running()
+            if running is None:
+                save_port(port)
+                print("API port saved for the next launch; no running LocalCode service was found.")
+                return 0
+            auth = read_auth_file(run_dir())
+            if not auth:
+                raise ValueError("Cannot authenticate to the running service; port unchanged")
+            request = urllib.request.Request(
+                f"http://127.0.0.1:{running[0]}/server/port",
+                data=json.dumps({"port": port}).encode(),
+                headers={**control_headers(auth[0]), "Content-Type": "application/json"},
+            )
+            with urllib.request.urlopen(request, timeout=5) as response:
+                result = json.load(response)
+            print(f"API moved to {result['base_url']}. Update external clients to this address; LocalCode stays connected.")
+            return 0
+        except urllib.error.HTTPError as exc:
+            try:
+                message = json.loads(exc.read()).get("error", str(exc))
+            except (ValueError, OSError):
+                message = str(exc)
+            print(f"localcode: {message}", file=sys.stderr)
+            return 1
+        except (ValueError, OSError, KeyError) as exc:
+            print(f"localcode: {exc}. Run `localcode api` to check the current address.", file=sys.stderr)
+            return 1
+
+    running = find_running()
+    if running is None:
+        print("localcode: no running model server; start `localcode` first", file=sys.stderr)
+        return 1
+    _, status = running
+    auth = read_auth_file(run_dir())
+    if auth is None or not auth[1]:
+        print("localcode: the running server's API key is unavailable", file=sys.stderr)
+        return 1
+    port = int(status["port"])
+    alias = status.get("current") or None
+    info = {
+        "base_url": f"http://127.0.0.1:{port}/v1",
+        "model": f"localcode/{alias}" if alias else None,
+        "state": status.get("state"),
+    }
+    if args.show_key:
+        info["api_key"] = auth[1]
+    if args.json:
+        print(json.dumps(info))
+    else:
+        print(f"Base URL: {info['base_url']}")
+        print(f"Model: {info['model'] or '(none loaded)'}")
+        print(f"State: {info['state'] or 'unknown'}")
+        if args.show_key:
+            print(f"API key: {info['api_key']}")
+        else:
+            print("Use --show-key to include the API key.")
+    return 0

localcode-0.5.7/src/localcode/ui/gateway.py

@@ -0,0 +1,187 @@
+"""Movable loopback API listener; the authenticated inference server stays put.
+
+Byte forwarding preserves SSE, request bodies and llama-server's authentication.
+Retiring a listener stops new connections without closing established streams.
+"""
+from __future__ import annotations
+
+import select
+import socket
+import socketserver
+import threading
+import time
+
+from .ports import save_port
+
+
+class PortChangeError(Exception):
+    def __init__(self, message: str, status: int = 409):
+        super().__init__(message)
+        self.status = status
+
+
+def relay(client: socket.socket, upstream: socket.socket, idle_timeout: float = 1800) -> None:
+    """Bounded buffers and half-close support, including streaming responses."""
+    sockets = (client, upstream)
+    for sock in sockets:
+        sock.setblocking(False)
+    pending = {client: bytearray(), upstream: bytearray()}
+    reading = {client, upstream}
+    shut = set()
+    deadline = time.monotonic() + idle_timeout
+    while reading or any(pending.values()):
+        for source, target in ((client, upstream), (upstream, client)):
+            if source not in reading and not pending[target] and target not in shut:
+                target.shutdown(socket.SHUT_WR)
+                shut.add(target)
+        readable = [source for source, target in ((client, upstream), (upstream, client))
+                    if source in reading and len(pending[target]) < 65536]
+        writable = [sock for sock in sockets if pending[sock]]
+        timeout = deadline - time.monotonic()
+        if timeout <= 0:
+            raise TimeoutError("API connection idle timeout")
+        ready, write, _ = select.select(readable, writable, [], min(timeout, 1.0))
+        for source in ready:
+            target = upstream if source is client else client
+            try:
+                chunk = source.recv(65536 - len(pending[target]))
+            except BlockingIOError:
+                continue
+            if chunk:
+                pending[target].extend(chunk)
+                deadline = time.monotonic() + idle_timeout
+            else:
+                reading.remove(source)
+        for target in write:
+            try:
+                count = target.send(pending[target])
+            except BlockingIOError:
+                continue
+            if count == 0:
+                raise ConnectionError("API connection closed")
+            del pending[target][:count]
+            deadline = time.monotonic() + idle_timeout
+
+
+def unavailable(sock: socket.socket) -> None:
+    try:
+        sock.settimeout(1)
+        body = b'{"error":{"message":"Model server unavailable; try again shortly","type":"server_error"}}'
+        sock.sendall(b"HTTP/1.1 503 Service Unavailable\r\nContent-Type: application/json\r\nConnection: close\r\nRetry-After: 1\r\nContent-Length: "
+                     + str(len(body)).encode() + b"\r\n\r\n" + body)
+    except OSError:
+        pass  # The client may already have disconnected.
+
+
+class Listener(socketserver.ThreadingTCPServer):
+    daemon_threads = True
+    block_on_close = False
+    allow_reuse_address = True
+    request_queue_size = 32
+
+    def __init__(self, port: int, backend: int, capacity: threading.BoundedSemaphore):
+        self.backend = backend
+        self.capacity = capacity
+        super().__init__(("127.0.0.1", port), Forward)
+
+    def process_request(self, request, client_address):
+        if not self.capacity.acquire(blocking=False):
+            unavailable(request)
+            self.shutdown_request(request)
+            return
+        try:
+            super().process_request(request, client_address)
+        except Exception:
+            self.capacity.release()
+            self.shutdown_request(request)
+            raise
+
+    def process_request_thread(self, request, client_address):
+        try:
+            super().process_request_thread(request, client_address)
+        finally:
+            self.capacity.release()
+
+    def start(self):
+        thread = threading.Thread(target=self.serve_forever, kwargs={"poll_interval": 0.05}, daemon=True)
+        try:
+            thread.start()
+        except Exception:
+            self.server_close()
+            raise
+        return self
+
+    def retire(self):
+        self.shutdown()
+        self.server_close()  # Existing connection threads keep their own sockets.
+
+
+class Forward(socketserver.BaseRequestHandler):
+    def handle(self):
+        try:
+            upstream = socket.create_connection(("127.0.0.1", self.server.backend), timeout=3)
+        except OSError:
+            unavailable(self.request)
+            return
+        with upstream:
+            try:
+                self.request.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+                upstream.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+                relay(self.request, upstream)
+            except (OSError, TimeoutError):
+                # Never append JSON to an already-started SSE/HTTP response.
+                # Closing the connection tells the client its stream ended.
+                pass
+
+
+class ModelGateway:
+    def __init__(self, backend: int, port: int, control: int):
+        self.backend, self.control = backend, control
+        self._lock = threading.Lock()
+        self._capacity = threading.BoundedSemaphore(64)
+        self.listener = Listener(port, backend, self._capacity).start()
+        self._closed = False
+
+    @property
+    def port(self):
+        return self.listener.server_address[1]
+
+    def change(self, port: int | None):
+        if port is not None and (type(port) is not int or not 1024 <= port <= 65535):
+            raise PortChangeError("Port must be an integer between 1024 and 65535, or auto", 400)
+        if port in (self.backend, self.control):
+            raise PortChangeError("That port is reserved for LocalCode's internal services")
+        if not self._lock.acquire(blocking=False):
+            raise PortChangeError("Another port change is in progress; refresh and try again")
+        replacement = None
+        try:
+            if self._closed:
+                raise PortChangeError("The model service is shutting down", 503)
+            if port != self.port:
+                try:
+                    replacement = Listener(port or 0, self.backend, self._capacity).start()
+                except OSError as exc:
+                    raise PortChangeError(f"Cannot use port {port or 'auto'}: {exc.strerror or str(exc)}. The current port is unchanged.") from exc
+                except RuntimeError as exc:
+                    raise PortChangeError("Could not start the new listener. The current port is unchanged.", 503) from exc
+            try:
+                save_port(port)
+            except OSError as exc:
+                raise PortChangeError("Could not save the port setting. The current port is unchanged.", 500) from exc
+            if replacement is not None:
+                previous, self.listener = self.listener, replacement
+                replacement = None
+                previous.retire()
+            return {"ok": True, "port": self.port, "base_url": f"http://127.0.0.1:{self.port}/v1", "restart_required": False}
+        finally:
+            try:
+                if replacement is not None:
+                    replacement.retire()
+            finally:
+                self._lock.release()
+
+    def close(self):
+        with self._lock:
+            if not self._closed:
+                self._closed = True
+                self.listener.retire()

{localcode-0.5.6 → localcode-0.5.7}/src/localcode/ui/launch.py

@@ -190,7 +190,7 @@ def attach(ctrl: int, status: dict, ui_bin: Path, project_dir: Path, alias: str
     auth = read_auth_file(run_dir())
     if auth:
         os.environ[TOKEN_ENV], os.environ[KEY_ENV] = auth
-    port = int(status["port"])
+    port = int(status.get("inference_port") or status["port"])
     try:
         ctx = int(status.get("ctx") or 0)
     except (TypeError, ValueError):
@@ -303,9 +303,13 @@ def main(model: str | None = None, project: str | None = None,
                 return 1
             time.sleep(0.5)
 
+        status = _get_json(f"http://127.0.0.1:{ctrl}/status", timeout=2)
+        if not status or not status.get("inference_port"):
+            print("localcode: could not discover the model endpoint; relaunch LocalCode", file=sys.stderr)
+            return 1
         ctx = _context_size(models_dir, ctrl)
         config_path = rd / "session.json"
-        write_config(config_path, port=port, ctx=ctx, alias=alias)
+        write_config(config_path, port=int(status["inference_port"]), ctx=ctx, alias=alias)
 
         env = runtime_env(config_path, ctrl, trust_project=trust_project)
         argv = [str(ui_bin)]

{localcode-0.5.6 → localcode-0.5.7}/src/localcode/ui/plugin/modes.ts

@@ -168,7 +168,53 @@ async function tui(api: TuiPluginApi) {
     if (api.route.current.name === route) return back();
     api.ui.dialog.clear();
   } }));
+  let changingPort = 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 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: "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"}` },
+        { 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 === "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) {
+            if (changingPort) return;
+            const input = value.trim();
+            if (input !== "auto" && (!/^\d+$/.test(input) || Number(input) < 1024 || Number(input) > 65535)) return error("Enter a port from 1024 to 65535, or auto");
+            changingPort = true;
+            void fetch(control + "/server/port", { method: "POST", headers, body: JSON.stringify({ port: input === "auto" ? null : Number(input) }), signal: AbortSignal.timeout(3000) })
+              .then(async (r) => {
+                if (!r.ok) throw new Error((await r.json() as { error: string }).error);
+                const result = await r.json() as { base_url: string };
+                api.ui.toast({ variant: "info", message: `API moved to ${result.base_url}. Update other apps to use this address; this chat stays connected.`, duration: 8000 });
+                await server();
+              }).catch((e) => error(`Could not confirm port change: ${String(e)}. Refresh /server to check the current address.`))
+              .finally(() => { changingPort = false; });
+          },
+        }));
+        const key = process.env.LOCALCODE_SERVER_KEY;
+        if ((item.value === "key" || item.value === "curl") && !key) return error("API key unavailable; use localcode api --show-key in a terminal");
+        const value = item.value === "url" ? info.base_url : item.value === "model" ? info.model : item.value === "key" ? key : `curl '${info.base_url}/models' -H 'Authorization: Bearer ${key}'`;
+        if (value) void copy(value, item.value === "key" || item.value === "curl").catch((e) => error(String(e)));
+      } }));
+    } catch (e) { error(String(e)); }
+  }
   api.keymap.registerLayer({ commands: [
+    { name: "localcode.server", title: "Model server connection and port", category: "LocalCode", slash: { name: "server" }, run: server },
     { name: "localcode.mode", title: "Choose Chat or Decisions", category: "LocalCode", slash: { name: "mode" }, run: choose },
     { name: "localcode.decide", title: "Open decision mode", category: "LocalCode", slash: { name: "decide" }, run: open },
   ] });

{localcode-0.5.6 → localcode-0.5.7}/src/localcode/ui/ports.py

@@ -2,20 +2,50 @@
 from __future__ import annotations
 
 import json
+import os
 import socket
+import tempfile
 import urllib.request
 
 from localcode.ui import run_dir
 from localcode.ui.auth import control_headers, read_auth_file
 
 
+def preferred_port() -> int | None:
+    try:
+        value = json.loads((run_dir() / "server-port.json").read_text())["port"]
+    except FileNotFoundError:
+        return None
+    except (OSError, ValueError, KeyError, TypeError) as exc:
+        raise RuntimeError("Invalid server port preference; reset it with localcode api --port auto") from exc
+    if value is not None and (type(value) is not int or not 1024 <= value <= 65535):
+        raise RuntimeError("Saved server port must be between 1024 and 65535")
+    return value
+
+
+def save_port(value: int | None) -> None:
+    """Save a preference for the next launch; never interrupt a live server."""
+    if value is not None and (type(value) is not int or not 1024 <= value <= 65535):
+        raise ValueError("Port must be an integer between 1024 and 65535, or null for automatic")
+    directory = run_dir()
+    directory.mkdir(parents=True, exist_ok=True, mode=0o700)
+    fd, name = tempfile.mkstemp(prefix=".server-port-", dir=directory)
+    try:
+        with os.fdopen(fd, "w") as stream:
+            json.dump({"port": value}, stream)
+        os.replace(name, directory / "server-port.json")
+    finally:
+        if os.path.exists(name):
+            os.unlink(name)
+
+
 def _status(port: int) -> dict:
     """/status of a supervisor on this port, authenticated with the session
     token the supervisor left in the run directory."""
     auth = read_auth_file(run_dir())
     req = urllib.request.Request(f"http://127.0.0.1:{port}/status",
                                  headers=control_headers(auth[0] if auth else ""))
-    with urllib.request.urlopen(req, timeout=0.3) as response:
+    with urllib.request.urlopen(req, timeout=1.5) as response:
         return json.load(response)
 
 
@@ -43,8 +73,15 @@ def find_running(control_ports=range(8323, 8400)) -> tuple[int, dict] | None:
 
 
 def choose_ports(model_ports=range(8123, 8200), control_ports=range(8323, 8400)) -> tuple[int, int]:
+    preferred = preferred_port()
+    if preferred is not None:
+        if not available(preferred):
+            raise RuntimeError(f"Configured model port {preferred} is in use; close that service or change server-port.json in {run_dir()}")
+        model_ports = (preferred,)
     control = None
     for port in control_ports:
+        if port == preferred:
+            continue
         if available(port):
             if control is None:
                 control = port
@@ -54,7 +91,7 @@ def choose_ports(model_ports=range(8123, 8200), control_ports=range(8323, 8400))
             raise RuntimeError("localcode is already running in another terminal; a second window attaches to its model server.")
         except (OSError, ValueError, KeyError, TypeError):
             continue
-    model = next((port for port in model_ports if available(port)), None)
+    model = next((port for port in model_ports if port != control and available(port)), None)
     if model is None or control is None:
         raise RuntimeError("No free local model/control port pair")
     return model, control

{localcode-0.5.6 → localcode-0.5.7}/src/localcode/ui/supervisor.py

@@ -384,6 +384,16 @@ class Supervisor:
         except Exception:  # noqa: BLE001
             return False
 
+    def server_status(self) -> dict:
+        """Report current liveness, not just the last successful model load."""
+        state = dict(self.state)
+        process = self.proc
+        running = process is not None and process.poll() is None
+        ready = running and state["state"] == "ready" and self.healthy()
+        if state["state"] == "ready" and not ready:
+            state.update(state="error", detail="Model server is unavailable")
+        return dict(state, server_running=running, server_ready=ready)
+
     # ---- catalog ------------------------------------------------------------
     def _rec_repo(self) -> str | None:
         try:
@@ -807,10 +817,23 @@ def make_handler(sup: Supervisor):
                 return self._json(sup.quants(key))
             if u.path == "/status":
                 from localcode.decision import supported
-                return self._json(dict(sup.state, current=sup.current, port=sup.port,
+                return self._json(dict(sup.server_status(), current=sup.current,
+                                       port=sup.gateway.port if getattr(sup, "gateway", None) else sup.port,
+                                       inference_port=sup.port,
                                        group=sup.active.get("group"), filename=sup.active.get("filename"),
                                        supports_systemone=supported(sup.current),
                                        **sup.context_info(), **sup.vision_info()))
+            if u.path == "/server":
+                from localcode.ui.ports import preferred_port
+                try:
+                    preferred = preferred_port()
+                except RuntimeError:
+                    preferred = "invalid; choose a new port"
+                port = sup.gateway.port if getattr(sup, "gateway", None) else sup.port
+                return self._json(dict(sup.server_status(), port=port,
+                                       base_url=f"http://127.0.0.1:{port}/v1",
+                                       model=f"localcode/{sup.current}" if sup.current else None,
+                                       preferred_port=preferred))
             if u.path == "/models_dir":
                 return self._json(sup.models_dir_info())
             if u.path == "/voice/status":
@@ -834,6 +857,16 @@ 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 == "/server/port":
+                from localcode.ui.gateway import PortChangeError
+                if not isinstance(body, dict) or "port" not in body:
+                    return self._json({"error": "port is required"}, 400)
+                if not getattr(sup, "gateway", None):
+                    return self._json({"error": "Restart LocalCode once to enable live port changes"}, 409)
+                try:
+                    return self._json(sup.gateway.change(body["port"]))
+                except PortChangeError as exc:
+                    return self._json({"error": str(exc)}, exc.status)
             if u.path == "/decision":
                 from localcode.decision import DecisionError
                 try:
@@ -897,7 +930,24 @@ def main() -> int:
     except BlockingIOError:
         log("localcode is already running; refusing a second model supervisor")
         return 1
-    sup = Supervisor(a.server, a.port, Path(a.models_dir), 0)
+    from localcode.ui.gateway import ModelGateway
+    import socket
+    # The model and every LocalCode window use this stable private endpoint.
+    # Only the externally advertised API listener moves during a port change.
+    try:
+        for _ in range(10):
+            with socket.socket() as sock:
+                sock.bind(("127.0.0.1", 0))
+                inference_port = sock.getsockname()[1]
+            if inference_port not in (a.port, a.control_port):
+                break
+        else:
+            log("could not allocate an internal model port")
+            return 1
+    except OSError as exc:
+        log(f"could not allocate an internal model port: {exc}")
+        return 1
+    sup = Supervisor(a.server, inference_port, Path(a.models_dir), 0)
     sup.lease_fd = lease.fileno()
     # Session secrets: from the launcher's environment, else fresh. Written
     # owner-only into the run dir for a second `localcode` and dev tooling.
@@ -906,24 +956,37 @@ def main() -> int:
     if not server_key():
         os.environ[KEY_ENV] = new_secret()
     write_auth_file(HERE, sup.control_token, server_key())
-    httpd = ThreadingHTTPServer(("127.0.0.1", a.control_port), make_handler(sup))
-    threading.Thread(target=httpd.serve_forever, daemon=True).start()
+    httpd = None
+    try:
+        sup.gateway = ModelGateway(sup.port, a.port, a.control_port)
+        httpd = ThreadingHTTPServer(("127.0.0.1", a.control_port), make_handler(sup))
+        threading.Thread(target=httpd.serve_forever, daemon=True).start()
+    except (OSError, RuntimeError) as exc:
+        if httpd is not None:
+            httpd.server_close()
+        if getattr(sup, "gateway", None):
+            sup.gateway.close()
+        log(f"could not start local API services: {exc}")
+        return 1
 
     def bye(signum, frame):
         import traceback
         log(f"supervisor: got signal {signum}, exiting")
         log("".join(traceback.format_stack(frame)))
+        sup.gateway.close()
         sup.stop()
         with sup.speech_lock:
             if sup.speech_proc and sup.speech_proc.poll() is None:
                 sup.speech_proc.terminate()
         httpd.shutdown()
+        httpd.server_close()
         sys.exit(0)
     signal.signal(signal.SIGTERM, bye)
     signal.signal(signal.SIGINT, bye)
     signal.signal(signal.SIGHUP, bye)
     import atexit
     atexit.register(sup.stop)
+    atexit.register(sup.gateway.close)
     if a.parent_pid:
         def watch_launcher() -> None:
             while os.getppid() == a.parent_pid:

{localcode-0.5.6 → localcode-0.5.7/src/localcode.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localcode
-Version: 0.5.6
+Version: 0.5.7
 Summary: High-performance AI coding on consumer hardware.
 Author: LocalCode contributors
 License-Expression: Apache-2.0
@@ -101,7 +101,7 @@ See [Chat and Decisions](https://mjwsolo.github.io/localcode/guides/decisions).
 
 Docs: [mjwsolo.github.io/localcode](https://mjwsolo.github.io/localcode/)
 
-To use the running model from another local app, run `localcode api` for its
+To use the running model from another local app, open `/server` or run `localcode api` for its
 OpenAI compatible endpoint. See the [Local API guide](https://mjwsolo.github.io/localcode/guides/local-api/).
 
 ## What it does

{localcode-0.5.6 → localcode-0.5.7}/src/localcode.egg-info/SOURCES.txt

@@ -1197,6 +1197,7 @@ src/localcode/ui/__init__.py
 src/localcode/ui/api.py
 src/localcode/ui/auth.py
 src/localcode/ui/context_budget.py
+src/localcode/ui/gateway.py
 src/localcode/ui/launch.py
 src/localcode/ui/ports.py
 src/localcode/ui/server_cmd.py
@@ -1240,5 +1241,7 @@ tests/test_thermal.py
 tests/test_ui_api.py
 tests/test_ui_auth.py
 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_warmup.py

{localcode-0.5.6 → localcode-0.5.7}/tests/test_architecture.py

@@ -386,6 +386,9 @@ PRINT_ALLOWLIST = {
     # CLI entry point (`localcode api`): prints the local endpoint details
     # to the terminal for other tools. Not invoked from the agent loop.
     "api.py",
+    # CLI entry point (`localcode decide`): JSON results on stdout and errors
+    # on stderr. Its inference helpers do not print into the TUI.
+    "decision.py",
 }