Qwen3.8-Flash-Next on any consumer hardware: one-click install for Windows / Linux. Strata inference engine, OpenAI/Anthropic API on localhost, optional image input.
C++
launch: TUI screens, runner events, monitor Connect view, harness check, tests for flags and rules
Niko12215fbd5396283b
diff --git a/strata_cli/launch/access.py b/strata_cli/launch/access.pyindex 2832896b5..9ae286ca4 100644--- a/strata_cli/launch/access.py+++ b/strata_cli/launch/access.py@@ -148,19 +148,19 @@ def options(port: int, *, tunnel_url: str | None = None) -> list[AccessOption]:cf = find_cloudflared()ts = tailscale_status()out = [AccessOption("local", "This computer only", f"http://127.0.0.1:{port}",- "for apps on this computer (OpenCode, Codex, Claude Code...)", True)]+ "for apps on this computer", True)]out.append(AccessOption("lan", "My local network", f"http://{lan or '<network address>'}:{port}",- "other computers at home or in the office" if lan else- "other computers on your network; no network address was found on this computer", bool(lan), warn=not lan))+ "other computers at home or the office" if lan else+ "no network address found on this computer", bool(lan), warn=not lan))out.append(AccessOption("cloudflare", "Cloudflare tunnel", tunnel_url or "https://<random>.trycloudflare.com",- "from anywhere, no router setup · cloudflared found" if cf else "cloudflared is not installed",+ "from anywhere · cloudflared found" if cf else "cloudflared is not installed",bool(cf), warn=not cf))if ts["running"]:out.append(AccessOption("tailscale", "Tailscale", f"http://{ts['name'] or ts['ip']}:{port}",- f"your Tailscale devices · tailnet address {ts['ip']}", True))+ "your Tailscale devices", True))else:out.append(AccessOption("tailscale", "Tailscale", f"http://<tailnet address>:{port}",- "Tailscale is installed but not connected (run: tailscale up)" if ts["installed"] else+ "Tailscale is not connected" if ts["installed"] else"Tailscale is not installed", False, warn=True))return outdiff --git a/strata_cli/launch/app.py b/strata_cli/launch/app.pynew file mode 100644index 000000000..017563dd2--- /dev/null+++ b/strata_cli/launch/app.py@@ -0,0 +1,354 @@+"""The `strata launch` application: the screens in order, the run, and the hand-over to the monitor.++`run_tui` opens the screens (or, with settings already chosen, goes straight to the run), then the Strata Monitor with the+launch-aware extras: a Connect view (key 7) and a quit question (keep serving in the background, or stop).+"""++from __future__ import annotations++import json+import sys+import threading+from dataclasses import dataclass, field+from pathlib import Path+from typing import Any++from rich.text import Text+from textual.app import App+from textual.binding import Binding++from strata_cli.launch import access as acc+from strata_cli.launch import params as P+from strata_cli.launch import settings as S+from strata_cli.launch import store+from strata_cli.launch.catalog import Catalog+from strata_cli.launch.runner import Cancelled, Event, LaunchError, Result, Runner, read_config+from strata_cli.launch.screens import (AccessScreen, AdvancedScreen, CardsScreen, ConfirmScreen, ContextScreen, FolderScreen,+ ModelScreen, ParallelScreen, PicturesScreen, RunScreen, SaveScreen, StartScreen,+ TuningScreen, flow_for)+from strata_cli.launch.widgets import CSS, Glyphs++SCREENS = {"model": ModelScreen, "cards": CardsScreen, "folder": FolderScreen, "context": ContextScreen, "pictures": PicturesScreen,+ "parallel": ParallelScreen, "tuning": TuningScreen, "advanced": AdvancedScreen, "access": AccessScreen, "save": SaveScreen}+++@dataclass+class Ctx:+ """Everything the screens share: the catalog, this computer, the choices so far."""++ catalog: Catalog+ computer: Any+ rows: list+ settings: S.LaunchSettings+ glyphs: Glyphs = field(default_factory=Glyphs)+ feed: str | None = None+ notes: list[str] = field(default_factory=list)+ start_own_files: bool = False+ picked_in_list: bool = False+ tune_chosen: bool = False+ fresh_setup: bool = True+ engine_note: str = ""+ engine_flags: list[str] | None = None+ _adv: list | None = None+ _help: str | None = None++ # ---- names and warnings+ def default_name(self) -> str:+ s = self.settings+ base = f"{s.model or 'my model'} {S.context_label(s.context)}"+ names = {p.name for p in store.list_presets()}+ if base not in names:+ return base+ n = 2+ while f"{base} ({n})" in names:+ n += 1+ return f"{base} ({n})"++ def warnings(self) -> list[str]:+ s = self.settings+ out = [n.line() for n in S.check_access(s)]+ out += [n.line() for n in S.check_parallel(s, vram_gb=self.computer.main_vram_gb or None)]+ out += [n.line() for n in S.check_context(s)]+ r = next((x for x in self.rows if (x.family, x.model) == (s.family, s.model)), None)+ if r is not None and r.verdict != "fits":+ out.append(f"{r.title}: {r.words}.")+ missing = acc.missing_helper(s.access)+ if missing:+ out.append(missing)+ return out++ # ---- the installed model's configuration (for the Advanced table and the command)+ def base_config(self) -> dict | None:+ s = self.settings+ if not (s.family and s.model):+ return None+ path = self.catalog.installed_config(self.catalog.tag_of(s.family, s.model))+ if path is None:+ return None+ try:+ return read_config(path)+ except (OSError, ValueError):+ return None++ def engine_exe(self) -> str | None:+ try:+ from strata_control import engine_component as ec+ rep = ec.status()+ return (rep.get("engine") or {}).get("exe") if rep.get("usable") else None+ except Exception: # noqa: BLE001+ return None++ def invalidate_rows(self) -> None:+ self._adv = None++ def advanced_rows(self) -> list[P.Row]:+ if self._adv is not None:+ return self._adv+ s = self.settings+ cfg = self.base_config()+ base_args = list((cfg or {}).get("args") or [])+ base_env = dict((cfg or {}).get("env") or {})+ tuned_args, tuned_env = None, None+ if cfg:+ try:+ from strata_control import presets+ merged, info = presets.overlay(cfg)+ if info.get("applied"):+ tuned_args, tuned_env = list(merged.get("args") or []), dict(merged.get("env") or {})+ except Exception: # noqa: BLE001+ pass+ exe = self.engine_exe()+ text = P.engine_help_text(exe) if exe else None+ if exe and text:+ self.engine_flags = sorted({p.name for p in P.parse_help(text)})+ self.engine_note = ""+ else:+ self.engine_flags = None+ self.engine_note = ("The engine is not installed yet, so this list shows only what this launch uses. The full list "+ "appears after the first launch installs it.") if not exe else \+ "The engine's own list could not be read here; names are not checked."+ if not cfg and not s.extra:+ self.engine_note = self.engine_note or "The model is not installed yet; the defaults and tuned values appear after it is."+ self._adv = P.build_rows(text, base_args, tuned_args, base_env, tuned_env, s.extra)+ return self._adv++ def command_text(self) -> str:+ s = self.settings+ name = "launch-" + S.slug(s.name or self.default_name())+ cfg = self.base_config()+ line = f"strata runtime start --profile {name}"+ if cfg is None:+ return line + " (the engine command is shown once the model is installed)"+ try:+ from strata_control import tune_knobs+ from strata_cli.launch.runner import derive_config+ from serve.server import engine_args+ import contextlib+ import io+ d = derive_config(cfg, s, bool_flags=tune_knobs.BOOL_FLAGS)+ if s.parallel:+ d["parallel"] = s.parallel+ with contextlib.redirect_stdout(io.StringIO()):+ argv = engine_args(d)+ argv = ["***" if (i and argv[i - 1] in ("--api-key",)) else a for i, a in enumerate(argv)]+ return f"{Path(str(d.get('exe', 'engine'))).name} {' '.join(str(a) for a in argv)}"+ except Exception: # noqa: BLE001+ return line+++class LaunchApp(App):+ TITLE = "strata launch"+ CSS = CSS++ def __init__(self, ctx: Ctx, *, auto_run: bool = False) -> None:+ super().__init__()+ self.ctx = ctx+ self.history: list[str] = []+ self.result: Result | None = None+ self.stopped_after_save = False+ self.cancel = threading.Event()+ self.auto_run = auto_run+ self.runner: Runner | None = None+ self.run_screen: RunScreen | None = None+ self.running = False++ def on_mount(self) -> None:+ if self.auto_run:+ self.run_launch()+ else:+ self.push_screen(StartScreen())++ # ---- navigation+ def flow(self) -> list[str]:+ return flow_for(self.ctx)++ def goto(self, step_id: str) -> None:+ self.current = step_id+ self.switch_screen(SCREENS[step_id]())++ def begin_setup(self, *, preset: str | None = None, own_files: bool = False) -> None:+ self.ctx.tune_chosen = False+ self.ctx.fresh_setup = not preset+ if preset:+ s = store.load(preset)+ self.ctx.settings = s+ else:+ self.ctx.settings = S.LaunchSettings()+ self.ctx.start_own_files = own_files+ self.ctx.picked_in_list = False+ self.ctx.invalidate_rows()+ self.current = "model"+ self.switch_screen(ModelScreen())++ def advance(self) -> None:+ flow = self.flow()+ i = flow.index(self.current) if self.current in flow else -1+ if i + 1 < len(flow):+ self.goto(flow[i + 1])++ def back(self) -> None:+ flow = self.flow()+ i = flow.index(self.current) if self.current in flow else 0+ if i > 0:+ self.goto(flow[i - 1])+ else:+ self.current = "start"+ self.switch_screen(StartScreen())++ # ---- starting+ def start_preset(self, name: str) -> None:+ s = store.load(name)+ self.ctx.settings = s+ self.run_launch()++ def run_launch(self) -> None:+ s = self.ctx.settings+ self.cancel = threading.Event()+ self.runner = Runner(s, catalog=self.ctx.catalog, emit=self._emit, cancel=self.cancel, feed=self.ctx.feed)+ screen = RunScreen()+ self.run_screen = screen+ self.current = "run"+ self.switch_screen(screen)+ self.running = True+ threading.Thread(target=self._work, daemon=True).start()++ def _emit(self, ev: Event) -> None:+ screen = self.run_screen+ if screen is not None:+ try:+ self.call_from_thread(screen.on_event, ev)+ except Exception: # noqa: BLE001 - the app is closing+ pass++ def _work(self) -> None:+ screen = self.run_screen+ try:+ result = self.runner.run() # type: ignore[union-attr]+ except Cancelled:+ self.running = False+ self.call_from_thread(self._after_cancel)+ return+ except LaunchError as e:+ self.running = False+ self.call_from_thread(screen.on_failure, f"{e.text} {e.next}".strip())+ return+ except Exception as e: # noqa: BLE001+ self.running = False+ self.call_from_thread(screen.on_failure, f"Something unexpected went wrong: {type(e).__name__}: {e}")+ return+ self.running = False+ s = self.ctx.settings+ try:+ if s.name and store.load(s.name, missing_ok=True) is not None:+ store.save(s, s.name)+ store.touch_used(s.name)+ except Exception: # noqa: BLE001+ pass+ self.result = result+ self.call_from_thread(screen.on_finished)+ self.call_from_thread(self.exit, result)++ def _after_cancel(self) -> None:+ self.run_screen.on_failure("Stopped. Nothing was started.") # type: ignore[union-attr]++ def stop_run(self, screen) -> None:+ if not self.running:+ if screen.failed:+ self.back_to_start()+ else:+ self.exit(None)+ return++ def done(choice: str | None) -> None:+ if choice == "stop":+ self.cancel.set()++ self.push_screen(ConfirmScreen("Stop now?", "Files already downloaded are kept; a download continues where it stopped next time. "+ "Nothing is started.", [("stop", "Stop"), ("go", "Keep going")]), done)++ def back_to_start(self) -> None:+ self.current = "start"+ self.switch_screen(StartScreen())+++# ------------------------------------------------------------------------------------------------ the monitor++def _info_for(result: Result, s: S.LaunchSettings) -> dict:+ cfg = {}+ try:+ cfg = read_config(Path(result.config))+ except (OSError, ValueError):+ pass+ return {"url": result.urls[0] if result.urls else f"http://127.0.0.1:{s.port}", "urls": result.urls, "key": result.key,+ "model": cfg.get("model_name") or "strata", "name": s.name, "profile": result.profile, "running": True,+ "tunnel": result.tunnel}+++def run_monitor(info: dict, *, keep_default: bool = True, color: str = "auto") -> int:+ """Open the monitor for a running launch. q asks whether to keep serving or stop."""+ from strata_cli.client import Endpoint+ from strata_cli.launch.monitor_ext import LaunchMonitor+ local = next((u for u in info.get("urls", []) if "127.0.0.1" in u), None) or f"http://127.0.0.1:{info.get('port', S.DEFAULT_PORT)}"+ endpoint = Endpoint(local, info.get("key"), 3.0, "")+ app = LaunchMonitor(endpoint, None, info=info, color=color)+ app.run()+ if app.stop_requested:+ from strata_cli.launch.runner import Runner as R+ from strata_control import runtime+ try:+ runtime.stop(info["profile"], timeout=180)+ except Exception as e: # noqa: BLE001+ print(f"strata: could not stop the server: {e}", file=sys.stderr)+ return 6+ acc.stop_tunnel(info["profile"])+ print("Stopped. The model is unloaded and the graphics memory is free.")+ else:+ print(f"Still serving at {info['url']}. Watch it again: strata monitor --url {info['url']} Stop: strata launch --stop")+ return 0+++def run_tui(settings: S.LaunchSettings | None, *, catalog: Catalog | None = None, feed: str | None = None, auto_run: bool = False,+ save: bool = False) -> int:+ """Open the launch screens. `settings` given and `auto_run`: skip the questions and go straight to the run."""+ catalog = catalog or Catalog()+ print("Looking at this computer…", flush=True)+ computer = catalog.computer()+ rows = catalog.rows(computer.raw)+ from strata_cli.launch.cmd import apply_defaults+ s = settings or S.LaunchSettings()+ notes: list[S.Notice] = []+ if settings is not None:+ s, notes = apply_defaults(s, catalog)+ if not s.name:+ s.name = f"{s.model or 'model'} {S.context_label(s.context)}"+ if save:+ store.save(s, s.name)+ ctx = Ctx(catalog=catalog, computer=computer, rows=rows, settings=s, glyphs=Glyphs(), feed=feed)+ app = LaunchApp(ctx, auto_run=auto_run)+ result = app.run()+ if app.stopped_after_save:+ print(f"Saved the preset '{ctx.settings.name}'. Start it with: strata launch --preset \"{ctx.settings.name}\"")+ return 0+ if result is None:+ return 0+ return run_monitor(_info_for(result, ctx.settings))diff --git a/strata_cli/launch/catalog.py b/strata_cli/launch/catalog.pyindex a911a5652..ff4d1ab62 100644--- a/strata_cli/launch/catalog.py+++ b/strata_cli/launch/catalog.py@@ -70,12 +70,12 @@ def verdict(on_this_pc: str | None) -> tuple[str, str]:if not text:return TIGHT, "not checked (this computer's memory could not be read)"if low.startswith("does not fit"):- return NO, "does not fit (you can still try)"+ return NO, "does not fit (can still try)"if "low-ram mode" in low:- return FITS, "fits (slower: part of it stays in RAM or on the SSD)"+ return FITS, "fits, a bit slower"if "part of its experts" in low or "read from the ssd" in low:base = "slow here" in low- return TIGHT, ("tight: part is read from the SSD, noticeably slower" if base else "fits, with part read from the SSD")+ return (TIGHT, "tight: much read from SSD") if base else (FITS, "fits, part read from SSD")if low.startswith("tight"):return TIGHT, "tight: close other programs"if "fits" in low:diff --git a/strata_cli/launch/check.py b/strata_cli/launch/check.pynew file mode 100644index 000000000..4399906e1--- /dev/null+++ b/strata_cli/launch/check.py@@ -0,0 +1,150 @@+"""Check my harness: send one simple prompt and one tool call to the running server the way an app configured by+`strata connect` would, and say in plain words whether each worked.++The check uses the harness's own wire format (chat completions, responses, or messages) with the address, key and model name its+config carries, so it proves the settings `strata connect` prints reach a server that answers correctly. It does not start the app+itself. The prompt's answer text is checked (it must contain the expected word) and the tool call's arguments are checked (the+city must be named), not just the HTTP status.+"""++from __future__ import annotations++import json+import time+import urllib.error+import urllib.request+from dataclasses import dataclass++#: harness id -> the endpoint family it speaks (the others use chat completions)+WIRE = {"codex": "responses", "claude-code": "messages"}++PROMPT = "Reply with exactly one word: pong"+TOOL_PROMPT = "What is the weather in Paris? Use the get_weather tool."+TOOL_SCHEMA = {"type": "object", "properties": {"city": {"type": "string"}}, "required": ["city"]}+++@dataclass+class Check:+ name: str # "prompt" | "tool call"+ ok: bool+ detail: str # plain words+ seconds: float = 0.0+++def _post(url: str, key: str, body: dict, headers: dict | None = None, timeout: float = 240.0) -> dict:+ h = {"Content-Type": "application/json", "Accept": "application/json", **(headers or {})}+ if key:+ h["Authorization"] = "Bearer " + key+ h["x-api-key"] = key+ req = urllib.request.Request(url, data=json.dumps(body).encode("utf-8"), headers=h, method="POST")+ with urllib.request.urlopen(req, timeout=timeout) as r:+ return json.loads(r.read().decode("utf-8", "replace"))+++def wire_for(harness_id: str) -> str:+ return WIRE.get(harness_id, "chat")+++def _prompt_request(wire: str, base: str, model: str) -> tuple[str, dict]:+ if wire == "responses":+ return base + "/v1/responses", {"model": model, "input": PROMPT, "max_output_tokens": 256}+ if wire == "messages":+ return base + "/v1/messages", {"model": model, "max_tokens": 256, "messages": [{"role": "user", "content": PROMPT}]}+ return base + "/v1/chat/completions", {"model": model, "max_tokens": 256, "messages": [{"role": "user", "content": PROMPT}]}+++def _tool_request(wire: str, base: str, model: str) -> tuple[str, dict]:+ if wire == "responses":+ return base + "/v1/responses", {"model": model, "input": TOOL_PROMPT, "max_output_tokens": 512, "tool_choice": "auto",+ "tools": [{"type": "function", "name": "get_weather", "description": "Weather of a city",+ "parameters": TOOL_SCHEMA}]}+ if wire == "messages":+ return base + "/v1/messages", {"model": model, "max_tokens": 512, "messages": [{"role": "user", "content": TOOL_PROMPT}],+ "tools": [{"name": "get_weather", "description": "Weather of a city", "input_schema": TOOL_SCHEMA}]}+ return base + "/v1/chat/completions", {"model": model, "max_tokens": 512, "messages": [{"role": "user", "content": TOOL_PROMPT}],+ "tools": [{"type": "function", "function": {"name": "get_weather", "description": "Weather of a city",+ "parameters": TOOL_SCHEMA}}]}+++def answer_text(wire: str, data: dict) -> str:+ if wire == "responses":+ if isinstance(data.get("output_text"), str):+ return data["output_text"]+ parts = []+ for item in data.get("output") or []:+ for c in item.get("content") or []:+ if isinstance(c, dict) and c.get("text"):+ parts.append(c["text"])+ return "".join(parts)+ if wire == "messages":+ return "".join(b.get("text", "") for b in data.get("content") or [] if isinstance(b, dict) and b.get("type") == "text")+ try:+ return data["choices"][0]["message"].get("content") or ""+ except (KeyError, IndexError, TypeError, AttributeError):+ return ""+++def tool_calls(wire: str, data: dict) -> list[tuple[str, dict]]:+ out: list[tuple[str, dict]] = []+ try:+ if wire == "responses":+ for item in data.get("output") or []:+ if item.get("type") == "function_call":+ out.append((item.get("name", ""), json.loads(item.get("arguments") or "{}")))+ elif wire == "messages":+ for b in data.get("content") or []:+ if isinstance(b, dict) and b.get("type") == "tool_use":+ out.append((b.get("name", ""), b.get("input") or {}))+ else:+ for tc in data["choices"][0]["message"].get("tool_calls") or []:+ fn = tc.get("function") or {}+ out.append((fn.get("name", ""), json.loads(fn.get("arguments") or "{}")))+ except (KeyError, IndexError, TypeError, ValueError, AttributeError):+ return out+ return out+++def run_checks(harness_id: str, url: str, key: str, model: str, *, timeout: float = 240.0, poster=_post) -> list[Check]:+ """The two checks for one harness. `poster` is replaceable for tests."""+ base = url.rstrip("/")+ wire = wire_for(harness_id)+ checks: list[Check] = []+ t0 = time.monotonic()+ try:+ u, body = _prompt_request(wire, base, model)+ data = poster(u, key, body, None, timeout)+ text = answer_text(wire, data).strip()+ ok = "pong" in text.lower()+ checks.append(Check("prompt", ok, f"It answered: {text[:60]!r}." if ok else+ (f"It answered {text[:60]!r}, not the word asked for." if text else "The server replied but with no text."),+ time.monotonic() - t0))+ except Exception as e: # noqa: BLE001+ checks.append(Check("prompt", False, _why(e), time.monotonic() - t0))+ t1 = time.monotonic()+ try:+ u, body = _tool_request(wire, base, model)+ data = poster(u, key, body, None, timeout)+ calls = tool_calls(wire, data)+ hit = next(((n, a) for n, a in calls if n == "get_weather" and "paris" in json.dumps(a).lower()), None)+ if hit:+ checks.append(Check("tool call", True, f"It called {hit[0]} with {json.dumps(hit[1])}.", time.monotonic() - t1))+ elif calls:+ checks.append(Check("tool call", False, f"It called {calls[0][0]} with {json.dumps(calls[0][1])[:60]}, not the city asked for.",+ time.monotonic() - t1))+ else:+ checks.append(Check("tool call", False, "The model answered in words and did not call the tool.", time.monotonic() - t1))+ except Exception as e: # noqa: BLE001+ checks.append(Check("tool call", False, _why(e), time.monotonic() - t1))+ return checks+++def _why(e: Exception) -> str:+ if isinstance(e, urllib.error.HTTPError):+ if e.code in (401, 403):+ return "The server refused the key. Check the API key in the config."+ if e.code == 404:+ return "The server does not have that address. Check the server address and the app's endpoint type."+ return f"The server answered with an error (HTTP {e.code})."+ if isinstance(e, urllib.error.URLError):+ return "The server could not be reached. Is it running (strata launch --status)?"+ return f"The check could not finish: {type(e).__name__}."diff --git a/strata_cli/launch/monitor_ext.py b/strata_cli/launch/monitor_ext.pynew file mode 100644index 000000000..f811bc322--- /dev/null+++ b/strata_cli/launch/monitor_ext.py@@ -0,0 +1,255 @@+"""The Strata Monitor as `strata launch` opens it: the same monitor plus a Connect view and a quit question.++Everything about the monitor itself (the views, colours, polling, key hints) is `strata_cli.monitor.MonitorApp`, unchanged.+This subclass adds+* key 7: the Connect view (the address, the API key hint and copy-ready setup for each app, with `c` copy, `w` write the config for+ you after a backup, `h` check that the app's settings reach a server that answers a prompt and a tool call correctly);+* q: asks whether to keep serving in the background or stop (stopping frees the graphics memory).+"""++from __future__ import annotations++import threading++from rich.text import Text+from textual.binding import Binding+from textual.widgets import Static++from strata_cli.launch import check, harness+from strata_cli.launch.screens import ConfirmScreen+from strata_cli.launch.widgets import ACCENT, BAD, MUTE, WARN, Glyphs+from strata_cli.monitor import MonitorApp+from strata_cli.render import VIEWS, safe+++class LaunchMonitor(MonitorApp):+ BINDINGS = MonitorApp.BINDINGS + [Binding("7", "connect", "Connect view", show=False)]++ def __init__(self, endpoint, snapshot, *, info: dict, **kw) -> None:+ super().__init__(endpoint, snapshot, **kw)+ self.info = info+ self.connect_open = False+ self.connect_index = 0+ self.show_key = False+ self.check_results: dict[str, list[check.Check] | str] = {}+ self.glyphs = Glyphs()+ self.stop_requested = False+ self.notice = ""++ # ---- quit asks+ def action_quit(self) -> None:+ if self.closing:+ return++ def done(choice: str | None) -> None:+ if choice == "keep":+ self.closing = True+ self.exit()+ elif choice == "stop":+ self.stop_requested = True+ self.closing = True+ self.exit()++ self.push_screen(ConfirmScreen("Leave the monitor?", "Keeping it serving lets your apps go on using the model. "+ "Stopping unloads the model and frees the graphics memory.",+ [("keep", "Keep serving in the background"), ("stop", "Stop serving and free the memory"),+ ("cancel", "Stay in the monitor")]), done)++ # ---- the Connect view+ def _harness(self) -> harness.Harness:+ return harness.HARNESSES[self.connect_index % len(harness.HARNESSES)]++ def action_connect(self) -> None:+ self.connect_open = not self.connect_open+ self.notice = ""+ self._paint()++ def _set_view(self, index: int) -> None:+ self.connect_open = False+ super()._set_view(index)++ def action_next_row(self) -> None:+ if self.connect_open:+ self.connect_index = (self.connect_index + 1) % len(harness.HARNESSES)+ self.notice = ""+ self._paint()+ else:+ super().action_next_row()++ def action_previous_row(self) -> None:+ if self.connect_open:+ self.connect_index = (self.connect_index - 1) % len(harness.HARNESSES)+ self.notice = ""+ self._paint()+ else:+ super().action_previous_row()++ def action_filter_clear(self) -> None:+ if self.connect_open:+ self.connect_open = False+ self._paint()+ else:+ super().action_filter_clear()++ def action_request_detail(self) -> None:+ if not self.connect_open:+ super().action_request_detail()++ def action_next_view(self) -> None:+ if self.connect_open:+ self.connect_open = False+ self._paint()+ super().action_next_view()++ def on_key(self, event) -> None:+ if not self.connect_open:+ return+ key = event.key+ if key == "c":+ self._copy()+ elif key == "w":+ self._write()+ elif key == "k":+ self.show_key = not self.show_key+ self._paint()+ elif key == "h":+ self._check()+ else:+ return+ event.stop()++ def _rendered(self) -> dict:+ h = self._harness()+ key = self.info.get("key") or ""+ return harness.render(h, url=self.info["url"], key=key or "<your API key>", model=self.info.get("model") or "strata")++ def _copy(self) -> None:+ out = self._rendered()+ text = "\n\n".join(f"# {f['path']}\n{f['text']}" for f in out["files"])+ if out["env"]:+ text += "\n\n" + "\n".join(f"{k}={v}" for k, v in out["env"].items())+ try:+ self.copy_to_clipboard(text)+ self.notice = "Copied (if your terminal allows it)."+ except Exception: # noqa: BLE001+ self.notice = "! Your terminal does not allow copying; use: strata connect " + self._harness().id+ self._paint()++ def _write(self) -> None:+ h = self._harness()+ out = self._rendered()+ if not out["files"]:+ self.notice = "! Nothing to write for this app."+ self._paint()+ return++ def done(choice: str | None) -> None:+ if choice != "write":+ return+ lines = []+ for f in out["files"]:+ try:+ r = harness.write_file(f)+ lines.append(f"{r['action']} {r['path']}" + (f" (backup {r['backup']})" if r["backup"] else ""))+ except OSError as e:+ lines.append(f"could not write {f['path']}: {e}")+ self.notice = "; ".join(lines)+ self._paint()++ self.push_screen(ConfirmScreen(f"Write {h.title}'s settings?", "A file that exists is copied to a backup first.\n"+ + "\n".join(f" {f['path']}" for f in out["files"]),+ [("write", "Write it"), ("no", "Not now")]), done)++ def _check(self) -> None:+ h = self._harness()+ self.check_results[h.id] = "running"+ self.notice = "Checking: one prompt and one tool call. This can take a minute on a big model."+ self._paint()+ key = self.info.get("key") or ""+ url = self.info["url"]+ model = self.info.get("model") or "strata"++ def work() -> None:+ res = check.run_checks(h.id, url, key, model)+ self.check_results[h.id] = res+ try:+ self.call_from_thread(self._paint)+ except Exception: # noqa: BLE001+ pass++ threading.Thread(target=work, daemon=True).start()++ # ---- painting+ def _paint(self, size=None) -> None:+ if not getattr(self, "connect_open", False):+ return super()._paint(size)+ size = self.screen.size if size is None else size+ width = max(40, size.width - 2)+ self.query_one("#content", Static).update(self.connect_text(width))+ idle = "c copy w write it for me (keeps a backup) h check it 1-7 views q quit (asks: keep serving / stop)"+ msg = self.notice or idle+ self.query_one("#message", Static).update(Text(msg, style=WARN if msg.startswith("!") else ""))++ def connect_text(self, width: int) -> Text:+ g = self.glyphs+ state = {"connected": "[LIVE]", "stale": "[STALE]", "connecting": "[CONNECTING]", "disconnected": "[DISCONNECTED]",+ "auth_required": "[AUTH REQUIRED]"}.get(self.connection_state, "[LIVE]")+ t = Text(no_wrap=True, overflow="crop")+ head = f"STRATA Connect {self.info['url']}"+ t.append(head, style=f"bold {ACCENT}")+ t.append(" " * max(2, width - len(head) - len(state)) + state + "\n", style=f"bold {ACCENT}")+ nav = []+ for i, name in enumerate(VIEWS):+ nav.append(f"{i + 1} {name.title()}")+ nav.append("[7 Connect]")+ t.append(" ".join(nav) + "\n")+ t.append(g.rule * min(width, 100) + "\n", style=MUTE)+ key = self.info.get("key") or ""+ shown = key if self.show_key else (key[:10] + g.mask * 4 if key else "off")+ t.append("Connect an app", style=f"bold {ACCENT}")+ t.append(f" URL {self.info['url']}/v1 model {self.info.get('model') or 'strata'} key {shown} ")+ t.append("(k hide)" if self.show_key else "(k show)", style=MUTE)+ t.append("\n")+ for u in self.info.get("urls", [])[1:]:+ t.append(f" also reachable at {u}/v1\n", style=MUTE)+ t.append("\n " + "App".ljust(20) + "Works with".ljust(22) + "Status\n", style="bold")+ for i, h in enumerate(harness.HARNESSES):+ sel = i == self.connect_index % len(harness.HARNESSES)+ res = self.check_results.get(h.id)+ status = h.status + (f" {g.tick}" if h.tested else "")+ style = ""+ if res == "running":+ status, style = "checking…", WARN+ elif isinstance(res, list):+ okn = sum(1 for c in res if c.ok)+ status, style = (f"works {g.tick} ({okn}/{len(res)} checks)" if okn == len(res) else f"problem ({okn}/{len(res)} checks)"), \+ (ACCENT if okn == len(res) else BAD)+ row = (" " + (g.cursor + " " if sel else " ")) + h.title.ljust(20) + h.speaks.ljust(22) + status+ t.append(row.ljust(width - 1) + "\n", style=(f"bold {ACCENT} on #1f2a27" if sel else style))+ h = self._harness()+ out = self._rendered()+ t.append("\n")+ paths = ", ".join(f["path"] for f in out["files"]) or ("built into the Strata app" if h.built_in else "")+ t.append(f"{h.title} setup", style=f"bold {ACCENT}")+ t.append(f" {paths}\n", style=MUTE)+ if not h.tested and not h.built_in:+ t.append(" Not tested with this app yet: a starting point, not a promise.\n", style=WARN)+ for n in h.notes:+ t.append(f" {n}\n", style=MUTE)+ shown_lines = []+ for f in out["files"][:1]:+ body = f["text"] if self.show_key else harness.mask(f["text"], key)+ shown_lines += body.splitlines()+ for k, v in out["env"].items():+ shown_lines.append(f"{k}={v if self.show_key else harness.mask(v, key)}")+ room = max(3, 0)+ for line in shown_lines[:14]:+ t.append(" " + line + "\n")+ if len(shown_lines) > 14:+ t.append(f" … {len(shown_lines) - 14} more lines (c copies all)\n", style=MUTE)+ res = self.check_results.get(h.id)+ if isinstance(res, list):+ t.append("\n")+ for c in res:+ t.append(f" {g.tick if c.ok else 'x'} {c.name}: {c.detail}\n", style=ACCENT if c.ok else BAD)+ return tdiff --git a/strata_cli/launch/screens.py b/strata_cli/launch/screens.pynew file mode 100644index 000000000..9a28af77b--- /dev/null+++ b/strata_cli/launch/screens.py@@ -0,0 +1,1341 @@+"""The screens of `strata launch`: the saved-preset start screen, the nine setup steps, the confirm pop-up and the progress screen.++One decision per screen. Every screen has a short plain explanation under the content (what it means, what to do next) and a line+of key hints. Esc goes back, Enter goes on, q leaves (and says what is kept). Choices are written into `app.ctx.settings`+(strata_cli/launch/settings.py); nothing is installed or started until the last screen.+"""++from __future__ import annotations++import os+import shutil+import threading+from pathlib import Path+from typing import Any++from rich.text import Text+from textual.app import ComposeResult+from textual.binding import Binding+from textual.containers import Vertical+from textual.screen import ModalScreen, Screen+from textual.widgets import Input, Static++from strata_cli.launch import access as acc+from strata_cli.launch import params as P+from strata_cli.launch import settings as S+from strata_cli.launch import store+from strata_cli.launch.widgets import (ACCENT, BAD, FG, MUTE, WARN, Cell, Item, Menu, bar)++STEPS = (("model", "Model"), ("cards", "Cards"), ("folder", "Folder"), ("context", "Context"), ("pictures", "Pictures"),+ ("parallel", "Parallel"), ("tuning", "Tuning"), ("advanced", "Advanced"), ("access", "Access"), ("save", "Save"))+++def flow_for(ctx) -> list[str]:+ """The steps of this computer: the Cards step exists only when two or more graphics cards can be used."""+ ids = [sid for sid, _ in STEPS]+ if len(ctx.computer.usable_gpus) < 2:+ ids.remove("cards")+ return ids+++def _t(*parts: tuple[str, str] | str) -> Text:+ out = Text(no_wrap=False)+ for p in parts:+ if isinstance(p, tuple):+ out.append(p[0], style=p[1])+ else:+ out.append(p)+ return out+++class Base(Screen):+ """Shared frame: heading line, rule, content, rule, explanation, key hints, message."""++ BINDINGS = [+ Binding("escape", "back", "Back", show=False), Binding("q", "quit_app", "Quit", show=False),+ Binding("question_mark", "help", "Help", show=False), Binding("f1", "help", "Help", show=False),+ Binding("down", "move(1)", show=False), Binding("up", "move(-1)", show=False),+ Binding("pagedown", "page(1)", show=False), Binding("pageup", "page(-1)", show=False),+ Binding("enter", "next", "Next", show=False),+ ]++ step_id = ""+ title_line = "Set up"+ hints = "↑↓ choose Enter next Esc back ? help q quit"+ help_text = "Up/Down choose, Enter next, Esc back, q quit. Nothing is installed or started until the last screen."++ def __init__(self) -> None:+ super().__init__()+ self.message = ""++ # ---- frame+ @property+ def ctx(self):+ return self.app.ctx # type: ignore[attr-defined]++ @property+ def g(self):+ return self.ctx.glyphs++ def compose(self) -> ComposeResult:+ with Vertical(id="shell"):+ yield Static("", id="head", markup=False)+ yield Static("", id="rule1", markup=False)+ with Vertical(id="body"):+ yield from self.body()+ yield Static("", id="rule2", markup=False)+ yield Static("", id="explain", markup=False)+ yield Static("", id="hints", markup=False)+ yield Static("", id="message", markup=False)++ def body(self) -> ComposeResult:+ yield from ()++ def on_mount(self) -> None:+ self.paint()++ def on_resize(self, _e) -> None:+ self.paint()++ def width(self) -> int:+ return max(40, (self.size.width or 100) - 2)++ def rule(self) -> str:+ return self.g.rule * self.width()++ def head_text(self) -> Text:+ flow = flow_for(self.ctx)+ out = Text(no_wrap=True, overflow="crop")+ out.append("STRATA ", style=f"bold {ACCENT}")+ out.append(f"{self.title_line}", style=f"bold {ACCENT}")+ if self.step_id in flow:+ labels = dict(STEPS)+ n = flow.index(self.step_id)+ if self.width() >= 118:+ out.append(" ")+ for i, sid in enumerate(flow):+ mark = f"[{i + 1} {labels[sid]}]" if i == n else f"{i + 1} {labels[sid]}"+ out.append(mark + " ", style=f"bold {ACCENT}" if i == n else "")+ else:+ out.append(f" Step {n + 1} of {len(flow)}: {labels[self.step_id]}", style="")+ return out++ def paint(self) -> None:+ try:+ self.query_one("#head", Static).update(self.head_text())+ self.query_one("#rule1", Static).update(Text(self.rule(), style=MUTE))+ self.query_one("#rule2", Static).update(Text(self.rule(), style=MUTE))+ self.query_one("#explain", Static).update(self.explain())+ self.query_one("#hints", Static).update(Text(self.hints_text(), style=MUTE))+ self.query_one("#message", Static).update(Text(self.message, style=WARN if self.message.startswith("!") else MUTE))+ except Exception: # noqa: BLE001 - a screen that is closing+ return+ self.refresh_body()++ def hints_text(self) -> str:+ return self.hints.replace("↑↓", self.g.updown)++ def explain(self) -> Text:+ return Text("")++ def refresh_body(self) -> None:+ pass++ def say(self, text: str, warn: bool = False) -> None:+ self.message = ("! " if warn else "") + text+ self.paint()++ # ---- actions+ def menu(self) -> Menu | None:+ try:+ return self.query_one(Menu)+ except Exception: # noqa: BLE001+ return None++ def action_move(self, step: int) -> None:+ m = self.menu()+ if m is not None and not self.input_open():+ m.move(step)+ self.on_cursor()+ self.paint()++ def action_page(self, step: int) -> None:+ m = self.menu()+ if m is not None:+ m.page(step)+ self.on_cursor()+ self.paint()++ def on_cursor(self) -> None:+ pass++ def input_open(self) -> bool:+ return any(i.has_class("open") for i in self.query(".field"))++ def action_help(self) -> None:+ self.say(self.help_text)++ def action_quit_app(self) -> None:+ self.app.exit(None)++ def action_back(self) -> None:+ self.app.back() # type: ignore[attr-defined]++ def action_next(self) -> None:+ self.commit()+ self.app.advance() # type: ignore[attr-defined]++ def commit(self) -> None:+ pass++ # ---- text input helper+ def open_field(self, field_id: str, value: str = "", placeholder: str = "") -> None:+ f = self.query_one(f"#{field_id}", Input)+ f.disabled = False+ f.add_class("open")+ f.value = value+ f.placeholder = placeholder+ f.focus()++ def close_field(self, field_id: str) -> None:+ f = self.query_one(f"#{field_id}", Input)+ f.remove_class("open")+ f.disabled = True+ self.set_focus(None)+++# ------------------------------------------------------------------------------------------------ start++class StartScreen(Base):+ step_id = "start"+ title_line = "Launch"+ hints = "↑↓ choose Enter launch e edit preset d delete ? help q quit"+ help_text = ("Pick a saved preset to start it at once, or set up from the beginning. A preset remembers the model, "+ "context size, parallel requests, tuned settings and who can reach it.")++ BINDINGS = Base.BINDINGS + [Binding("e", "edit", "Edit", show=False), Binding("d", "delete", "Delete", show=False)]++ def body(self) -> ComposeResult:+ yield Static("", id="intro", markup=False)+ yield Menu([("", 34), ("", 14), ("", 8), ("", 14), ("", 16)], id="menu")++ def on_mount(self) -> None:+ self.reload()+ self.paint()++ def reload(self) -> None:+ self.presets = store.list_presets()+ items: list[Item] = []+ for p in self.presets:+ sm = store.summary(p)+ req = (f"{p.parallel} request" + ("s" if p.parallel != 1 else "")) if p.parallel else "fit to card"+ tuned = f"tuned {p.tuned_at[5:]}" if p.tuned_preset and p.tuned_at else "not tuned"+ used = f"last used {p.last_used[5:10]}" if p.last_used else "not used yet"+ items.append(Item([p.name or "?", str(sm["model"]), S.context_label(p.context), req, Cell(tuned, MUTE if not p.tuned_preset else ""),+ Cell(used, MUTE)], key=("preset", p.name)))+ items.append(Item([Cell("Set up from the beginning", "")], key=("new", None)))+ items.append(Item([Cell("Use model files I already have", "")], key=("own", None)))+ m = self.query_one(Menu)+ m.columns = [("", 34), ("", 14), ("", 8), ("", 14), ("", 14)]+ m.show_header = False+ m.set_items(items, 0)++ def refresh_body(self) -> None:+ intro = Text()+ if self.presets:+ intro.append("Start from a saved preset\n", style=f"bold {ACCENT}")+ else:+ intro.append("No saved presets yet\n", style=f"bold {ACCENT}")+ intro.append("A preset remembers all your choices so next time you start with one key.\n", style=MUTE)+ self.query_one("#intro", Static).update(intro)++ def explain(self) -> Text:+ c = self.ctx.computer+ return Text(f"This computer: {c.line()}. " + ("Preset: model, context, parallel requests, tuned settings, access. "+ "Shared with the Strata app." if self.presets else "Choose how to begin."), style=MUTE)++ def head_text(self) -> Text:+ out = Text(no_wrap=True, overflow="crop")+ out.append("STRATA Launch", style=f"bold {ACCENT}")+ info = self.ctx.computer.line()+ gap = max(2, self.width() - len("STRATA Launch") - len(info))+ out.append(" " * gap + info, style=MUTE)+ return out++ def action_next(self) -> None:+ it = self.query_one(Menu).current+ if it is None:+ return+ kind, name = it.key+ if kind == "preset":+ self.app.start_preset(name) # type: ignore[attr-defined]+ elif kind == "new":+ self.app.begin_setup() # type: ignore[attr-defined]+ else:+ self.app.begin_setup(own_files=True) # type: ignore[attr-defined]++ def action_edit(self) -> None:+ it = self.query_one(Menu).current+ if it and it.key[0] == "preset":+ self.app.begin_setup(preset=it.key[1]) # type: ignore[attr-defined]++ def action_delete(self) -> None:+ it = self.query_one(Menu).current+ if not it or it.key[0] != "preset":+ return+ name = it.key[1]++ def done(choice: str | None) -> None:+ if choice == "yes":+ try:+ store.delete(name)+ except store.PresetError as e:+ self.say(str(e), True)+ self.reload()+ self.say(f"Deleted '{name}'. Models and tuning results were not touched.")++ self.app.push_screen(ConfirmScreen(f"Delete the preset '{name}'?",+ "Only the saved choices go. The model files and tuning results stay.",+ [("yes", "Delete it"), ("no", "Keep it")]), done)++ def action_back(self) -> None:+ self.app.exit(None)+++# ------------------------------------------------------------------------------------------------ confirm pop-up++class ConfirmScreen(ModalScreen):+ BINDINGS = [Binding("up", "move(-1)", show=False), Binding("down", "move(1)", show=False),+ Binding("enter", "pick", show=False), Binding("escape", "cancel", show=False)]+ DEFAULT_CSS = f"""+ ConfirmScreen {{ align: center middle; background: #0e1113 80%; }}+ #dialog {{ width: 70; height: auto; background: #161a1d; border: solid {ACCENT}; padding: 1 2; }}+ """++ def __init__(self, question: str, detail: str, options: list[tuple[str, str]]):+ super().__init__()+ self.question, self.detail, self.options = question, detail, options++ def compose(self) -> ComposeResult:+ with Vertical(id="dialog"):+ yield Static(Text(self.question, style=f"bold {ACCENT}"), markup=False)+ yield Static(Text(self.detail, style=MUTE), markup=False)+ yield Static("", markup=False)+ yield Menu(id="confirm-menu")+ yield Static(Text("Up/Down choose Enter confirm Esc cancel", style=MUTE), markup=False)++ def on_mount(self) -> None:+ m = self.query_one(Menu)+ m.set_items([Item([label], key=key) for key, label in self.options], 0)++ def action_move(self, step: int) -> None:+ self.query_one(Menu).move(step)++ def action_pick(self) -> None:+ self.dismiss(self.query_one(Menu).current.key)++ def action_cancel(self) -> None:+ self.dismiss(None)+++# ------------------------------------------------------------------------------------------------ 1 model++class ModelScreen(Base):+ step_id = "model"+ hints = "↑↓ choose Enter next o use my own files Esc back ? help"+ help_text = ("Pick the model. 'Needs' is the graphics memory and RAM it uses on this computer; the n-gram table stays on "+ "your SSD and is not counted. 'Does not fit' is a warning, not a block: you can still try it.")++ BINDINGS = Base.BINDINGS + [Binding("o", "own", "Own files", show=False)]++ def body(self) -> ComposeResult:+ yield Static("", id="question", markup=False)+ yield Menu(id="menu")+ yield Input(placeholder="Folder with the model files, or one .gguf file", id="own", classes="field", disabled=True)++ def on_mount(self) -> None:+ self.rows = self.ctx.rows+ s = self.ctx.settings+ self.build_menu(initial=True)+ self.paint()+ if self.ctx.start_own_files and not s.model_path:+ self.ctx.start_own_files = False+ self.action_own()++ def widths(self) -> list[tuple[str, int]]:+ w = self.width()+ if w >= 100:+ return [("Model", 42), ("Download", 10), ("Needs (graphics + RAM)", 24), ("On this computer", 0)]+ return [("Model", 41), ("Download", 9), ("Needs (gfx + RAM)", 18), ("On this computer", 0)]++ def build_menu(self, initial: bool = False) -> None:+ s = self.ctx.settings+ if not (s.family and s.model) and not s.model_path:+ rec = next((r for r in self.rows if r.recommended), None) or next((r for r in self.rows if r.verdict == "fits"), None)+ if rec is not None:+ s.family, s.model = rec.family, rec.model+ items: list[Item] = []+ sel = 0+ for i, r in enumerate(self.rows):+ col = {"fits": "", "tight": WARN, "no": BAD}[r.verdict]+ tag = (" (recommended)" if r.recommended else "") + (" (installed)" if r.installed else "") + (" [experimental]" if r.experimental else "")+ need = f"{r.need_vram_gb:.0f} GB + {r.need_ram_gb:.0f} GB" if r.need_vram_gb or r.need_ram_gb else "-"+ items.append(Item([r.title, f"{r.download_gb:.0f} GB", need, Cell(r.words + tag, col)], key=(r.family, r.model)))+ if (s.family, s.model) == (r.family, r.model):+ sel = i+ m = self.query_one(Menu)+ m.columns = self.widths()+ m.window = max(4, (self.size.height or 30) - 12)+ m.set_items(items, sel if (initial or not m.items) else None)++ def on_resize(self, _e) -> None:+ if hasattr(self, "rows"):+ self.build_menu()+ self.paint()++ def refresh_body(self) -> None:+ q = Text()+ q.append("Which model?", style=f"bold {ACCENT}")+ s = self.ctx.settings+ if s.model_path:+ q.append(f" your files: {s.model_path}", style=MUTE)+ else:+ info = "This computer: " + self.ctx.computer.line()+ if len("Which model?") + len(info) + 3 <= self.width():+ q.append(" " * (self.width() - len("Which model?") - len(info)) + info, style=MUTE)+ self.query_one("#question", Static).update(q)++ def explain(self) -> Text:+ m = self.menu()+ cur = m.current if m else None+ out = Text()+ if cur is not None and hasattr(self, "rows"):+ r = next((x for x in self.rows if (x.family, x.model) == cur.key), None)+ if r:+ out.append(f"{r.title}: {r.about}.\n", style=FG)+ if r.verdict != "fits":+ out.append(f"{r.words}. ", style=WARN if r.verdict == "tight" else BAD)+ if r.spill_gb:+ out.append(f"About {r.spill_gb:.0f} GB would be read from the SSD while it answers. ", style=MUTE)+ out.append("The n-gram table stays on your SSD and is not counted above.", style=MUTE)+ return out++ def on_cursor(self) -> None:+ pass++ def commit(self) -> None:+ if self.input_open():+ return+ cur = self.menu().current+ if cur is not None:+ s = self.ctx.settings+ fam, model = cur.key+ if (s.family, s.model) != (fam, model) or s.model_path:+ s.model_path = None+ s.family, s.model = fam, model+ r = next(x for x in self.rows if (x.family, x.model) == (fam, model))+ if r.verdict == "no":+ self.ctx.notes.append(f"{r.title} does not fit this computer; it may be slow or run out of memory.")++ def action_next(self) -> None:+ if self.input_open():+ return+ if self.ctx.settings.model_path and not self.ctx.picked_in_list:+ self.app.advance() # type: ignore[attr-defined]+ return+ super().action_next()++ def action_move(self, step: int) -> None:+ if self.input_open():+ return+ self.ctx.picked_in_list = True+ super().action_move(step)++ # ---- own files+ def action_own(self) -> None:+ self.open_field("own", self.ctx.settings.model_path or "", "Folder with the model files, or one .gguf file")+ self.say("Type or paste the folder (or the first .gguf file), then press Enter.")++ def on_input_submitted(self, event: Input.Submitted) -> None:+ if event.input.id != "own":+ return+ path = event.value.strip().strip('"')+ if not path:+ self.close_field("own")+ return+ self.check_own(path)++ def check_own(self, path: str) -> None:+ from strata_cli.launch.runner import plain_issue+ from strata_control import models+ try:+ plan = models.plan_import(str(Path(path).expanduser().resolve()))+ except Exception as e: # noqa: BLE001+ self.say(f"These files cannot be used: {e}. Pick the folder with every shard of one model, or a .gguf file of it.", True)+ return+ sel = plan.get("candidate_selection") or {}+ if sel.get("family") and sel.get("model") and not plan.get("issues"):+ s = self.ctx.settings+ s.model_path, s.family, s.model = str(Path(path).expanduser()), sel["family"], sel["model"]+ self.ctx.picked_in_list = False+ self.close_field("own")+ gb = plan.get("total_bytes", 0) / 1e9+ self.say(f"These files are {sel['family']} {sel['model']} ({plan['file_count']} file(s), {gb:.0f} GB). Press Enter to use them.")+ self.menu().select((sel["family"], sel["model"]))+ self.paint()+ else:+ why = "; ".join(plain_issue(str(x)) for x in (plan.get("issues") or [])[:3]) or "they are not a model Strata knows"+ self.say(f"These files cannot be used as they are ({why}). Check that every shard is in the folder, or pick a model from the list.", True)++ def action_back(self) -> None:+ if self.input_open():+ self.close_field("own")+ self.say("")+ return+ super().action_back()+++# ------------------------------------------------------------------------------------------------ 2 cards (only with 2+ cards)++class CardsScreen(Base):+ step_id = "cards"+ help_text = "Strata can use several graphics cards for one model. 'Let Strata choose' is the recommendation."++ def body(self) -> ComposeResult:+ yield Static(Text("Which graphics cards should it use?", style=f"bold {ACCENT}"), markup=False)+ yield Menu(id="menu")++ def on_mount(self) -> None:+ gpus = self.ctx.computer.usable_gpus+ items = [Item([f"Let Strata choose (recommended): {len(gpus)} cards"], key=None)]+ for g in gpus:+ items.append(Item([f"Only card {g.get('index')}: {g.get('name')}, {float(g.get('vram_gb') or 0):.0f} GB"], key=[g.get("index")]))+ if len(gpus) > 2:+ pass+ items.append(Item(["All of them together, as one"], key=[g.get("index") for g in gpus]))+ sel = 0+ cur = self.ctx.settings.gpus+ for i, it in enumerate(items):+ if it.key == cur:+ sel = i+ self.query_one(Menu).set_items(items, sel)+ self.paint()++ def explain(self) -> Text:+ return Text("This computer has several graphics cards. One card is simplest; several cards share the model so bigger "+ "models fit. Strata's own choice is a good default.", style=MUTE)++ def commit(self) -> None:+ self.ctx.settings.gpus = self.menu().current.key+++# ------------------------------------------------------------------------------------------------ 3 folder++class FolderScreen(Base):+ step_id = "folder"+ hints = "Type to change the folder Enter next Esc back ? help"+ help_text = "Models are big. Pick a drive with free space. The default is where Strata keeps its data."++ BINDINGS = [b for b in Base.BINDINGS if b.key not in ("q", "up", "down")] + [Binding("down", "noop", show=False)]++ def body(self) -> ComposeResult:+ yield Static(Text("Where should the model files be stored?", style=f"bold {ACCENT}"), markup=False)+ yield Static("", id="folderinfo", markup=False)+ yield Input(id="folderpath", classes="field open")++ def on_mount(self) -> None:+ s = self.ctx.settings+ f = self.query_one("#folderpath", Input)+ f.value = s.data_dir or str(self.ctx.catalog.data_dir())+ f.focus()+ self.paint()++ def action_noop(self) -> None:+ pass++ def on_input_changed(self, event: Input.Changed) -> None:+ self.paint()++ def on_input_submitted(self, event: Input.Submitted) -> None:+ self.action_next()++ def need_gb(self) -> float:+ s = self.ctx.settings+ r = next((x for x in self.ctx.rows if (x.family, x.model) == (s.family, s.model)), None)+ if r is None:+ return 8.0+ return 8.0 + (0 if s.model_path else r.download_gb)++ def refresh_body(self) -> None:+ try:+ value = self.query_one("#folderpath", Input).value.strip()+ except Exception: # noqa: BLE001+ return+ free = self.ctx.catalog.disk_free(value or self.ctx.catalog.data_dir())+ need = self.need_gb()+ s = self.ctx.settings+ out = Text()+ if s.model_path:+ out.append(f"Your model files stay where they are: {s.model_path}\n", style=FG)+ out.append("Strata only writes its prepared data here (packs, a small draft layer).\n", style=MUTE)+ else:+ out.append(f"Needs about {need:.0f} GB (the download plus working room).", style=FG)+ out.append("\n")+ if free is not None:+ warn = free < need+ out.append(f"Free space in that folder's drive: {free:,.0f} GB", style=WARN if warn else FG)+ if warn:+ out.append(f" Not enough for {need:.0f} GB. You can still go on, but the download is likely to stop; pick a bigger drive.", style=WARN)+ else:+ out.append("The free space of that folder could not be read.", style=MUTE)+ self.query_one("#folderinfo", Static).update(out)++ def explain(self) -> Text:+ return Text("Models are large files. Strata keeps them in one folder; the default is Strata's own data folder. "+ "Press Enter to keep it, or type another folder (it is created if it does not exist).", style=MUTE)++ def commit(self) -> None:+ value = self.query_one("#folderpath", Input).value.strip().strip('"')+ default = str(self.ctx.catalog.data_dir())+ self.ctx.settings.data_dir = None if (not value or value == default) else value+++# ------------------------------------------------------------------------------------------------ 4 context++class ContextScreen(Base):+ step_id = "context"+ hints = "↑↓ choose Enter next m memory format Esc back ? help"+ help_text = ("Context is how much text the model can see at once (your chat, files, tool output). A longer one lets agents read "+ "bigger projects, uses more memory, and makes the first reply of a long chat slower.")++ BINDINGS = Base.BINDINGS + [Binding("m", "memory", "Memory format", show=False), Binding("c", "custom", "Custom", show=False)]++ def body(self) -> ComposeResult:+ yield Static(Text("How much text should it remember at once?", style=f"bold {ACCENT}"), markup=False)+ yield Menu([("", 7), ("", 24), ("", 12), ("", 0)], id="menu")+ yield Static("", id="kvline", markup=False)+ yield Input(placeholder="a size like 100k, or a number of tokens", id="custom", classes="field", disabled=True)++ def kv(self) -> str:+ s = self.ctx.settings+ return s.kv or "int8"++ def on_mount(self) -> None:+ s = self.ctx.settings+ cat = self.ctx.catalog+ fam, model = s.family, s.model+ self.rec = cat.max_context(fam, model, self.ctx.computer.raw) if fam and model else 32768+ if s.context is None:+ s.context = self.rec+ self.build()+ self.paint()++ def build(self) -> None:+ s, cat = self.ctx.settings, self.ctx.catalog+ items = []+ sel = 0+ for i, c in enumerate(cat.contexts()):+ kvgb = cat.kv_gb(c, self.kv())+ note, style = "", ""+ if c == self.rec:+ note = "recommended"+ elif c > max(self.rec * 2, 131072) and c <= 262144:+ note, style = "tight on this computer", WARN+ elif c > 262144:+ note, style = "experimental: rope scaling", WARN+ items.append(Item([S.context_label(c), S.words_for(c), f"+{kvgb:.1f} GB", Cell(note, style)], key=c))+ if c == s.context:+ sel = i+ if s.context and s.context not in cat.contexts():+ items.append(Item([S.context_label(s.context), S.words_for(s.context), f"+{cat.kv_gb(s.context, self.kv()):.1f} GB",+ Cell("your own size", "")], key=s.context))+ sel = len(items) - 1+ items.append(Item(["Custom…"], key="custom"))+ self.query_one(Menu).set_items(items, sel)++ def refresh_body(self) -> None:+ s = self.ctx.settings+ kv = self.kv()+ label = {"int8": "8-bit (recommended: what the published numbers were measured with)",+ "q4_0": "4-bit (half the memory, a little less precise on long documents)",+ "k8v4": "mixed 8-bit and 4-bit", "fp16": "full precision"}.get(kv, kv)+ small = (s.context or 0) <= 8192+ self.query_one("#kvline", Static).update(Text(+ f"Conversation memory: {label}" + ("" if not small else " (small contexts always use full precision)") + " press m to change",+ style=MUTE))++ def explain(self) -> Text:+ cur = self.menu().current if self.menu() else None+ out = Text("More context lets agents read bigger projects. It uses more memory and the first reply of a long chat is slower. "+ "The memory shown is only the extra for the conversation itself.", style=MUTE)+ if cur is not None and isinstance(cur.key, int) and cur.key > 262144:+ out.append("\nThis is past what the model was trained on; setup adds rope scaling and answers may get less reliable.", style=WARN)+ return out++ def action_memory(self) -> None:+ s = self.ctx.settings+ order = ["int8", "q4_0"]+ cur = s.kv or "int8"+ s.kv = order[(order.index(cur) + 1) % len(order)] if cur in order else "int8"+ self.build()+ self.paint()++ def action_custom(self) -> None:+ self.open_field("custom", "", "a size like 100k, or a number of tokens")+ self.say("Type a size and press Enter.")++ def on_input_submitted(self, event: Input.Submitted) -> None:+ if event.input.id != "custom":+ return+ try:+ n = S.parse_context(event.value)+ except ValueError as e:+ self.say(str(e), True)+ return+ self.ctx.settings.context = n+ self.close_field("custom")+ self.build()+ self.say(f"{S.context_label(n)} chosen.")+ self.paint()++ def action_back(self) -> None:+ if self.input_open():+ self.close_field("custom")+ return+ super().action_back()++ def commit(self) -> None:+ cur = self.menu().current+ if cur is None:+ return+ if cur.key == "custom":+ return+ self.ctx.settings.context = int(cur.key)++ def action_next(self) -> None:+ if self.input_open():+ return+ cur = self.menu().current+ if cur is not None and cur.key == "custom":+ self.action_custom()+ return+ super().action_next()+++# ------------------------------------------------------------------------------------------------ 5 pictures++class PicturesScreen(Base):+ step_id = "pictures"+ help_text = "Pictures let the model read screenshots, photos and scanned pages. It is a small extra download and a little graphics memory."++ def body(self) -> ComposeResult:+ yield Static(Text("Should the model read pictures?", style=f"bold {ACCENT}"), markup=False)+ yield Menu(id="menu")++ def row(self):+ s = self.ctx.settings+ return next((x for x in self.ctx.rows if (x.family, x.model) == (s.family, s.model)), None)++ def on_mount(self) -> None:+ s = self.ctx.settings+ r = self.row()+ self.supported = True if r is None else r.images+ items = [Item(["No pictures"], key="off")]+ if self.supported:+ items.append(Item(["Yes, read pictures"], key="on"))+ else:+ items.append(Item([Cell("Yes, read pictures: not available for this model yet", MUTE)], key="on", enabled=False))+ sel = 1 if s.vision != "off" and self.supported else 0+ self.query_one(Menu).set_items(items, sel)+ self.paint()++ def explain(self) -> Text:+ vram = self.ctx.computer.main_vram_gb+ extra = ("a 0.9 GB download. On a card under 24 GB the picture reader runs on the CPU (a few seconds per picture, nothing "+ "taken from the graphics card). On a bigger card it runs on the GPU and keeps about 1.4 GB free, costing a few % of text speed."+ if vram < 24 else "a 0.9 GB download, and about 1.4 GB of graphics memory kept free for the picture reader (text is a few % slower).")+ if not self.supported:+ return Text("This model cannot read pictures yet, so pictures stay off. Pick another model if you need them.", style=WARN)+ return Text("Pictures add " + extra + " Say No if you only chat in text.", style=MUTE)++ def commit(self) -> None:+ self.ctx.settings.vision = self.menu().current.key+++# ------------------------------------------------------------------------------------------------ 6 parallel++class ParallelScreen(Base):+ step_id = "parallel"+ help_text = ("Parallel requests: how many people or apps are answered at the same time. More at once makes each answer a bit slower "+ "and needs graphics memory the model could use otherwise.")++ def body(self) -> ComposeResult:+ yield Static(Text("How many requests at the same time?", style=f"bold {ACCENT}"), markup=False)+ yield Menu(id="menu")++ def on_mount(self) -> None:+ vram = self.ctx.computer.main_vram_gb+ self.fit = S.fit_parallel(vram) if vram else 1+ s = self.ctx.settings+ items = [Item([f"Fit to my graphics card ({self.fit})", Cell("recommended", "")], key=None)]+ for n in (1, 2, 3, 4):+ note, style = "", ""+ if n > self.fit:+ note, style = "may not fit: slower answers", WARN+ items.append(Item([f"{n} request" + ("s" if n != 1 else ""), Cell(note, style)], key=n))+ sel = 0 if s.parallel is None else min(4, max(1, s.parallel))+ self.query_one(Menu).columns = [("", 36), ("", 0)]+ self.query_one(Menu).set_items(items, sel)+ self.paint()++ def explain(self) -> Text:+ vram = self.ctx.computer.main_vram_gb+ return Text(f"Your card has {vram:.0f} GB of graphics memory, which fits {self.fit} at once by Strata's rule "+ "(12 GB: 1, 20 GB: 2, 24 GB: 3, 32 GB or more: 4). One person: pick 1. A team or several coding agents: more. "+ "More than fits still starts, only slower." if vram else+ "No graphics card was found, so Strata cannot say how many fit. 1 is the safe choice.", style=MUTE)++ def commit(self) -> None:+ self.ctx.settings.parallel = self.menu().current.key+++# ------------------------------------------------------------------------------------------------ 7 tuning++class TuningScreen(Base):+ step_id = "tuning"+ hints = "↑↓ choose Enter next a answer-changing settings on/off Esc back ? help"+ help_text = ("Tuning measures a few settings on this computer and keeps only real gains. It runs after the model is downloaded, "+ "before serving starts. You can stop it at any time: nothing changes until it is done.")++ BINDINGS = Base.BINDINGS + [Binding("a", "allow", "Allow", show=False)]++ def body(self) -> ComposeResult:+ yield Static(Text("Tune for the best speed on this computer?", style=f"bold {ACCENT}"), markup=False)+ yield Menu([("", 12), ("", 22), ("", 0)], id="menu")+ yield Static("", id="allowline", markup=False)++ def on_mount(self) -> None:+ s = self.ctx.settings+ items = [Item(["Quick", "about 20 minutes", "checks the most likely gains"], key="quick"),+ Item(["Thorough", "up to 2 hours", "tries more settings, measures each one several times"], key="thorough"),+ Item(["Skip", "", "use the default settings (already good on most computers)"], key="skip")]+ if not self.ctx.tune_chosen and s.tune == "skip" and not s.tuned_preset and self.ctx.fresh_setup:+ s.tune = "quick"+ self.query_one(Menu).set_items(items, {"quick": 0, "thorough": 1, "skip": 2}.get(s.tune, 0))+ self.paint()++ def refresh_body(self) -> None:+ on = self.ctx.settings.tune_allow_small+ self.query_one("#allowline", Static).update(Text(+ f"\n [{'x' if on else ' '}] Allow settings that change answers very slightly (same quality) press a to change", style=MUTE))++ def explain(self) -> Text:+ return Text("Tuning is optional. It tries single changes against your settings, keeps only gains above the noise, and saves the "+ "result as a preset the Strata app can use too. Close other heavy programs while it measures. If your computer is "+ "already at its best it says so and changes nothing.", style=MUTE)++ def action_allow(self) -> None:+ self.ctx.settings.tune_allow_small = not self.ctx.settings.tune_allow_small+ self.paint()++ def commit(self) -> None:+ self.ctx.settings.tune = self.menu().current.key+ self.ctx.tune_chosen = True+++# ------------------------------------------------------------------------------------------------ 8 advanced++class AdvancedScreen(Base):+ step_id = "advanced"+ hints = "↑↓ choose Enter edit Del reset x experimental / filter a add by name c copy command n next Esc back"+ help_text = ("Every engine setting with its default, the value the tuner chose and your own value. You never have to touch this. "+ "A name the engine does not list gets a warning, not a refusal.")++ BINDINGS = [b for b in Base.BINDINGS if b.key != "enter"] + [+ Binding("enter", "edit", show=False), Binding("delete", "reset", show=False), Binding("backspace", "reset", show=False),+ Binding("x", "experimental", show=False), Binding("slash", "filter", show=False), Binding("a", "add", show=False),+ Binding("c", "copy", show=False), Binding("n", "go_next", show=False), Binding("right", "go_next", show=False)]++ def body(self) -> ComposeResult:+ yield Static("", id="advhead", markup=False)+ yield Menu([("Setting", 28), ("Default", 13), ("Tuned", 15), ("Yours", 13), ("What it does", 0)], id="menu", window=8)+ yield Static("", id="cmdline", markup=False)+ yield Input(id="edit", classes="field", disabled=True)++ def on_mount(self) -> None:+ self.only_experimental = False+ self.filter = ""+ self.mode = "" # "", "edit", "filter", "add"+ self.rows: list[P.Row] = []+ self.load_rows()+ self.paint()++ def load_rows(self) -> None:+ self.rows = self.ctx.advanced_rows()+ self.build()++ def build(self) -> None:+ items = []+ for r in self.rows:+ if self.only_experimental and not r.experimental:+ continue+ if self.filter and self.filter.lower() not in r.name.lower() and self.filter.lower() not in r.description.lower():+ continue+ d, t, y = r.cells()[1:]+ desc = r.description + (" [experimental]" if r.experimental else "")+ items.append(Item([r.name, d, t, Cell(y, ACCENT if y != "-" else ""), Cell(desc, WARN if r.experimental else (BAD if not r.known else ""))],+ key=r.name))+ items.append(Item([Cell("+ Add a setting by name…", ""), "", "", "", Cell("for flags of newer engine versions", MUTE)], key="__add__"))+ m = self.query_one(Menu)+ m.window = max(4, (self.size.height or 30) - 15)+ m.set_items(items, min(m.index, len(items) - 1))++ def on_resize(self, _e) -> None:+ if hasattr(self, "rows"):+ self.build()+ self.paint()++ def refresh_body(self) -> None:+ eng = self.ctx.engine_note+ t = Text()+ t.append("All settings", style=f"bold {ACCENT}")+ t.append(" (optional · for tinkerers)", style=MUTE)+ extra = " / filter" + (f": {self.filter}" if self.filter else "") + " x show experimental only" + (" (on)" if self.only_experimental else "")+ t.append(extra, style=MUTE)+ self.query_one("#advhead", Static).update(t)+ s = self.ctx.settings+ cmd = self.ctx.command_text()+ out = Text()+ out.append("Command that will run\n", style=f"bold {ACCENT}")+ out.append(" " + cmd + "\n")+ out.append(" Same as: " + S.flags_text(s) + "\n", style=MUTE)+ if eng:+ out.append(" " + eng, style=WARN)+ self.query_one("#cmdline", Static).update(out)++ def explain(self) -> Text:+ m = self.menu()+ cur = m.current if m else None+ if cur is not None and cur.key not in (None, "__add__"):+ r = next((x for x in self.rows if x.name == cur.key), None)+ if r:+ return Text(f"{r.name}: {r.description}" + (" This one is experimental: it may change answers or not work on every card." if r.experimental else ""), style=MUTE)+ return Text("Press Enter on a row to set your own value; Del puts the tuned value back. You can go on without touching anything: n.", style=MUTE)++ # ---- editing+ def action_edit(self) -> None:+ if self.mode:+ return+ cur = self.menu().current+ if cur is None:+ return+ if cur.key == "__add__":+ return self.action_add()+ self.mode = "edit"+ self.edit_name = cur.key+ r = next(x for x in self.rows if x.name == cur.key)+ self.open_field("edit", r.yours or (r.tuned if r.tuned != "-" else r.default) or "", f"value for {cur.key} (empty = on, 'off' removes it)")+ self.say(f"Type the value for {cur.key} and press Enter. Esc cancels.")++ def action_add(self) -> None:+ if self.mode:+ return+ self.mode = "add"+ self.open_field("edit", "", "name=value, e.g. prefill=65536 or STRATA_PIN_BY_NEED=1")+ self.say("Type the setting as name=value (the name of a newer engine's flag is fine).")++ def action_filter(self) -> None:+ if self.mode:+ return+ self.mode = "filter"+ self.open_field("edit", self.filter, "part of a name or description")++ def on_input_submitted(self, event: Input.Submitted) -> None:+ if event.input.id != "edit":+ return+ text = event.value.strip()+ mode = self.mode+ self.mode = ""+ self.close_field("edit")+ if mode == "filter":+ self.filter = text+ elif mode == "edit":+ self.set_value(self.edit_name, text)+ elif mode == "add" and text:+ try:+ key, value = S.split_setting(text)+ except ValueError as e:+ self.say(str(e), True)+ return+ self.set_value(key, value)+ self.build()+ self.paint()++ def set_value(self, key: str, value: str) -> None:+ s = self.ctx.settings+ s.extra[key] = value+ warn = P.check_name(key, self.ctx.engine_flags)+ self.ctx.invalidate_rows()+ self.rows = self.ctx.advanced_rows()+ self.say(warn or f"{key} set to {value or 'on'}. It is used for this launch.", bool(warn))++ def action_reset(self) -> None:+ if self.mode:+ return+ cur = self.menu().current+ if cur is None or cur.key in (None, "__add__"):+ return+ if self.ctx.settings.extra.pop(cur.key, None) is not None:+ self.ctx.invalidate_rows()+ self.rows = self.ctx.advanced_rows()+ self.build()+ self.say(f"{cur.key} is back to the tuned value.")+ self.paint()++ def action_experimental(self) -> None:+ if self.mode:+ return+ self.only_experimental = not self.only_experimental+ self.build()+ self.paint()++ def action_copy(self) -> None:+ if self.mode:+ return+ text = self.ctx.command_text() + "\n" + S.flags_text(self.ctx.settings)+ try:+ self.app.copy_to_clipboard(text)+ self.say("Copied the command to the clipboard (if your terminal allows it).")+ except Exception: # noqa: BLE001+ self.say("Your terminal does not allow copying; select the lines above with the mouse.", True)++ def action_go_next(self) -> None:+ if self.mode:+ return+ self.app.advance() # type: ignore[attr-defined]++ def action_next(self) -> None:+ self.action_edit()++ def action_back(self) -> None:+ if self.mode:+ self.mode = ""+ self.close_field("edit")+ self.say("")+ return+ super().action_back()++ def action_move(self, step: int) -> None:+ if self.mode:+ return+ super().action_move(step)+++# ------------------------------------------------------------------------------------------------ 9 access++class AccessScreen(Base):+ step_id = "access"+ hints = "↑↓ choose Enter next p port k new key t key on/off Esc back ? help"+ help_text = ("Who can use the model. 'This computer only' is the safe default. Anything beyond it needs the API key: the server will not "+ "start on a network without one.")++ BINDINGS = Base.BINDINGS + [Binding("p", "port", show=False), Binding("k", "newkey", show=False), Binding("t", "keytoggle", show=False)]++ def body(self) -> ComposeResult:+ yield Static(Text("Who can use it?", style=f"bold {ACCENT}"), markup=False)+ yield Menu([("", 22), ("", 46), ("", 0)], id="menu")+ yield Static("", id="portkey", markup=False)+ yield Input(id="portfield", classes="field", disabled=True)++ def on_mount(self) -> None:+ self.build()+ self.paint()++ def build(self) -> None:+ s = self.ctx.settings+ opts = acc.options(s.port)+ items = []+ sel = 0+ for i, o in enumerate(opts):+ note = o.note+ style = WARN if o.warn else ""+ items.append(Item([o.label, o.url, Cell(note, style)], key=o.kind))+ if o.kind == s.access:+ sel = i+ self.opts = {o.kind: o for o in opts}+ self.query_one(Menu).set_items(items, sel)++ def refresh_body(self) -> None:+ s = self.ctx.settings+ on = bool(s.api_key)+ beyond = s.access != "local"+ t = Text()+ t.append(f"\n Port [ {s.port} ] press p to change\n")+ t.append(f" API key [ {'on' if on else 'off'} ] {acc.mask_key(s.api_key)} ", style=FG if on else WARN)+ t.append("(recommended for anything beyond this computer)" if beyond else "(optional on this computer)", style=MUTE)+ self.query_one("#portkey", Static).update(t)++ def explain(self) -> Text:+ cur = self.menu().current if self.menu() else None+ out = Text()+ if cur is not None:+ missing = acc.missing_helper(cur.key)+ if missing:+ out.append(missing + "\n", style=WARN)+ if cur.key == "cloudflare":+ out.append("A Cloudflare quick tunnel gives a temporary public address; anyone with it can try to use the server, so keep the API key on.", style=MUTE)+ elif cur.key == "lan":+ out.append("Other computers on your network can use it at the address shown. Keep the API key on.", style=MUTE)+ elif cur.key == "tailscale":+ out.append("Only devices signed in to your Tailscale network can reach it.", style=MUTE)+ else:+ out.append("Only programs on this computer can reach it, so no key is needed.", style=MUTE)+ return out++ def on_cursor(self) -> None:+ kind = self.menu().current.key+ s = self.ctx.settings+ s.access = kind+ if kind != "local" and not s.api_key:+ s.api_key = acc.new_key()+ self.say("An API key was made for you, because this reaches beyond your computer.")++ def action_port(self) -> None:+ self.open_field("portfield", str(self.ctx.settings.port), "port number")+ self.say("Type a port from 1 to 65535 and press Enter.")++ def on_input_submitted(self, event: Input.Submitted) -> None:+ if event.input.id != "portfield":+ return+ n = S.check_port(event.value.strip())+ if n and n.level == "error":+ self.say(n.line(), True)+ return+ self.ctx.settings.port = int(event.value.strip())+ self.close_field("portfield")+ self.build()+ self.say(n.line() if n else f"Port {self.ctx.settings.port}.", bool(n))+ self.paint()++ def action_newkey(self) -> None:+ self.ctx.settings.api_key = acc.new_key()+ self.say("A new API key was made. Apps that used the old one need the new one (strata connect shows it).")+ self.paint()++ def action_keytoggle(self) -> None:+ s = self.ctx.settings+ if s.api_key:+ s.api_key = None+ self.say("The API key is off." + (" The server will not start on a network without one." if s.access != "local" else ""), s.access != "local")+ else:+ s.api_key = acc.new_key()+ self.say("The API key is on.")+ self.paint()++ def action_next(self) -> None:+ if self.input_open():+ return+ self.commit()+ self.app.advance() # type: ignore[attr-defined]++ def commit(self) -> None:+ s = self.ctx.settings+ s.access = self.menu().current.key+ if s.access != "local" and not s.api_key:+ s.api_key = acc.new_key()++ def action_back(self) -> None:+ if self.input_open():+ self.close_field("portfield")+ return+ super().action_back()+++# ------------------------------------------------------------------------------------------------ 10 save + launch++class SaveScreen(Base):+ step_id = "save"+ hints = "↑↓ choose Enter do it Esc back ? help"+ help_text = "Save remembers all your choices under a name so next time you start with one key. Launch downloads what is missing, tunes if you asked, and starts serving."++ def body(self) -> ComposeResult:+ yield Static("", id="summary", markup=False)+ yield Input(id="name", classes="field open")+ yield Menu(id="menu")++ def on_mount(self) -> None:+ s = self.ctx.settings+ f = self.query_one("#name", Input)+ f.value = s.name or self.ctx.default_name()+ items = [Item(["Save as a preset and launch"], key="save_launch"), Item(["Launch without saving"], key="launch"),+ Item(["Save the preset and stop here"], key="save")]+ self.query_one(Menu).set_items(items, 0)+ self.paint()++ def refresh_body(self) -> None:+ s = self.ctx.settings+ r = next((x for x in self.ctx.rows if (x.family, x.model) == (s.family, s.model)), None)+ t = Text()+ t.append("Save as preset, then launch\n", style=f"bold {ACCENT}")+ t.append(" Name ")+ t.append("(type below)\n", style=MUTE)+ lines = [("Model", (r.title if r else (s.model or "?")) + (" (your files)" if s.model_path else "")),+ ("Context", S.context_label(s.context) + f", memory {s.kv or 'int8'}"),+ ("Pictures", "on" if s.vision != "off" else "off"),+ ("Parallel", f"{s.parallel} at a time" if s.parallel else f"fit to your card ({S.fit_parallel(self.ctx.computer.main_vram_gb)})"),+ ("Tuning", {"quick": "quick (about 20 min)", "thorough": "thorough (up to 2 h)", "skip": "skipped"}[s.tune]),+ ("Access", f"{S.ACCESS_WORDS[s.access]}, port {s.port}" + (", API key on" if s.api_key else ", no API key")),+ ("Storage", s.data_dir or "Strata's data folder")]+ if s.extra:+ lines.append(("Advanced", ", ".join(f"{k}={v}" for k, v in s.extra.items())))+ for k, v in lines:+ t.append(f" {k:<10}{v}\n")+ for n in self.ctx.warnings():+ t.append(f" ! {n}\n", style=WARN)+ self.query_one("#summary", Static).update(t)++ def explain(self) -> Text:+ return Text("Press Enter on the first choice to save and start. The first start may download the model and tune; the monitor opens when it is serving.", style=MUTE)++ def action_move(self, step: int) -> None:+ super().action_move(step)++ def action_next(self) -> None:+ name = self.query_one("#name", Input).value.strip() or self.ctx.default_name()+ choice = self.menu().current.key+ s = self.ctx.settings+ s.name = name+ if choice in ("save", "save_launch"):+ try:+ store.save(s, name)+ except store.PresetError as e:+ self.say(str(e), True)+ return+ if choice == "save":+ self.app.exit(None)+ self.app.stopped_after_save = True # type: ignore[attr-defined]+ return+ self.app.run_launch() # type: ignore[attr-defined]++ def action_quit_app(self) -> None:+ pass+++# ------------------------------------------------------------------------------------------------ progress++class RunScreen(Base):+ step_id = "run"+ title_line = "Launch"+ hints = "s stop q quit"+ BINDINGS = [Binding("s", "stop_run", show=False), Binding("q", "stop_run", show=False), Binding("escape", "stop_run", show=False),+ Binding("r", "retry", show=False)]++ STAGE_WORDS = (("engine", "Engine"), ("model", "Model"), ("config", "Settings"), ("tune", "Tuning"), ("start", "Starting"),+ ("access", "Access"))++ def body(self) -> ComposeResult:+ yield Static("", id="stages", markup=False)+ yield Static("", id="tunepanel", markup=False)++ def on_mount(self) -> None:+ self.state: dict[str, dict] = {k: {"text": "", "pct": None, "status": "wait"} for k, _ in self.STAGE_WORDS}+ self.failed: str | None = None+ self.tune_info: dict = {}+ self.paint()++ def head_text(self) -> Text:+ out = Text(no_wrap=True, overflow="crop")+ out.append("STRATA Launch", style=f"bold {ACCENT}")+ s = self.ctx.settings+ out.append(f" {s.name or ''}", style=MUTE)+ return out++ def on_event(self, ev) -> None:+ if ev.stage == "done":+ return+ st = self.state.get(ev.stage)+ if st is None:+ return+ for k, _ in self.STAGE_WORDS: # earlier stages are finished+ if k == ev.stage:+ break+ if self.state[k]["status"] in ("wait", "run"):+ self.state[k]["status"] = "done" if self.state[k]["text"] else "skip"+ st["text"] = ev.text+ st["pct"] = ev.pct+ st["level"] = ev.level+ st["status"] = "done" if (ev.pct is not None and ev.pct >= 100) else "run"+ if ev.stage == "tune":+ self.tune_info = ev.data or {}+ self.paint()++ def on_failure(self, text: str) -> None:+ self.failed = text+ self.paint()++ def on_finished(self) -> None:+ for k, st in self.state.items():+ if st["status"] in ("wait", "run"):+ st["status"] = "done" if st["text"] else "skip"+ self.paint()++ def refresh_body(self) -> None:+ t = Text()+ g = self.g+ width = max(20, min(40, self.width() - 50))+ for k, label in self.STAGE_WORDS:+ st = self.state.get(k) if hasattr(self, "state") else None+ if st is None:+ continue+ mark = {"wait": " ", "run": "> ", "done": g.tick + " ", "skip": "- "}[st["status"]]+ style = ACCENT if st["status"] in ("run", "done") else MUTE+ if st.get("level") == "warn" and st["status"] != "run":+ style = WARN+ t.append(f" {mark}{label:<10}", style=f"bold {style}")+ if st["pct"] is not None and st["status"] == "run":+ t.append(bar(st["pct"] / 100.0, width, g) + f" {st['pct']:.0f}% ", style=ACCENT)+ t.append((st["text"] or "") + "\n", style=FG if st["status"] == "run" else MUTE)+ if self.failed:+ t.append("\n " + self.failed + "\n", style=BAD)+ t.append(" Press r to try again, Esc to go back to the screens, q to quit.\n", style=MUTE)+ try:+ self.query_one("#stages", Static).update(t)+ self.query_one("#tunepanel", Static).update(self.tune_panel())+ except Exception: # noqa: BLE001+ pass++ def tune_panel(self) -> Text:+ t = Text()+ info = self.tune_info+ if not info or self.state["tune"]["status"] == "wait":+ return t+ t.append("\n Tuning", style=f"bold {ACCENT}")+ rnd = info.get("round")+ if rnd and rnd[1]:+ t.append(f" measurement {rnd[0]} of {rnd[1]}")+ if info.get("minutes_left"):+ t.append(f" about {info['minutes_left']} min left")+ t.append("\n")+ for sp in (info.get("speeds") or [])[-6:]:+ label = sp.get("label") or sp.get("id") or "?"+ val = sp.get("decode_tok_s") or sp.get("value") or sp.get("tok_s")+ t.append(f" {str(label)[:34]:<36}{val if val is not None else '-'}" + (" tokens/s" if val is not None else "") + "\n")+ t.append(" Close other heavy programs while it measures. You can stop it any time: nothing changes until it is done.\n", style=MUTE)+ return t++ def explain(self) -> Text:+ return Text("Strata is getting everything ready. This can take a while the first time (the model is large). "+ "Stopping is safe: files already downloaded are kept and a download continues where it stopped.", style=MUTE)++ def action_stop_run(self) -> None:+ self.app.stop_run(self) # type: ignore[attr-defined]++ def action_retry(self) -> None:+ if self.failed:+ self.app.run_launch() # type: ignore[attr-defined]++ def action_move(self, step: int) -> None:+ pass++ def action_next(self) -> None:+ passdiff --git a/strata_cli/launch/settings.py b/strata_cli/launch/settings.pyindex b15faf9ba..03183029f 100644--- a/strata_cli/launch/settings.py+++ b/strata_cli/launch/settings.py@@ -276,7 +276,7 @@ def flags_text(s: LaunchSettings, *, preset: str | None = None) -> str:def slug(name: str) -> str:"""A name safe for profile ids and file names: lowercase letters, digits, - and _, starting with a letter."""- text = re.sub(r"[^a-z0-9_-]+", "-", name.lower()).strip("-_") or "launch"+ text = re.sub(r"-{2,}", "-", re.sub(r"[^a-z0-9_-]+", "-", name.lower())).strip("-_") or "launch"if not text[0].isalpha():text = "l" + textreturn text[:48]diff --git a/strata_cli/launch/store.py b/strata_cli/launch/store.pyindex 4ce704557..21b432984 100644--- a/strata_cli/launch/store.py+++ b/strata_cli/launch/store.py@@ -60,7 +60,8 @@ def _private_write(path: Path, payload: bytes) -> None:def now_text() -> str:- return time.strftime("%Y-%m-%d %H:%M")+ now = time.time()+ return time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(now)) + f".{int((now % 1) * 1000000):06d}"def save(settings: LaunchSettings, name: str | None = None) -> LaunchSettings:diff --git a/strata_cli/launch/widgets.py b/strata_cli/launch/widgets.pyindex 28cc190d2..a26367347 100644--- a/strata_cli/launch/widgets.py+++ b/strata_cli/launch/widgets.py@@ -83,7 +83,7 @@ def cell(c: Cell | str) -> Cell:class Menu(Static):"""A column list with a cursor: `items` is a list of `Item`, `columns` a list of (title, width) (width 0 = the rest)."""- DEFAULT_CSS = "Menu { height: auto; }"+ DEFAULT_CSS = "Menu { height: auto; text-wrap: nowrap; text-overflow: clip; }"def __init__(self, columns: list[tuple[str, int]] | None = None, *, glyphs: Glyphs | None = None, id: str | None = None,window: int = 0) -> None:diff --git a/tests/terminal/launch_support.py b/tests/terminal/launch_support.pynew file mode 100644index 000000000..a693c9c4a--- /dev/null+++ b/tests/terminal/launch_support.py@@ -0,0 +1,70 @@+"""Shared fixtures for the `strata launch` tests: an isolated home, a fake computer, and a text dump of a Textual screen."""++from __future__ import annotations++import contextlib+import io+import os+import tempfile+from pathlib import Path+from unittest import mock++HW_12 = {"ram_gb": 64.0, "os": "Test OS", "cpu": {"avx2": True, "name": "test cpu"},+ "gpus": [{"index": 0, "name": "NVIDIA GeForce RTX 5070", "vram_gb": 12.0, "usable": True, "vendor": "nvidia"}]}+HW_24 = {**HW_12, "gpus": [{"index": 0, "name": "NVIDIA GeForce RTX 4090", "vram_gb": 24.0, "usable": True, "vendor": "nvidia"}]}+HW_2X16 = {**HW_12, "gpus": [{"index": 0, "name": "NVIDIA RTX A4000", "vram_gb": 16.0, "usable": True, "vendor": "nvidia"},+ {"index": 1, "name": "NVIDIA RTX A4000", "vram_gb": 16.0, "usable": True, "vendor": "nvidia"}]}+HW_32GB_RAM = {**HW_12, "ram_gb": 32.0}+++class Home:+ """A throw-away per-user home: profiles, presets, launch presets, state, components and install folder."""++ def __init__(self) -> None:+ self.tmp = tempfile.TemporaryDirectory(prefix="strata-launch-test-")+ base = Path(self.tmp.name)+ self.base = base+ self.env = {+ "STRATA_PROFILE_DIR": str(base / "config" / "profiles"),+ "STRATA_PRESET_DIR": str(base / "config" / "presets"),+ "STRATA_LAUNCH_PRESET_DIR": str(base / "config" / "launch-presets"),+ "STRATA_COMPONENTS_DIR": str(base / "components"),+ "STRATA_INSTALL_DIR": str(base / "install"),+ "STRATA_RUNTIME_DIR": str(base / "runtime"),+ "XDG_STATE_HOME": str(base / "state"),+ "LOCALAPPDATA": str(base / "local"),+ "HOME": str(base / "home"),+ "USERPROFILE": str(base / "home"),+ }+ (base / "home").mkdir(parents=True, exist_ok=True)+ self.patch = mock.patch.dict(os.environ, self.env)++ def __enter__(self) -> "Home":+ self.patch.start()+ return self++ def __exit__(self, *exc) -> None:+ self.patch.stop()+ self.tmp.cleanup()+++def catalog(hw: dict | None = None, root: Path | None = None):+ from strata_cli.launch.catalog import Catalog+ return Catalog(root=root or Path(os.environ["STRATA_INSTALL_DIR"]), hardware=hw or HW_12)+++def text_of(app) -> str:+ """What the current screen shows, one line per terminal row (for assertions and the text previews)."""+ strips = app.screen._compositor.render_strips()+ return "\n".join(s.text.rstrip() for s in strips)+++def run_cli(argv: list[str]) -> tuple[int, str, str]:+ from strata_cli.cli import main+ out, err = io.StringIO(), io.StringIO()+ with contextlib.redirect_stdout(out), contextlib.redirect_stderr(err):+ try:+ code = main(argv)+ except SystemExit as e:+ code = int(e.code or 0)+ return code, out.getvalue(), err.getvalue()diff --git a/tests/terminal/test_launch.py b/tests/terminal/test_launch.pynew file mode 100644index 000000000..d34c7f558--- /dev/null+++ b/tests/terminal/test_launch.py@@ -0,0 +1,558 @@+"""`strata launch` without screens: the settings rules, the catalog, presets, parameters, access, connect, and every flag."""++from __future__ import annotations++import json+import os+import unittest+from pathlib import Path+from unittest import mock++from strata_cli.launch import access, harness, params, settings as S, store+from strata_cli.launch.catalog import Catalog, CatalogUnavailable, fit_on, verdict+from strata_cli.launch.runner import Result, Runner, derive_config, desc_matches, tune_words+from tests.terminal.launch_support import HW_12, HW_24, HW_2X16, Home, catalog, run_cli+++class SettingsRules(unittest.TestCase):+ def test_parse_context(self):+ self.assertEqual(S.parse_context("128k"), 131072)+ self.assertEqual(S.parse_context("128K"), 131072)+ self.assertEqual(S.parse_context("32 k"), 32768)+ self.assertEqual(S.parse_context("65536"), 65536)+ with self.assertRaises(ValueError):+ S.parse_context("lots")+ with self.assertRaises(ValueError):+ S.parse_context("100")++ def test_fit_parallel_follows_the_spec(self):+ self.assertEqual([S.fit_parallel(v) for v in (8, 12, 16, 20, 24, 32, 48)], [1, 1, 1, 2, 3, 4, 4])+ self.assertEqual(S.fit_parallel(None), 1)++ def test_words_and_labels(self):+ self.assertEqual(S.context_label(131072), "128K")+ self.assertEqual(S.words_for(131072), "about 98,000 words")++ def test_parallel_warning_is_a_warning_not_an_error(self):+ notes = S.check_parallel(S.LaunchSettings(parallel=4), vram_gb=12)+ self.assertEqual([n.level for n in notes], ["warn"])+ self.assertIn("still start", notes[0].line())+ self.assertEqual(S.check_parallel(S.LaunchSettings(parallel=9), vram_gb=12)[0].level, "error")+ self.assertEqual(S.check_parallel(S.LaunchSettings(parallel=2), vram_gb=24), [])++ def test_access_notes(self):+ self.assertEqual(S.check_access(S.LaunchSettings(access="local")), [])+ lan = S.check_access(S.LaunchSettings(access="lan"))+ self.assertEqual([n.level for n in lan], ["warn"])+ self.assertIn("API key", lan[0].line())+ bad = S.check_access(S.LaunchSettings(access="lann"))+ self.assertEqual(bad[0].level, "error")+ self.assertIn("lan", bad[0].line())+ self.assertEqual(S.check_port("abc").level, "error")+ self.assertEqual(S.check_port(70000).level, "error")+ self.assertEqual(S.check_port(80).level, "warn")+ self.assertIsNone(S.check_port(8080))++ def test_split_setting(self):+ self.assertEqual(S.split_setting("prefill=65536"), ("--prefill", "65536"))+ self.assertEqual(S.split_setting("--kv-grow"), ("--kv-grow", ""))+ self.assertEqual(S.split_setting("STRATA_PIN_BY_NEED=1"), ("STRATA_PIN_BY_NEED", "1"))+ self.assertEqual(S.split_setting("expert_cache=auto"), ("--expert-cache", "auto"))+ with self.assertRaises(ValueError):+ S.split_setting("no spaces allowed=1")++ def test_flags_text_round_trips_to_the_same_choices(self):+ s = S.LaunchSettings(family="qwen", model="IQ3_XXS", context=131072, parallel=2, tune="quick", access="lan", port=9000,+ extra={"--prefill": "65536", "STRATA_PIN_BY_NEED": "1"})+ text = S.flags_text(s)+ for part in ("--model iq3_xxs", "--context 128k", "--parallel 2", "--tune quick", "--access lan", "--port 9000",+ "--set prefill=65536", "--set STRATA_PIN_BY_NEED=1"):+ self.assertIn(part, text)+ self.assertIn('--preset "Fast"', S.flags_text(s, preset="Fast"))++ def test_slug(self):+ self.assertEqual(S.slug("IQ3_XXS 128K - Full speed"), "iq3_xxs-128k-full-speed")+ self.assertTrue(S.slug("123 go")[0].isalpha())++ def test_roundtrip_dict(self):+ s = S.LaunchSettings(name="a", model="Q2_0", family="qwen", context=32768, extra={"--spec": "3"}, tuned_preset="abc")+ again = S.LaunchSettings.from_dict(json.loads(json.dumps(s.to_dict())))+ self.assertEqual(again, s)+ self.assertEqual(s.to_dict(with_key=False)["api_key"], None)+ self.assertEqual(S.LaunchSettings(api_key="sk-x").to_dict(with_key=False)["api_key"], "set")+++class CatalogRules(unittest.TestCase):+ def test_one_source_of_truth_and_fit_numbers(self):+ with Home():+ cat = catalog(HW_12)+ rows = cat.rows()+ ids = {(r.family, r.model) for r in rows}+ self.assertIn(("qwen", "IQ3_XXS"), ids)+ models, families, contexts, source = cat.tables()+ self.assertEqual(source, "setup.py") # the same tables setup.py and the app read+ for r in rows:+ self.assertAlmostEqual(r.download_gb, models[r.model]["download_gb"])+ rec = [r for r in rows if r.recommended]+ self.assertEqual([(r.family, r.model) for r in rec], [("qwen", "IQ3_XXS")])++ def test_fit_on_matches_native_fit_ts(self):+ # apps/host/src/lib/native-fit.ts: memory = experts + 1; GPU holds experts up to vram - 5; RAM holds up to ram - 10; the rest spills+ f = fit_on({"experts_gb": 42.9, "ram_needed_gb": 60}, 64.0, 12.0)+ self.assertEqual((f["memoryGb"], f["vramUseGb"], f["spillGb"]), (43.9, 12.0, 0.0))+ self.assertAlmostEqual(f["ramUseGb"], 35.9, places=1)+ spill = fit_on({"experts_gb": 98.4, "ram_needed_gb": 108}, 64.0, 12.0)+ self.assertGreater(spill["spillGb"], 30)+ self.assertFalse(fit_on({"experts_gb": 10}, None, 12)["known"])+ gyro = fit_on({"mem_total": True, "ram_needed_gb": 27.6}, 64, 12)+ self.assertEqual(gyro["memoryGb"], 27.6)++ def test_verdict_words_never_block(self):+ self.assertEqual(verdict("fits")[0], "fits")+ self.assertEqual(verdict("does not fit")[0], "no")+ self.assertIn("can still try", verdict("does not fit")[1])+ self.assertEqual(verdict("tight")[0], "tight")+ self.assertEqual(verdict("fits in the low-RAM mode (slower)")[0], "fits")++ def test_resolve_names_and_closest(self):+ with Home():+ cat = catalog()+ self.assertEqual(cat.resolve("iq3_xxs"), ("qwen", "IQ3_XXS"))+ self.assertEqual(cat.resolve("IQ1_M"), ("coder", "IQ1_M"))+ self.assertEqual(cat.resolve("iq3_xxs", "swift"), ("swift", "IQ3_XXS"))+ with self.assertRaises(ValueError) as e:+ cat.resolve("iq3xxs")+ self.assertIn("Did you mean 'IQ3_XXS'", str(e.exception))+ with self.assertRaises(ValueError) as e:+ cat.resolve("q2_0", "swiift")+ self.assertIn("swift", str(e.exception))+ with self.assertRaises(ValueError) as e:+ cat.resolve("IQ1_M", "swift")+ self.assertIn("has no size", str(e.exception))++ def test_small_computer_gets_warnings_not_blocks(self):+ with Home():+ rows = catalog({**HW_12, "ram_gb": 32.0}).rows()+ big = [r for r in rows if r.model == "IQ3_S" and r.family == "qwen"][0]+ self.assertIn(big.verdict, ("no", "tight"))++ def test_kv_figures(self):+ with Home():+ cat = catalog()+ self.assertAlmostEqual(cat.kv_gb(131072, "int8"), 1.799, places=2)+ self.assertLess(cat.kv_gb(131072, "q4_0"), cat.kv_gb(131072, "int8"))+ self.assertEqual(cat.max_context("qwen", "IQ3_XXS", HW_12), 32768)+ self.assertEqual(cat.max_context("qwen", "IQ3_XXS", HW_24), 131072)++ def test_missing_installer_files_are_said_in_words(self):+ with Home():+ with self.assertRaises(CatalogUnavailable) as e:+ Catalog(src="/nonexistent-folder", hardware=HW_12)+ self.assertIn("one-line installer", str(e.exception))+++class PresetStore(unittest.TestCase):+ def test_save_load_list_delete(self):+ with Home():+ s = S.LaunchSettings(name="IQ3_XXS 128K", family="qwen", model="IQ3_XXS", context=131072, api_key="sk-secret")+ store.save(s)+ store.save(S.LaunchSettings(name="Coder 64K", family="coder", model="IQ1_M", context=65536))+ names = [p.name for p in store.list_presets()]+ self.assertEqual(sorted(names), ["Coder 64K", "IQ3_XXS 128K"])+ back = store.load("IQ3_XXS 128K")+ self.assertEqual((back.model, back.context, back.api_key), ("IQ3_XXS", 131072, "sk-secret"))+ store.touch_used("IQ3_XXS 128K")+ self.assertTrue(store.load("IQ3_XXS 128K").last_used)+ self.assertEqual(store.list_presets()[0].name, "IQ3_XXS 128K") # most recently used first+ store.delete("Coder 64K")+ self.assertEqual([p.name for p in store.list_presets()], ["IQ3_XXS 128K"])+ with self.assertRaises(store.PresetError) as e:+ store.load("IQ3 XXS 128")+ self.assertIn("Did you mean", str(e.exception))+ with self.assertRaises(store.PresetError):+ store.delete("nope")++ def test_key_is_not_world_readable_on_posix(self):+ if os.name == "nt":+ self.skipTest("POSIX modes")+ with Home():+ store.save(S.LaunchSettings(name="k", api_key="sk-secret"))+ path = next(store.preset_dir().glob("*.json"))+ self.assertEqual(path.stat().st_mode & 0o077, 0)+++class Advanced(unittest.TestCase):+ HELP = """strata generate --pack DIR [options]++ --pack DIR the pack directory (default pack/full)+ --kv fp16|int8 KV storage (plan v0.3 P7): int8 codes, half the+ VRAM; default fp16 until the gate accepts int8+ --kv q4_0 4-bit K/V after a Hadamard rotation+ --kv-grow the K/V takes VRAM only for the cells the requests reach+ --native-rope experimental pinned text-only CUDA rotary arithmetic+ --prefill N prompt chunk size (default 2048)+"""++ def test_parse_help(self):+ ps = {p.name: p for p in params.parse_help(self.HELP)}+ self.assertEqual(set(ps), {"--pack", "--kv", "--kv-grow", "--native-rope", "--prefill"})+ self.assertEqual(ps["--pack"].metavar, "DIR")+ self.assertEqual(ps["--pack"].help_default, "pack/full")+ self.assertEqual(ps["--kv"].values, ["fp16", "int8"])+ self.assertIn("4-bit", ps["--kv"].description) # a flag listed twice keeps both texts+ self.assertTrue(ps["--native-rope"].experimental)+ self.assertFalse(ps["--prefill"].experimental)+ self.assertEqual(ps["--kv-grow"].metavar, "")+ self.assertLessEqual(len(ps["--prefill"].short), 70)++ def test_rows_show_default_tuned_and_yours(self):+ rows = {r.name: r for r in params.build_rows(self.HELP, ["--kv", "int8", "--prefill", "auto"], ["--kv", "int8", "--prefill", "auto:32768"],+ {}, {}, {"--prefill": "65536"})}+ self.assertEqual((rows["--prefill"].default, rows["--prefill"].tuned, rows["--prefill"].yours), ("auto", "auto:32768", "65536"))+ self.assertEqual(rows["--kv"].yours, "")+ self.assertIn("--native-rope", rows)+ names = list(rows)+ self.assertEqual(names[:2], ["--kv", "--prefill"]) # what this launch uses comes first++ def test_unknown_names_warn_and_are_kept(self):+ rows = params.build_rows(self.HELP, [], None, {}, {}, {"--prefil": "1"})+ r = next(x for x in rows if x.name == "--prefil")+ self.assertFalse(r.known)+ warn = params.check_name("--prefil", ["--prefill", "--kv"])+ self.assertIn("Did you mean --prefill", warn)+ self.assertIsNone(params.check_name("--prefill", ["--prefill"]))+ self.assertIsNone(params.check_name("--prefil", None)) # no list to check against: no warning++ def test_extra_becomes_argv_and_env(self):+ a, e = S.as_argv_changes({"--prefill": "65536", "--kv-grow": "", "--spec": "off", "STRATA_PIN_BY_NEED": "1"}, frozenset({"--kv-grow"}))+ self.assertEqual(a, {"--prefill": "65536", "--kv-grow": True, "--spec": None})+ self.assertEqual(e, {"STRATA_PIN_BY_NEED": "1"})+++class RunConfig(unittest.TestCase):+ BASE = {"exe": "component:strata-engine", "args": ["--native", "x.gguf", "--max-context", "32768", "--kv", "int8", "--prefill", "auto"],+ "port": 8095, "model_name": "m", "env": {}}++ def test_derive_applies_access_key_and_advanced(self):+ s = S.LaunchSettings(access="lan", port=9001, api_key="sk-k", extra={"--prefill": "65536", "--kv-grow": "", "STRATA_PIN_BY_NEED": "1"})+ cfg = derive_config(self.BASE, s, bool_flags=frozenset({"--kv-grow"}))+ self.assertEqual((cfg["host"], cfg["port"], cfg["api_key"]), ("0.0.0.0", 9001, "sk-k"))+ args = cfg["args"]+ self.assertEqual(args[args.index("--prefill") + 1], "65536")+ self.assertIn("--kv-grow", args)+ self.assertEqual(cfg["env"], {"STRATA_PIN_BY_NEED": "1"})+ self.assertEqual(self.BASE["args"][-1], "auto") # the installed config is never edited++ def test_local_and_cloudflare_stay_on_loopback_without_a_key(self):+ for kind in ("local", "cloudflare"):+ cfg = derive_config(self.BASE, S.LaunchSettings(access=kind), bool_flags=frozenset())+ self.assertEqual(cfg["host"], "127.0.0.1")+ self.assertNotIn("api_key", cfg)++ def test_installed_config_matching(self):+ d = {"context": 32768, "kv": "int8", "images": "off"}+ self.assertTrue(desc_matches(d, S.LaunchSettings(context=32768)))+ self.assertFalse(desc_matches(d, S.LaunchSettings(context=65536)))+ self.assertFalse(desc_matches(d, S.LaunchSettings(context=32768, vision="on")))+ self.assertFalse(desc_matches({**d, "images": "cpu"}, S.LaunchSettings(context=32768, vision="off")))+ self.assertFalse(desc_matches(d, S.LaunchSettings(context=32768, kv="q4_0")))++ def test_tune_words(self):+ self.assertEqual(tune_words({"outcome": "improved", "gain_pct": 4.2})[0], "faster")+ self.assertEqual(tune_words({"outcome": "default_confirmed"})[0], "already fastest")+ self.assertEqual(tune_words({"outcome": "inconclusive", "reason_code": "noisy"})[0], "busy PC")+ self.assertEqual(tune_words({"outcome": "base_failed", "message": "Not tuned: no memory"})[0], "failed")+ self.assertEqual(tune_words(None)[0], "failed")+ self.assertEqual(tune_words({"outcome": "cancelled"})[0], "stopped")+++class AccessRules(unittest.TestCase):+ def test_hosts_and_keys(self):+ self.assertEqual(access.host_for("local"), "127.0.0.1")+ self.assertEqual(access.host_for("cloudflare"), "127.0.0.1")+ self.assertEqual(access.host_for("lan"), "0.0.0.0")+ self.assertTrue(access.new_key().startswith("sk-strata-"))+ self.assertNotIn(access.new_key(), access.mask_key(access.new_key()))+ self.assertEqual(access.mask_key(None), "off")++ def test_private_ranges(self):+ for ip in ("10.1.2.3", "192.168.88.21", "172.16.0.9", "100.101.1.1"):+ self.assertTrue(access._is_private(ip), ip)+ for ip in ("8.8.8.8", "172.32.0.1", "1.2.3.4"):+ self.assertFalse(access._is_private(ip), ip)++ def test_missing_helpers_say_how_to_install(self):+ with mock.patch.object(access, "find_cloudflared", return_value=None):+ msg = access.missing_helper("cloudflare")+ self.assertIn("cloudflared is not installed", msg)+ self.assertIn("quick tunnel", msg)+ with mock.patch.object(access, "find_tailscale", return_value=None):+ self.assertIn("Tailscale is not installed", access.missing_helper("tailscale"))+ with mock.patch.object(access, "tailscale_status", return_value={"installed": True, "running": False, "ip": None, "name": None}):+ self.assertIn("tailscale up", access.missing_helper("tailscale"))+ self.assertIsNone(access.missing_helper("local"))++ def test_options_and_urls(self):+ with mock.patch.object(access, "lan_ips", return_value=["192.168.1.5"]), \+ mock.patch.object(access, "find_cloudflared", return_value="/bin/cloudflared"), \+ mock.patch.object(access, "tailscale_status", return_value={"installed": True, "running": True, "ip": "100.64.0.1", "name": "pc.tail.ts.net"}):+ opts = {o.kind: o for o in access.options(8080)}+ self.assertEqual(opts["lan"].url, "http://192.168.1.5:8080")+ self.assertTrue(opts["cloudflare"].ready)+ self.assertEqual(opts["tailscale"].url, "http://pc.tail.ts.net:8080")+ urls = access.urls_for(S.LaunchSettings(access="lan", port=8080))+ self.assertEqual(urls, ["http://127.0.0.1:8080", "http://192.168.1.5:8080"])+ self.assertEqual(access.urls_for(S.LaunchSettings(access="cloudflare", port=8080), tunnel_url="https://a.trycloudflare.com")[0],+ "https://a.trycloudflare.com")++ def test_helper_output_filter_drops_login_lines(self):+ self.assertEqual(access.filter_line("Please open this URL to login: https://dash.cloudflare.com/argotunnel?token=abc"), "")+ self.assertEqual(access.filter_line("Your quick Tunnel has been created: https://x.trycloudflare.com"),+ "Your quick Tunnel has been created: https://x.trycloudflare.com")+ self.assertEqual(access.TUNNEL_URL.search("| https://calm-river-1234.trycloudflare.com |").group(0),+ "https://calm-river-1234.trycloudflare.com")+++class FlagsCommand(unittest.TestCase):+ """Every `strata launch` flag, run through the real parser with the computer faked and nothing installed."""++ def setUp(self):+ self.home = Home().__enter__()+ self.addCleanup(self.home.__exit__, None, None, None)+ p = mock.patch.object(Catalog, "hardware", lambda self, fresh=False: dict(HW_12, disk_free_gb=500.0))+ p.start()+ self.addCleanup(p.stop)++ def plan(self, *args):+ code, out, err = run_cli(["launch", "--plan", "--output", "json", *args])+ self.assertEqual(code, 0, err or out)+ return json.loads(out)["plan"]++ def test_help_lists_everything_with_examples(self):+ code, out, err = run_cli(["launch", "--help"])+ self.assertEqual(code, 0)+ for flag in ("--preset", "--model", "--family", "--model-path", "--data-dir", "--context", "--kv", "--vision", "--parallel", "--gpu",+ "--tune", "--tune-allow-small", "--set", "--access", "--port", "--api-key", "--api-key-env", "--new-key", "--save-preset",+ "--no-tui", "--plan", "--feed", "--list-presets", "--delete-preset", "--status", "--stop", "--show-key", "examples:"):+ self.assertIn(flag, out)+ code, out, _ = run_cli(["--help"])+ self.assertIn("launch", out)+ self.assertIn("connect", out)++ def test_model_context_parallel_vision_tune_access_port(self):+ p = self.plan("--model", "iq3_xxs", "--context", "128k", "--parallel", "2", "--vision", "off", "--tune", "quick", "--access", "lan",+ "--port", "9090")+ s = p["settings"]+ self.assertEqual((s["family"], s["model"], s["context"], s["parallel"], s["vision"], s["tune"], s["access"], s["port"]),+ ("qwen", "IQ3_XXS", 131072, 2, "off", "quick", "lan", 9090))+ self.assertEqual(s["api_key"], "set") # shared beyond this computer: a key was made+ self.assertTrue(any("2 requests" in w and "12 GB" in w for w in p["warnings"]))++ def test_defaults_come_from_the_recommendation(self):+ p = self.plan()+ s = p["settings"]+ self.assertEqual((s["family"], s["model"], s["context"], s["access"], s["tune"]), ("qwen", "IQ3_XXS", 32768, "local", "skip"))+ self.assertTrue(any("picked" in w for w in p["warnings"]))++ def test_family_and_kv_and_gpu_and_data_dir_and_set(self):+ p = self.plan("--model", "iq3_xxs", "--family", "swift", "--kv", "q4_0", "--gpu", "0,1", "--data-dir", "/data/x",+ "--set", "prefill=65536", "--set", "STRATA_PIN_BY_NEED=1", "--tune-allow-small")+ s = p["settings"]+ self.assertEqual((s["family"], s["kv"], s["gpus"], s["data_dir"], s["tune_allow_small"]), ("swift", "q4_0", [0, 1], "/data/x", True))+ self.assertEqual(s["extra"], {"--prefill": "65536", "STRATA_PIN_BY_NEED": "1"})+ self.assertIn("--set prefill=65536", p["flags"])++ def test_api_key_flags(self):+ p = self.plan("--model", "q2_0", "--access", "lan", "--api-key", "sk-mine")+ self.assertEqual(p["settings"]["api_key"], "set")+ self.assertFalse(any("new API key was made" in w for w in p["warnings"]))+ with mock.patch.dict(os.environ, {"MY_KEY": "sk-env"}):+ p = self.plan("--model", "q2_0", "--api-key-env", "MY_KEY")+ self.assertEqual(p["settings"]["api_key"], "set")+ code, out, err = run_cli(["launch", "--plan", "--api-key-env", "NOT_SET_ANYWHERE"])+ self.assertEqual(code, 2)+ self.assertIn("NOT_SET_ANYWHERE", err)+ p = self.plan("--model", "q2_0", "--new-key")+ self.assertEqual(p["settings"]["api_key"], "set")++ def test_model_path_is_used_instead_of_a_catalog_model(self):+ p = self.plan("--model-path", "/data/models/IQ3_XXS")+ s = p["settings"]+ self.assertEqual(s["model_path"], str(Path("/data/models/IQ3_XXS")))+ self.assertIsNone(s["model"])++ def test_unknown_model_names_the_closest_one(self):+ code, out, err = run_cli(["launch", "--plan", "--model", "iq3xxs"])+ self.assertEqual(code, 2)+ self.assertIn("Did you mean 'IQ3_XXS'", err)+ self.assertNotIn("Traceback", err)++ def test_unknown_flag_names_the_closest_one(self):+ code, out, err = run_cli(["launch", "--modle", "iq3_xxs"])+ self.assertEqual(code, 2)+ self.assertIn("Did you mean '--model'", err)++ def test_bad_values_are_plain_sentences(self):+ for argv, word in ((["--tune", "quik"], "quick"), (["--access", "lann"], "lan"), (["--context", "huge"], "context"),+ (["--port", "99999"], "1 to 65535"), (["--parallel", "12"], "1 to 8"), (["--vision", "maybe"], "off")):+ code, out, err = run_cli(["launch", "--plan", *argv])+ self.assertEqual(code, 2, argv)+ self.assertIn(word, err, argv)++ def test_preset_with_flags_on_top(self):+ store.save(S.LaunchSettings(name="Office", family="qwen", model="IQ3_XXS", context=65536, parallel=2, access="local"))+ p = self.plan("--preset", "Office", "--context", "128k")+ s = p["settings"]+ self.assertEqual((s["name"], s["context"], s["parallel"]), ("Office", 131072, 2))+ code, out, err = run_cli(["launch", "--plan", "--preset", "Offce"])+ self.assertEqual(code, 2)+ self.assertIn("Did you mean 'Office'", err)++ def test_vision_is_turned_off_for_a_model_without_pictures(self):+ p = self.plan("--model", "gyro-s", "--vision", "on")+ self.assertEqual(p["settings"]["vision"], "off")+ self.assertTrue(any("cannot read pictures" in w for w in p["warnings"]))++ def test_does_not_fit_is_a_warning_with_the_reason(self):+ p = self.plan("--model", "nvfp4")+ self.assertTrue(any("does not fit" in w for w in p["warnings"]))++ def test_human_plan_changes_nothing(self):+ code, out, err = run_cli(["launch", "--plan", "--model", "q2_0", "--save-preset", "X"])+ self.assertEqual(code, 0)+ self.assertIn("Nothing was changed.", out)+ self.assertEqual(store.list_presets(), [])++ def test_run_without_screens_prints_the_address_and_saves_the_preset(self):+ fake = Result(profile="launch-office", urls=["http://127.0.0.1:8080", "http://192.168.1.5:8080"], key="sk-strata-abcdefghijkl",+ tune_word=None, notices=[], config="/x")+ with mock.patch.object(Runner, "run", return_value=fake):+ code, out, err = run_cli(["launch", "--no-tui", "--model", "q2_0", "--access", "lan", "--save-preset", "Office"])+ self.assertEqual(code, 0, err)+ self.assertIn("Strata is serving.", out)+ self.assertIn("http://127.0.0.1:8080/v1", out)+ self.assertIn("http://192.168.1.5:8080/v1", out)+ self.assertNotIn("sk-strata-abcdefghijkl", out) # the key is masked+ self.assertIn("strata connect", out)+ self.assertEqual([p.name for p in store.list_presets()], ["Office"])+ code, out, err = run_cli(["launch", "--list-presets"])+ self.assertIn("Office", out)+ code, out, _ = run_cli(["launch", "--show-key", "--preset", "Office"])+ self.assertEqual(code, 0) # the preset's own key+ self.assertTrue(out.strip().startswith("sk-strata-"))++ def test_launch_error_is_one_plain_sentence(self):+ from strata_cli.launch.runner import LaunchError+ with mock.patch.object(Runner, "run", side_effect=LaunchError("The engine could not be installed.", "Check your internet.", 6)):+ code, out, err = run_cli(["launch", "--no-tui", "--model", "q2_0"])+ self.assertEqual(code, 6)+ self.assertIn("The engine could not be installed. Check your internet.", err)+ self.assertNotIn("Traceback", err)++ def test_list_delete_status_stop_without_anything_running(self):+ store.save(S.LaunchSettings(name="A", family="qwen", model="Q2_0", context=32768))+ code, out, _ = run_cli(["launch", "--list-presets"])+ self.assertIn("A", out)+ code, out, _ = run_cli(["launch", "--delete-preset", "A"])+ self.assertEqual(code, 0)+ self.assertIn("Models and tuning results were not touched", out)+ code, out, _ = run_cli(["launch", "--list-presets"])+ self.assertIn("No saved presets", out)+ code, out, _ = run_cli(["launch", "--status"])+ self.assertEqual(code, 0)+ self.assertIn("Nothing from `strata launch` is running.", out)+ code, out, _ = run_cli(["launch", "--stop"])+ self.assertEqual(code, 0)+ self.assertIn("Nothing", out)+ code, out, err = run_cli(["launch", "--delete-preset", "gone"])+ self.assertEqual(code, 2)+ self.assertIn("no saved preset", err)++ def test_feed_flag_reaches_the_runner(self):+ seen = {}++ def fake(self, *a, **k):+ seen["feed"] = self.feed+ return Result("launch-x", ["http://127.0.0.1:8080"], None, None, [], "/x")++ with mock.patch.object(Runner, "run", fake):+ code, _, err = run_cli(["launch", "--no-tui", "--model", "q2_0", "--feed", "http://127.0.0.1:9/feed"])+ self.assertEqual(code, 0, err)+ self.assertEqual(seen["feed"], "http://127.0.0.1:9/feed")++ def test_output_json_for_scripts(self):+ fake = Result("launch-x", ["http://127.0.0.1:8080"], "sk-k", "faster", ["a note"], "/x")+ with mock.patch.object(Runner, "run", return_value=fake):+ code, out, err = run_cli(["launch", "--no-tui", "--output", "json", "--model", "q2_0"])+ data = json.loads(out)+ self.assertTrue(data["ok"])+ self.assertEqual(data["urls"], ["http://127.0.0.1:8080"])+ self.assertEqual(data["api_key"], "set") # never the key itself+ self.assertEqual(data["tuned"], "faster")+++class ConnectCommand(unittest.TestCase):+ def setUp(self):+ self.home = Home().__enter__()+ self.addCleanup(self.home.__exit__, None, None, None)++ def test_list_and_unknown_names(self):+ code, out, _ = run_cli(["connect"])+ self.assertEqual(code, 0)+ for h in ("opencode", "codex", "claude-code", "omp", "pi", "hermes", "openclaw", "deepseek-harness"):+ self.assertIn(h, out)+ code, out, err = run_cli(["connect", "opncode"])+ self.assertEqual(code, 2)+ self.assertIn("Did you mean 'opencode'", err)+ code, out, _ = run_cli(["connect", "--output", "json"])+ self.assertEqual(len(json.loads(out)["harnesses"]), 8)++ def test_prints_the_config_with_a_masked_key(self):+ code, out, err = run_cli(["connect", "opencode", "--url", "http://127.0.0.1:8123", "--key", "sk-strata-abcdefghij1234", "--model", "m1"])+ self.assertEqual(code, 0, err)+ self.assertIn("http://127.0.0.1:8123/v1", out)+ self.assertIn("opencode.json", out)+ self.assertNotIn("abcdefghij1234", out)+ code, out, _ = run_cli(["connect", "opencode", "--url", "http://127.0.0.1:8123", "--key", "sk-strata-abcdefghij1234", "--show-key"])+ self.assertIn("sk-strata-abcdefghij1234", out)++ def test_claude_code_uses_the_anthropic_variables_without_a_login(self):+ code, out, _ = run_cli(["connect", "claude-code", "--url", "http://127.0.0.1:8080", "--key", "sk-x1234567890abc", "--show-key"])+ self.assertIn("ANTHROPIC_BASE_URL", out)+ self.assertIn("ANTHROPIC_AUTH_TOKEN", out)+ self.assertNotIn("/v1", out.split("ANTHROPIC_BASE_URL")[1].splitlines()[0]) # the Anthropic client adds /v1 itself++ def test_write_keeps_a_backup_and_merges(self):+ target = Path(os.environ["HOME"]) / ".config" / "opencode" / "opencode.json"+ target.parent.mkdir(parents=True)+ target.write_text(json.dumps({"theme": "dark", "provider": {"other": {"a": 1}}}))+ code, out, err = run_cli(["connect", "opencode", "--url", "http://127.0.0.1:8080", "--key", "sk-x1234567890abc", "--write", "--yes"])+ self.assertEqual(code, 0, err)+ data = json.loads(target.read_text())+ self.assertEqual(data["theme"], "dark")+ self.assertIn("other", data["provider"])+ self.assertIn("strata", data["provider"])+ backups = list(target.parent.glob("opencode.json.strata-bak-*"))+ self.assertEqual(len(backups), 1)+ self.assertEqual(json.loads(backups[0].read_text())["theme"], "dark")+ self.assertIn("backup", out)++ def test_write_asks_first_without_yes(self):+ code, out, err = run_cli(["connect", "opencode", "--write"])+ self.assertEqual(code, 2)+ self.assertIn("asks first", err)++ def test_built_in_harness_has_nothing_to_write(self):+ code, out, _ = run_cli(["connect", "deepseek-harness", "--write", "--yes"])+ self.assertEqual(code, 0)+ self.assertIn("Nothing to write", out)++ def test_untested_drafts_say_so(self):+ h = harness.find("hermes")+ if not h.tested:+ code, out, _ = run_cli(["connect", "hermes"])+ self.assertIn("not been tested", out)+++if __name__ == "__main__":+ unittest.main()