wirestudio 0.17.2__tar.gz → 0.17.3__tar.gz

{wirestudio-0.17.2/wirestudio.egg-info → wirestudio-0.17.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wirestudio
-Version: 0.17.2
+Version: 0.17.3
 Summary: Agent-driven IoT device design tool that produces ESPHome YAML.
 Author: wirestudio contributors
 License: MIT

{wirestudio-0.17.2 → wirestudio-0.17.3}/tests/test_fleet.py

@@ -43,6 +43,11 @@ class FakeFleetAddon:
         # ({"id", "run_id", "state", "target", "finished_at"}) to drive the
         # run-status verdict tests.
         self.queue_jobs: list[dict] = []
+        # run_id -> {"app": bytes | None, "factory": bytes | None}; tests
+        # populate this to drive the firmware-artifact passthrough tests.
+        # None means "not built" -> the addon 404s (matches the fleet-side
+        # contract that 404 = not ready or unavailable).
+        self.firmware: dict[str, dict[str, bytes | None]] = {}
 
     def transport(self) -> httpx.MockTransport:
         def handler(req: httpx.Request) -> httpx.Response:
@@ -110,6 +115,26 @@ class FakeFleetAddon:
                     "finished": bool(self.job_logs[run_id]["finished"]),
                 })
 
+            # GET /ui/api/jobs/{run_id}/firmware            -> app image
+            # GET /ui/api/jobs/{run_id}/firmware/factory    -> factory image
+            if method == "GET" and path.startswith("/ui/api/jobs/") and (
+                path.endswith("/firmware") or path.endswith("/firmware/factory")
+            ):
+                kind = "factory" if path.endswith("/factory") else "app"
+                trim = "/firmware/factory" if kind == "factory" else "/firmware"
+                run_id = path[len("/ui/api/jobs/"):-len(trim)]
+                slot = self.firmware.get(run_id)
+                if slot is None:
+                    return httpx.Response(404, json={"error": "unknown run_id"})
+                data = slot.get(kind)
+                if data is None:
+                    return httpx.Response(404, json={"error": f"no {kind} image"})
+                return httpx.Response(
+                    200,
+                    content=data,
+                    headers={"content-type": "application/octet-stream"},
+                )
+
             return httpx.Response(404, json={"error": "not found"})
 
         return httpx.MockTransport(handler)
@@ -488,6 +513,115 @@ async def test_fleet_job_log_unknown_run_id_returns_502(monkeypatch, tmp_path):
     assert r.status_code == 502
 
 
+# ---------------------------------------------------------------------------
+# Build-artifact passthrough (fleet -> studio -> browser WebSerial)
+# ---------------------------------------------------------------------------
+
+async def test_get_firmware_returns_app_image_bytes():
+    addon = FakeFleetAddon()
+    addon.firmware["run-1"] = {"app": b"FAKE-APP-IMAGE", "factory": None}
+    fc = addon.make_client()
+    data = await fc.get_firmware("run-1")
+    assert data == b"FAKE-APP-IMAGE"
+
+
+async def test_get_firmware_factory_uses_factory_subpath():
+    addon = FakeFleetAddon()
+    addon.firmware["run-1"] = {
+        "app": b"APP",
+        "factory": b"BOOT+PART+APP",
+    }
+    fc = addon.make_client()
+    data = await fc.get_firmware("run-1", factory=True)
+    assert data == b"BOOT+PART+APP"
+
+
+async def test_get_firmware_unknown_run_id_raises():
+    addon = FakeFleetAddon()
+    fc = addon.make_client()
+    with pytest.raises(FleetUnavailable, match="not available"):
+        await fc.get_firmware("nope")
+
+
+async def test_get_firmware_factory_missing_raises():
+    # The build produced an app image but the older ESPHome on the fleet
+    # didn't emit firmware-factory.bin -- the addon 404s factory while the
+    # app image is fine. The dialog falls back / surfaces the message.
+    addon = FakeFleetAddon()
+    addon.firmware["run-1"] = {"app": b"APP", "factory": None}
+    fc = addon.make_client()
+    with pytest.raises(FleetUnavailable, match="not available"):
+        await fc.get_firmware("run-1", factory=True)
+
+
+async def test_get_firmware_unconfigured_raises():
+    fc = FleetClient(base_url=None, token=None)
+    with pytest.raises(FleetUnavailable, match="missing"):
+        await fc.get_firmware("run-1")
+
+
+async def test_fleet_firmware_endpoint_unconfigured_returns_503(monkeypatch, tmp_path):
+    client = _make_client(monkeypatch, tmp_path, addon=None)
+    r = client.get("/fleet/jobs/run-1/firmware")
+    assert r.status_code == 503
+
+
+async def test_fleet_firmware_endpoint_round_trips_app_image(monkeypatch, tmp_path):
+    addon = FakeFleetAddon()
+    addon.firmware["run-7"] = {"app": b"\x01\x02APP", "factory": None}
+    client = _make_client(monkeypatch, tmp_path, addon=addon)
+    r = client.get("/fleet/jobs/run-7/firmware")
+    assert r.status_code == 200
+    assert r.headers["content-type"] == "application/octet-stream"
+    assert r.headers["content-disposition"] == 'attachment; filename="run-7.bin"'
+    assert r.content == b"\x01\x02APP"
+
+
+async def test_fleet_firmware_endpoint_round_trips_factory_image(monkeypatch, tmp_path):
+    addon = FakeFleetAddon()
+    addon.firmware["run-7"] = {"app": b"app", "factory": b"\xe9\x00\x00FACTORY"}
+    client = _make_client(monkeypatch, tmp_path, addon=addon)
+    r = client.get("/fleet/jobs/run-7/firmware?factory=true")
+    assert r.status_code == 200
+    assert r.headers["content-disposition"] == 'attachment; filename="run-7-factory.bin"'
+    assert r.content == b"\xe9\x00\x00FACTORY"
+
+
+async def test_fleet_firmware_endpoint_unknown_run_id_returns_404(monkeypatch, tmp_path):
+    # 404 means "not ready yet / not built" -- the dialog uses this to keep
+    # waiting on the compile rather than treating it as a fleet outage (which
+    # would be 502).
+    addon = FakeFleetAddon()
+    client = _make_client(monkeypatch, tmp_path, addon=addon)
+    r = client.get("/fleet/jobs/ghost/firmware")
+    assert r.status_code == 404
+
+
+async def test_fleet_firmware_endpoint_addon_unreachable_returns_502(monkeypatch, tmp_path):
+    # Addon returns a 5xx (here, simulated via missing handler -> 404 then
+    # mapped to "not available"). For a transport-level failure we'd return
+    # 502; cover that explicitly by pointing the client at a transport that
+    # always 500s.
+    def boom_handler(req: httpx.Request) -> httpx.Response:
+        if req.url.path.startswith("/ui/api/jobs/") and req.url.path.endswith(
+            "/firmware"
+        ):
+            return httpx.Response(500, json={"error": "internal"})
+        return httpx.Response(404)
+
+    transport = httpx.MockTransport(boom_handler)
+    fc = FleetClient(
+        base_url="http://broken-fleet.local", token="tok-123", transport=transport,
+    )
+
+    class _BrokenAddon:
+        def make_client(self): return fc
+
+    client = _make_client(monkeypatch, tmp_path, addon=_BrokenAddon())
+    r = client.get("/fleet/jobs/run-1/firmware")
+    assert r.status_code == 502
+
+
 # ---------------------------------------------------------------------------
 # SSE log relay
 # ---------------------------------------------------------------------------

{wirestudio-0.17.2 → wirestudio-0.17.3}/tests/test_mcp_auth.py

@@ -12,6 +12,9 @@ from starlette.routing import Route
 from wirestudio.mcp.auth import (
     DEFAULT_TOKEN_PATH,
     BearerTokenMiddleware,
+    TokenManagedError,
+    TokenStore,
+    load_token_store,
     resolve_token,
 )
 
@@ -34,7 +37,8 @@ def _build_app(token: str) -> Starlette:
             Route("/public", _ok),
         ]
     )
-    app.add_middleware(BearerTokenMiddleware, token=token)
+    store = TokenStore(token=token, path=Path("/unused"), env_managed=True)
+    app.add_middleware(BearerTokenMiddleware, store=store)
     return app
 
 
@@ -115,6 +119,43 @@ def test_resolve_token_generates_and_persists(monkeypatch, tmp_path: Path):
     assert resolve_token(token_path=file_path) == token
 
 
+async def test_middleware_reads_rotated_token_without_restart(tmp_path: Path):
+    # Rotation updates the live store; the already-mounted middleware must
+    # validate against the new token, not the one captured at startup.
+    file_path = tmp_path / "mcp-token"
+    file_path.write_text("original")
+    store = TokenStore(token="original", path=file_path, env_managed=False)
+
+    app = Starlette(routes=[Route("/mcp", _ok)])
+    app.add_middleware(BearerTokenMiddleware, store=store)
+    transport = httpx.ASGITransport(app=app)
+    async with httpx.AsyncClient(transport=transport, base_url="http://t") as c:
+        new_token = store.rotate()
+        r_old = await c.get("/mcp", headers={"Authorization": "Bearer original"})
+        r_new = await c.get("/mcp", headers={"Authorization": f"Bearer {new_token}"})
+    assert r_old.status_code == 401
+    assert r_new.status_code == 200
+
+
+def test_token_store_rotate_persists_new_token(tmp_path: Path):
+    file_path = tmp_path / "mcp-token"
+    store = load_token_store(token_path=file_path)
+    first = store.token
+    rotated = store.rotate()
+    assert rotated != first
+    assert store.token == rotated
+    assert file_path.read_text() == rotated
+    assert file_path.stat().st_mode & 0o777 == 0o600
+
+
+def test_token_store_rotate_refuses_env_managed(monkeypatch, tmp_path: Path):
+    monkeypatch.setenv("WIRESTUDIO_MCP_TOKEN", "from-env")
+    store = load_token_store(token_path=tmp_path / "mcp-token")
+    assert store.env_managed is True
+    with pytest.raises(TokenManagedError):
+        store.rotate()
+
+
 def test_default_token_path_is_under_user_config():
     # Anchored to ~/.config/wirestudio so operators know where to look
     # without grepping the source.

{wirestudio-0.17.2 → wirestudio-0.17.3}/wirestudio/__init__.py

@@ -1,3 +1,3 @@
 """wirestudio: design.json -> ESPHome YAML + ASCII diagram."""
 
-__version__ = "0.17.2"
+__version__ = "0.17.3"

{wirestudio-0.17.2 → wirestudio-0.17.3}/wirestudio/api/app.py

@@ -22,7 +22,12 @@ from slowapi.errors import RateLimitExceeded
 import os
 from pydantic import ValidationError
 
-from wirestudio.mcp import BearerTokenMiddleware, build_mcp_server, resolve_token
+from wirestudio.mcp import (
+    BearerTokenMiddleware,
+    TokenManagedError,
+    build_mcp_server,
+    load_token_store,
+)
 
 from wirestudio import __version__
 from wirestudio.agent.agent import is_available as agent_available, run_turn, stream_turn_events
@@ -42,6 +47,7 @@ from wirestudio.api.schemas import (
     InventoryCheckRequest,
     InventoryCheckResponse,
     InventoryEntryModel,
+    McpTokenResponse,
     ModuleSummary,
     FleetJobLogResponse,
     FleetJobStatus,
@@ -1212,6 +1218,53 @@ def create_app(
             headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"},
         )
 
+    @app.get("/fleet/jobs/{run_id}/firmware", tags=["fleet"])
+    async def fleet_job_firmware(run_id: str, factory: bool = False) -> Response:
+        """Passthrough for the fleet's compiled-firmware artifact -- the
+        studio fetches it server-side with FLEET_TOKEN and streams the
+        bytes to the browser's WebSerial flasher (no token in the browser).
+
+        ``?factory=true`` returns the merged bootloader+partitions+app
+        image for flashing a blank board at offset 0x0 (paired with
+        ``eraseAll: true`` on the browser side); default is the app image
+        for an NVS-preserving re-flash. Mirrors the standalone path's
+        ``/lorawan/firmware/{cache_key}[/factory]`` so the WebSerial flow
+        on the external-component path can reuse ``lib/flash.ts`` unchanged.
+
+        Returns 404 when the run hasn't finished, has aged out of the
+        addon's tracking, or the build didn't produce the requested image
+        type; 503 when fleet credentials are missing; 502 when the addon
+        is reachable but the call failed (e.g. the upstream artifact
+        endpoint isn't implemented yet -- see
+        ``docs/lorawan/fleet-firmware-flash.md``).
+        """
+        fc = make_fleet()
+        if not fc.is_configured():
+            raise HTTPException(
+                status_code=503,
+                detail="fleet not configured (set FLEET_URL and FLEET_TOKEN)",
+            )
+        try:
+            data = await fc.get_firmware(run_id, factory=factory)
+        except FleetUnavailable as e:
+            # The client raises FleetUnavailable on both 404 (firmware not
+            # available -> the dialog stops the flash flow with a clear
+            # message) and transport failures (the addon being down).
+            # Preserve the 404 vs 502 distinction the addon emitted so the
+            # browser can tell "not ready yet" from "fleet is down".
+            msg = str(e)
+            if "not available" in msg:
+                raise HTTPException(status_code=404, detail=msg) from e
+            raise HTTPException(status_code=502, detail=msg) from e
+        suffix = "-factory" if factory else ""
+        return Response(
+            content=data,
+            media_type="application/octet-stream",
+            headers={
+                "Content-Disposition": f'attachment; filename="{run_id}{suffix}.bin"',
+            },
+        )
+
     @app.get("/agent/status", tags=["agent"])
     def agent_status() -> dict:
         ok, reason = agent_available()
@@ -1307,11 +1360,32 @@ def create_app(
                 h.strip() for h in allowed_hosts.split(",") if h.strip()
             ]
         token_path_env = os.environ.get("WIRESTUDIO_MCP_TOKEN_PATH")
-        token = resolve_token(
+        token_store = load_token_store(
             token_path=Path(token_path_env) if token_path_env else None,
         )
+
+        # Token-management endpoints for the web UI. Registered before the
+        # catch-all mount below so FastAPI serves them directly -- they sit on
+        # the unauthenticated API surface (the bearer token only gates /mcp),
+        # which is required so the UI can show the token to a user who doesn't
+        # have it yet.
+        @app.get("/mcp/token", response_model=McpTokenResponse, tags=["mcp"])
+        def get_mcp_token() -> McpTokenResponse:
+            return McpTokenResponse(
+                token=token_store.token,
+                managed="env" if token_store.env_managed else "file",
+            )
+
+        @app.post("/mcp/token/rotate", response_model=McpTokenResponse, tags=["mcp"])
+        def rotate_mcp_token() -> McpTokenResponse:
+            try:
+                new_token = token_store.rotate()
+            except TokenManagedError as e:
+                raise HTTPException(status_code=409, detail=str(e)) from e
+            return McpTokenResponse(token=new_token, managed="file")
+
         mcp_app = mcp_server.streamable_http_app()
-        mcp_app.add_middleware(BearerTokenMiddleware, token=token)
+        mcp_app.add_middleware(BearerTokenMiddleware, store=token_store)
         app.mount("/", mcp_app)
 
     return app

{wirestudio-0.17.2 → wirestudio-0.17.3}/wirestudio/api/schemas.py

@@ -3,7 +3,7 @@
 """
 from __future__ import annotations
 
-from typing import Optional
+from typing import Literal, Optional
 
 from pydantic import BaseModel, ConfigDict, Field
 
@@ -12,6 +12,14 @@ class _S(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
 
+class McpTokenResponse(_S):
+    token: str = Field(description="Current MCP bearer token.")
+    managed: Literal["file", "env"] = Field(
+        description="Token source: 'file' (rotatable here) or 'env' (set via "
+        "WIRESTUDIO_MCP_TOKEN, read-only)."
+    )
+
+
 class BoardSummary(_S):
     id: str = Field(description="Board library id, e.g. 'esp32-devkitc-v4'.")
     name: str = Field(description="Human-readable board name.")

{wirestudio-0.17.2 → wirestudio-0.17.3}/wirestudio/fleet/client.py

@@ -282,6 +282,50 @@ class FleetClient:
         ]
         return RunStatus(run_id=run_id, verdict=_verdict(jobs), jobs=jobs)
 
+    # ------------------------------------------------------------------
+    # Build-artifact fetch
+    # ------------------------------------------------------------------
+
+    async def get_firmware(
+        self, run_id: str, *, factory: bool = False
+    ) -> bytes:
+        """Fetch the compiled firmware bytes for a finished build.
+
+        Mirrors the addon's artifact endpoint at
+        ``GET /ui/api/jobs/{run_id}/firmware[/factory]`` (the upstream
+        half of the headless-device flash story -- see
+        ``docs/lorawan/fleet-firmware-flash.md``). The browser never holds
+        ``FLEET_TOKEN``; this is the studio-side passthrough that fetches
+        with the server token and re-streams the bytes to the WebSerial
+        flasher via the matching studio route.
+
+        ``factory=False`` (default) fetches the app image (re-flash that
+        preserves NVS); ``factory=True`` fetches the merged factory image
+        for blank-board flashing at offset 0x0. 404 -> ``FleetUnavailable``
+        the same way ``get_job_log`` handles unknown run_ids, so the UI
+        can stop polling.
+
+        The upstream endpoint does not exist yet at the time of writing
+        (it's the scoped fleet half); calls will 502 via the matching
+        studio route until the addon ships it. That gates the dialog's
+        "Flash via WebSerial" button on the upstream rollout without
+        changing this client surface later.
+        """
+        if not self.is_configured():
+            raise FleetUnavailable("FLEET_URL or FLEET_TOKEN missing")
+        suffix = "/factory" if factory else ""
+        async with self._client() as c:
+            resp = await c.get(f"/ui/api/jobs/{run_id}/firmware{suffix}")
+        if resp.status_code == 404:
+            raise FleetUnavailable(
+                f"firmware artifact not available for run_id {run_id!r}"
+            )
+        if resp.status_code >= 400:
+            raise FleetUnavailable(
+                f"firmware fetch failed: http {resp.status_code} {resp.text}"
+            )
+        return resp.content
+
     # ------------------------------------------------------------------
     # Internals
     # ------------------------------------------------------------------

{wirestudio-0.17.2 → wirestudio-0.17.3}/wirestudio/mcp/__init__.py

@@ -8,6 +8,9 @@ into the existing FastAPI app at `/mcp` over the Streamable HTTP transport.
 from wirestudio.mcp.auth import (
     DEFAULT_TOKEN_PATH,
     BearerTokenMiddleware,
+    TokenManagedError,
+    TokenStore,
+    load_token_store,
     resolve_token,
 )
 from wirestudio.mcp.server import build_mcp_server
@@ -15,6 +18,9 @@ from wirestudio.mcp.server import build_mcp_server
 __all__ = [
     "BearerTokenMiddleware",
     "DEFAULT_TOKEN_PATH",
+    "TokenManagedError",
+    "TokenStore",
     "build_mcp_server",
+    "load_token_store",
     "resolve_token",
 ]

{wirestudio-0.17.2 → wirestudio-0.17.3}/wirestudio/mcp/auth.py

@@ -21,32 +21,83 @@ DEFAULT_TOKEN_PATH = Path(os.path.expanduser("~/.config/wirestudio/mcp-token"))
 ENV_VAR = "WIRESTUDIO_MCP_TOKEN"
 
 
-def resolve_token(
+class TokenManagedError(RuntimeError):
+    """Raised when rotation is attempted on an externally-managed token.
+
+    When the token comes from `WIRESTUDIO_MCP_TOKEN` we can't rewrite it -- the
+    operator owns it (k8s Secret / sops). Rotating would only diverge the live
+    value from the secret, so we refuse.
+    """
+
+
+def _generate_and_persist(path: Path) -> str:
+    token = secrets.token_urlsafe(32)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(token)
+    path.chmod(0o600)
+    return token
+
+
+class TokenStore:
+    """Holds the live MCP bearer token so rotation takes effect without a restart.
+
+    `BearerTokenMiddleware` reads `.token` on every request rather than
+    capturing the value at construction time. `env_managed` is True when the
+    token came from the env var, in which case `rotate()` raises.
+    """
+
+    def __init__(self, *, token: str, path: Path, env_managed: bool) -> None:
+        self._token = token
+        self._path = path
+        self.env_managed = env_managed
+
+    @property
+    def token(self) -> str:
+        return self._token
+
+    def rotate(self) -> str:
+        if self.env_managed:
+            raise TokenManagedError(
+                f"token is set via {ENV_VAR}; rotate it by updating that secret, not here"
+            )
+        self._token = _generate_and_persist(self._path)
+        logger.info("Rotated MCP token; persisted to %s", self._path)
+        return self._token
+
+
+def load_token_store(
     *,
     env_var: str = ENV_VAR,
     token_path: Path | None = None,
-) -> str:
-    """Return the MCP bearer token, generating + persisting one on first call.
+) -> TokenStore:
+    """Resolve the MCP bearer token into a mutable store.
 
     The env var wins if set (operators using k8s Secrets / sops set this and
     the token-file path is ignored). Otherwise the persisted file is read.
     Otherwise a fresh token is generated, persisted with mode 0600, and the
     path is logged at INFO so the operator knows where to copy it from.
     """
+    path = token_path or DEFAULT_TOKEN_PATH
+
     env_token = os.environ.get(env_var)
     if env_token:
-        return env_token.strip()
+        return TokenStore(token=env_token.strip(), path=path, env_managed=True)
 
-    path = token_path or DEFAULT_TOKEN_PATH
     if path.exists():
-        return path.read_text().strip()
+        return TokenStore(token=path.read_text().strip(), path=path, env_managed=False)
 
-    token = secrets.token_urlsafe(32)
-    path.parent.mkdir(parents=True, exist_ok=True)
-    path.write_text(token)
-    path.chmod(0o600)
+    token = _generate_and_persist(path)
     logger.info("Generated MCP token; copy it from %s", path)
-    return token
+    return TokenStore(token=token, path=path, env_managed=False)
+
+
+def resolve_token(
+    *,
+    env_var: str = ENV_VAR,
+    token_path: Path | None = None,
+) -> str:
+    """Return the current MCP bearer token. See `load_token_store`."""
+    return load_token_store(env_var=env_var, token_path=token_path).token
 
 
 class BearerTokenMiddleware:
@@ -59,9 +110,9 @@ class BearerTokenMiddleware:
     only gates the MCP endpoint, not the rest of the API.
     """
 
-    def __init__(self, app: ASGIApp, *, token: str, path_prefix: str = "/mcp") -> None:
+    def __init__(self, app: ASGIApp, *, store: TokenStore, path_prefix: str = "/mcp") -> None:
         self.app = app
-        self._token = token
+        self._store = store
         # Regex match: prefix as a path component (preceded by "/" or start,
         # followed by "/" or end). We can't compare scope[path] literally
         # because Starlette's nested Mount('/') doesn't strip path
@@ -88,7 +139,7 @@ class BearerTokenMiddleware:
         auth = headers.get(b"authorization", b"").decode("latin-1", errors="ignore")
         prefix = "Bearer "
         if not auth.startswith(prefix) or not secrets.compare_digest(
-            auth[len(prefix):], self._token
+            auth[len(prefix):], self._store.token
         ):
             await _send_401(send)
             return

{wirestudio-0.17.2 → wirestudio-0.17.3/wirestudio.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wirestudio
-Version: 0.17.2
+Version: 0.17.3
 Summary: Agent-driven IoT device design tool that produces ESPHome YAML.
 Author: wirestudio contributors
 License: MIT