cli-consumption 0.4.3__tar.gz → 0.4.5__tar.gz

{cli_consumption-0.4.3 → cli_consumption-0.4.5}/CHANGELOG.md

@@ -6,6 +6,21 @@ use [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [0.4.5] - 2026-09-11
+
+### Added
+
+- `serve --front` now launches the FastAPI service and a bundled production Next.js
+  dashboard from the Python distribution, without requiring a repository checkout or
+  npm installation at runtime.
+
+## [0.4.4] - 2026-09-08
+
+### Fixed
+
+- Mistral Vibe now counts each persisted assistant message as a model call while
+  retaining cumulative session tokens as one unsplit aggregate.
+
 ## [0.4.3] - 2026-09-05
 
 ### Added
@@ -194,7 +209,9 @@ use [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 - Refreshed the provider guide for the first minor release ([#26]).
 
-[Unreleased]: https://github.com/Guillaume-Lombardo/cli-consumption/compare/v0.4.3...HEAD
+[Unreleased]: https://github.com/Guillaume-Lombardo/cli-consumption/compare/v0.4.5...HEAD
+[0.4.5]: https://github.com/Guillaume-Lombardo/cli-consumption/compare/v0.4.4...v0.4.5
+[0.4.4]: https://github.com/Guillaume-Lombardo/cli-consumption/compare/v0.4.3...v0.4.4
 [0.4.3]: https://github.com/Guillaume-Lombardo/cli-consumption/compare/v0.4.2...v0.4.3
 [0.4.2]: https://github.com/Guillaume-Lombardo/cli-consumption/compare/v0.4.1...v0.4.2
 [0.4.1]: https://github.com/Guillaume-Lombardo/cli-consumption/compare/v0.4.0...v0.4.1

{cli_consumption-0.4.3 → cli_consumption-0.4.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: cli-consumption
-Version: 0.4.3
+Version: 0.4.5
 Summary: Analyze and consolidate AI coding CLI consumption across machines.
 Project-URL: Homepage, https://github.com/Guillaume-Lombardo/cli-consumption
 Project-URL: Documentation, https://github.com/Guillaume-Lombardo/cli-consumption#readme
@@ -23,14 +23,14 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Quality Assurance
 Requires-Python: >=3.11
 Requires-Dist: alembic>=1.14
+Requires-Dist: fastapi>=0.115
 Requires-Dist: pydantic>=2.10
 Requires-Dist: sqlalchemy>=2.0
 Requires-Dist: typer>=0.15
+Requires-Dist: uvicorn>=0.34
 Provides-Extra: postgres
 Requires-Dist: psycopg[binary]>=3.2; extra == 'postgres'
 Provides-Extra: server
-Requires-Dist: fastapi>=0.115; extra == 'server'
-Requires-Dist: uvicorn>=0.34; extra == 'server'
 Provides-Extra: snapshots
 Requires-Dist: cryptography>=45; extra == 'snapshots'
 Provides-Extra: sync
@@ -72,16 +72,14 @@ CLI Consumption requires Python 3.11 or newer. Run it directly from PyPI with `u
 uv tool run cli-consumption providers
 ```
 
-The default package covers local collection, SQLite storage, and exports. Install only
-the optional runtime capabilities you use:
+The default package covers local collection, SQLite storage, exports, and the local
+HTTP server. Install only the optional runtime capabilities you use:
 
 - `cli-consumption[sync]` for the sync client;
-- `cli-consumption[server]` for the collector service;
 - `cli-consumption[postgres]` for PostgreSQL;
 - `cli-consumption[snapshots]` for signed, compressed offline snapshot files.
 
-Extras can be combined, for example `cli-consumption[server,postgres]` on a central
-collector.
+Extras can be combined, for example `cli-consumption[postgres]` on a central collector.
 
 ## Quick start
 
@@ -100,7 +98,7 @@ tables are generated only when `--csv` is passed.
 Dashboard development lives in the locked npm workspace under `packages/`. It builds
 provider-neutral ESM analytics, shared React presentation primitives, and deterministic
 React/Tailwind browser assets that Python embeds in the wheel. The React runtime is the
-only offline renderer; installing or using the Python CLI does not require Node.js.
+only offline renderer; collection and offline reporting do not require Node.js.
 
 The authenticated persistent dashboard lives in `apps/web/`. It reads the same
 minimized reporting contract through a server-side Next.js BFF: the browser never
@@ -186,6 +184,11 @@ Run `uv run cli-consumption COMMAND --help` for every option. The
 [usage guide](https://github.com/Guillaume-Lombardo/cli-consumption/blob/main/docs/usage.md)
 contains copy-ready examples.
 
+To run the API and bundled persistent dashboard together, install Node.js 20.9 or
+newer and use `uv tool run cli-consumption serve --front`. The command asks for a
+dashboard password when `CLI_CONSUMPTION_DASHBOARD_PASSWORD` is not set; it does not
+require a repository checkout or npm install.
+
 ## Documentation
 
 - [Usage and operations](https://github.com/Guillaume-Lombardo/cli-consumption/blob/main/docs/usage.md)

{cli_consumption-0.4.3 → cli_consumption-0.4.5}/README.md

@@ -33,16 +33,14 @@ CLI Consumption requires Python 3.11 or newer. Run it directly from PyPI with `u
 uv tool run cli-consumption providers
 ```
 
-The default package covers local collection, SQLite storage, and exports. Install only
-the optional runtime capabilities you use:
+The default package covers local collection, SQLite storage, exports, and the local
+HTTP server. Install only the optional runtime capabilities you use:
 
 - `cli-consumption[sync]` for the sync client;
-- `cli-consumption[server]` for the collector service;
 - `cli-consumption[postgres]` for PostgreSQL;
 - `cli-consumption[snapshots]` for signed, compressed offline snapshot files.
 
-Extras can be combined, for example `cli-consumption[server,postgres]` on a central
-collector.
+Extras can be combined, for example `cli-consumption[postgres]` on a central collector.
 
 ## Quick start
 
@@ -61,7 +59,7 @@ tables are generated only when `--csv` is passed.
 Dashboard development lives in the locked npm workspace under `packages/`. It builds
 provider-neutral ESM analytics, shared React presentation primitives, and deterministic
 React/Tailwind browser assets that Python embeds in the wheel. The React runtime is the
-only offline renderer; installing or using the Python CLI does not require Node.js.
+only offline renderer; collection and offline reporting do not require Node.js.
 
 The authenticated persistent dashboard lives in `apps/web/`. It reads the same
 minimized reporting contract through a server-side Next.js BFF: the browser never
@@ -147,6 +145,11 @@ Run `uv run cli-consumption COMMAND --help` for every option. The
 [usage guide](https://github.com/Guillaume-Lombardo/cli-consumption/blob/main/docs/usage.md)
 contains copy-ready examples.
 
+To run the API and bundled persistent dashboard together, install Node.js 20.9 or
+newer and use `uv tool run cli-consumption serve --front`. The command asks for a
+dashboard password when `CLI_CONSUMPTION_DASHBOARD_PASSWORD` is not set; it does not
+require a repository checkout or npm install.
+
 ## Documentation
 
 - [Usage and operations](https://github.com/Guillaume-Lombardo/cli-consumption/blob/main/docs/usage.md)

{cli_consumption-0.4.3 → cli_consumption-0.4.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "cli-consumption"
-version = "0.4.3"
+version = "0.4.5"
 description = "Analyze and consolidate AI coding CLI consumption across machines."
 readme = "README.md"
 requires-python = ">=3.11"
@@ -25,14 +25,16 @@ classifiers = [
 ]
 dependencies = [
   "alembic>=1.14",
+  "fastapi>=0.115",
   "pydantic>=2.10",
   "sqlalchemy>=2.0",
   "typer>=0.15",
+  "uvicorn>=0.34",
 ]
 
 [project.optional-dependencies]
 postgres = ["psycopg[binary]>=3.2"]
-server = ["fastapi>=0.115", "uvicorn>=0.34"]
+server = []
 sync = ["httpx>=0.27"]
 snapshots = [
     "cryptography>=45",
@@ -108,6 +110,7 @@ select = ["E", "F", "I", "UP", "B", "SIM", "RUF", "S"]
 "src/cli_consumption/api.py" = ["S608"]
 "src/cli_consumption/cli.py" = ["S107"]
 "src/cli_consumption/dashboard.py" = ["E501", "S608"]
+"src/cli_consumption/frontend.py" = ["S603"]
 "tests/**" = ["S101"]
 "tests/smoke_minimal_install.py" = ["S603", "S607"]
 "tests/test_codex_adapter.py" = ["S608"]

{cli_consumption-0.4.3 → cli_consumption-0.4.5}/src/cli_consumption/adapters/mistral_vibe.py

@@ -84,6 +84,7 @@ class MistralVibeAdapter:
         started_at = timestamp(source.metadata.get("start_time"))
         ended_at = timestamp(source.metadata.get("end_time"))
         active_turn: dict[str, Any] | None = None
+        assistant_turn_ids: list[str | None] = []
         turn_number = 0
         tool_number = 0
         compaction_number = 0
@@ -125,6 +126,8 @@ class MistralVibeAdapter:
                 continue
             if active_turn is not None:
                 active_turn["status"] = "completed"
+                active_turn["model_calls"] += 1
+            assistant_turn_ids.append(active_turn["id"] if active_turn else None)
             raw_tool_calls = message.get("tool_calls")
             if not isinstance(raw_tool_calls, list):
                 continue
@@ -160,20 +163,25 @@ class MistralVibeAdapter:
         )
         config = mapping(source.metadata.get("config"))
         model = label(config.get("active_model"), 255) or "unknown"
-        model_calls = 0
         totals = empty_tokens()
-        if usage["total_tokens"] > 0 or counter(stats.get("steps")) > 0:
-            model_calls = 1
+        if usage["total_tokens"] > 0:
             add_tokens(totals, usage)
+
+        for sequence, turn_id in enumerate(assistant_turn_ids, 1):
+            call_usage = (
+                usage if sequence == len(assistant_turn_ids) else empty_tokens()
+            )
             snapshot.model_calls.append(
                 {
-                    "id": f"{conversation_id}:model:aggregate",
+                    "id": f"{conversation_id}:model:{sequence}",
                     "conversation_id": conversation_id,
-                    "turn_id": None,
-                    "sequence": 1,
-                    "timestamp": iso(ended_at),
+                    "turn_id": turn_id,
+                    "sequence": sequence,
+                    "timestamp": iso(ended_at)
+                    if sequence == len(assistant_turn_ids)
+                    else None,
                     "model": model,
-                    **usage,
+                    **call_usage,
                 }
             )
 
@@ -193,9 +201,9 @@ class MistralVibeAdapter:
                 "ended_at": iso(ended_at),
                 "duration_seconds": _duration(started_at, ended_at),
                 "source": "local-session-json",
-                "models": [model] if model_calls else [],
+                "models": [model] if assistant_turn_ids else [],
                 "iterations": turn_number,
-                "model_calls": model_calls,
+                "model_calls": len(assistant_turn_ids),
                 "tool_calls": tool_number,
                 "compactions": compaction_number,
                 "event_count": source.event_count,

{cli_consumption-0.4.3 → cli_consumption-0.4.5}/src/cli_consumption/adapters/registry.py

@@ -346,10 +346,12 @@ ADAPTER_SPECS = (
         token_semantics="conversation-aggregate",
         qualification=_qualification(
             "mistral-vibe",
-            "CLI 2.24.5",
+            "CLI 2.25.0",
             "session meta JSON and messages JSONL",
-            "https://github.com/mistralai/mistral-vibe/tree/v2.24.5",
-            "Session aggregates only; no timing or historical model attribution.",
+            "https://github.com/mistralai/mistral-vibe/tree/v2.25.0",
+            "Assistant-message call counts with session-aggregate tokens; no timing "
+            "or historical model attribution.",
+            qualified_on="2026-09-08",
         ),
     ),
     AdapterSpec(

{cli_consumption-0.4.3 → cli_consumption-0.4.5}/src/cli_consumption/cli.py

@@ -3,11 +3,15 @@ from __future__ import annotations
 import json
 import os
 import platform
+import secrets
+import subprocess
 import tempfile
-from collections.abc import Iterator
+import threading
+from collections.abc import Callable, Iterator
 from datetime import UTC, datetime, timedelta
 from pathlib import Path
-from typing import Annotated, Never, TextIO, TypedDict
+from types import ModuleType
+from typing import Annotated, Never, Protocol, TextIO, TypedDict, cast
 
 import typer
 from sqlalchemy.engine import Engine
@@ -79,6 +83,12 @@ class IncrementalIngestion(TypedDict):
     batch_duplicates: int
 
 
+class _ServerProcess(Protocol):
+    should_exit: bool
+
+    def run(self) -> None: ...
+
+
 class _BoundedStagingWriter:
     """Count UTF-8 metadata bytes before writing them to strict staging."""
 
@@ -1038,17 +1048,42 @@ def serve(
             help="Environment variable containing the dashboard layout mutation token."
         ),
     ] = "CLI_CONSUMPTION_LAYOUT_TOKEN",
+    front: Annotated[
+        bool,
+        typer.Option(help="Also run the bundled persistent Next.js dashboard."),
+    ] = False,
+    front_host: Annotated[
+        str,
+        typer.Option(help="Loopback address for the bundled dashboard."),
+    ] = "127.0.0.1",
+    front_port: Annotated[
+        int,
+        typer.Option(help="Port for the bundled dashboard."),
+    ] = 3000,
+    front_password_env: Annotated[
+        str,
+        typer.Option(
+            help="Environment variable containing the dashboard login password."
+        ),
+    ] = "CLI_CONSUMPTION_DASHBOARD_PASSWORD",
 ) -> None:
-    """Run the optional central HTTP collector."""
+    """Run the central HTTP collector and optionally its dashboard."""
     try:
         import uvicorn
 
         from cli_consumption.api import create_app
     except ModuleNotFoundError:
         raise typer.BadParameter(
-            "serve requires optional dependencies; install cli-consumption[server]"
+            "serve requires FastAPI and Uvicorn; reinstall cli-consumption"
         ) from None
 
+    if front and front_host not in {"127.0.0.1", "localhost", "::1"}:
+        raise typer.BadParameter("--front-host must be a loopback address.")
+    if front and port == front_port:
+        raise typer.BadParameter("--port and --front-port must be different.")
+    if not 1 <= port <= 65535 or not 1 <= front_port <= 65535:
+        raise typer.BadParameter("Server ports must be between 1 and 65535.")
+
     token = os.environ.get(token_env)
     read_token = os.environ.get(read_token_env)
     export_token = os.environ.get(export_token_env)
@@ -1057,6 +1092,10 @@ def serve(
         raise typer.BadParameter(
             "Configured token environment variables must be non-empty."
         )
+    if front:
+        read_token = read_token or secrets.token_urlsafe(32)
+        export_token = export_token or secrets.token_urlsafe(32)
+        layout_token = layout_token or secrets.token_urlsafe(32)
     if (
         token is None
         and read_token is None
@@ -1090,11 +1129,153 @@ def serve(
                 layout_token=layout_token,
             )
         )
-        uvicorn.run(application, host=host, port=port, access_log=False)
+        if not front:
+            uvicorn.run(application, host=host, port=port, access_log=False)
+            return
+        _serve_with_frontend(
+            uvicorn,
+            application,
+            host=host,
+            port=port,
+            front_host=front_host,
+            front_port=front_port,
+            front_password_env=front_password_env,
+            read_token=cast(str, read_token),
+            export_token=cast(str, export_token),
+            layout_token=cast(str, layout_token),
+        )
     finally:
         engine.dispose()
 
 
+def _serve_with_frontend(
+    uvicorn: ModuleType,
+    application: object,
+    *,
+    host: str,
+    port: int,
+    front_host: str,
+    front_port: int,
+    front_password_env: str,
+    read_token: str,
+    export_token: str,
+    layout_token: str,
+) -> None:
+    from cli_consumption.frontend import (
+        FrontendRuntimeError,
+        find_node_runtime,
+        frontend_environment,
+        materialize_frontend_runtime,
+        start_frontend,
+        stop_frontend,
+    )
+
+    password = os.environ.get(front_password_env)
+    if password is None:
+        password = typer.prompt("Dashboard password", hide_input=True)
+    if len(password) < 12:
+        raise typer.BadParameter(
+            f"{front_password_env} must contain at least 12 characters."
+        )
+    session_secret = os.environ.get("CLI_CONSUMPTION_SESSION_SECRET")
+    if session_secret is not None and len(session_secret.encode("utf-8")) < 32:
+        raise typer.BadParameter(
+            "CLI_CONSUMPTION_SESSION_SECRET must contain at least 32 bytes."
+        )
+    session_secret = session_secret or secrets.token_urlsafe(32)
+    api_host = {
+        "0.0.0.0": "127.0.0.1",  # noqa: S104 - converts an explicit bind address
+        "::": "::1",
+    }.get(host, host)
+    api_origin = _http_origin(api_host, port)
+    front_origin = _http_origin(front_host, front_port)
+
+    try:
+        node = find_node_runtime()
+        environment = frontend_environment(
+            api_url=api_origin,
+            origin=front_origin,
+            host=front_host,
+            port=front_port,
+            password=password,
+            read_token=read_token,
+            export_token=export_token,
+            layout_token=layout_token,
+            session_secret=session_secret,
+        )
+        with materialize_frontend_runtime() as runtime:
+            frontend = start_frontend(node, runtime, environment)
+            typer.echo(f"Dashboard: {front_origin}")
+            _supervise_servers(
+                uvicorn,
+                application,
+                frontend,
+                host=host,
+                port=port,
+                stop_frontend=stop_frontend,
+            )
+    except FrontendRuntimeError as error:
+        messages = {
+            "frontend_node_missing": "serve --front requires Node.js 20.9 or newer.",
+            "frontend_node_invalid": "The Node.js runtime could not be validated.",
+            "frontend_node_unsupported": (
+                "serve --front requires Node.js 20.9 or newer."
+            ),
+            "frontend_runtime_missing": "The bundled dashboard runtime is missing.",
+            "frontend_runtime_invalid": "The bundled dashboard runtime is invalid.",
+            "frontend_start_failed": "The bundled dashboard could not be started.",
+            "frontend_stop_failed": "The bundled dashboard could not be stopped.",
+        }
+        typer.echo(f"Error: {messages[str(error)]}", err=True)
+        raise typer.Exit(1) from None
+
+
+def _supervise_servers(
+    uvicorn: ModuleType,
+    application: object,
+    frontend: subprocess.Popen[bytes],
+    *,
+    host: str,
+    port: int,
+    stop_frontend: Callable[[subprocess.Popen[bytes]], None],
+) -> None:
+    server = uvicorn.Server(
+        uvicorn.Config(application, host=host, port=port, access_log=False)
+    )
+    failures: list[BaseException] = []
+
+    def run_backend() -> None:
+        try:
+            server.run()
+        except BaseException as error:
+            failures.append(error)
+
+    backend = threading.Thread(target=run_backend, name="cli-consumption-api")
+    backend.start()
+    frontend_failed = False
+    try:
+        while backend.is_alive() and frontend.poll() is None:
+            backend.join(timeout=0.1)
+        frontend_failed = frontend.poll() is not None and backend.is_alive()
+    except KeyboardInterrupt:
+        pass
+    finally:
+        server.should_exit = True
+        stop_frontend(frontend)
+        backend.join(timeout=10)
+    if backend.is_alive() or failures:
+        typer.echo("Error: The API server stopped unexpectedly.", err=True)
+        raise typer.Exit(1)
+    if frontend_failed:
+        typer.echo("Error: The dashboard server stopped unexpectedly.", err=True)
+        raise typer.Exit(1)
+
+
+def _http_origin(host: str, port: int) -> str:
+    rendered_host = f"[{host}]" if ":" in host else host
+    return f"http://{rendered_host}:{port}"
+
+
 def _collect_incrementally(
     provider: str,
     source_values: list[str] | None,

cli_consumption-0.4.5/src/cli_consumption/frontend.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+import io
+import os
+import re
+import shutil
+import subprocess
+import tempfile
+import zipfile
+from collections.abc import Iterator, Mapping
+from contextlib import contextmanager
+from importlib.resources import files
+from pathlib import Path, PurePosixPath
+
+MAX_RUNTIME_FILES = 5_000
+MAX_RUNTIME_BYTES = 128 * 1024 * 1024
+MAX_RUNTIME_ARCHIVE_BYTES = 32 * 1024 * 1024
+MINIMUM_NODE = (20, 9)
+
+
+class FrontendRuntimeError(RuntimeError):
+    """A fixed, content-free dashboard runtime failure."""
+
+
+def find_node_runtime() -> str:
+    node = shutil.which("node")
+    if node is None:
+        raise FrontendRuntimeError("frontend_node_missing")
+    try:
+        result = subprocess.run(
+            [node, "--version"],
+            check=False,
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+    except (OSError, subprocess.SubprocessError):
+        raise FrontendRuntimeError("frontend_node_invalid") from None
+    match = re.fullmatch(r"v(\d+)\.(\d+)\.\d+\s*", result.stdout)
+    if result.returncode != 0 or match is None:
+        raise FrontendRuntimeError("frontend_node_invalid")
+    if (int(match.group(1)), int(match.group(2))) < MINIMUM_NODE:
+        raise FrontendRuntimeError("frontend_node_unsupported")
+    return node
+
+
+@contextmanager
+def materialize_frontend_runtime() -> Iterator[Path]:
+    try:
+        payload = files("cli_consumption").joinpath("web_runtime.zip").read_bytes()
+    except (FileNotFoundError, OSError):
+        raise FrontendRuntimeError("frontend_runtime_missing") from None
+
+    if len(payload) > MAX_RUNTIME_ARCHIVE_BYTES:
+        raise FrontendRuntimeError("frontend_runtime_invalid")
+
+    with tempfile.TemporaryDirectory(prefix="cli-consumption-web-") as directory:
+        destination = Path(directory)
+        try:
+            with zipfile.ZipFile(io.BytesIO(payload)) as archive:
+                members = archive.infolist()
+                if (
+                    len(members) > MAX_RUNTIME_FILES
+                    or len({member.filename for member in members}) != len(members)
+                    or sum(member.file_size for member in members) > MAX_RUNTIME_BYTES
+                    or any(not _safe_runtime_member(member) for member in members)
+                ):
+                    raise FrontendRuntimeError("frontend_runtime_invalid")
+                for member in members:
+                    target = destination.joinpath(*PurePosixPath(member.filename).parts)
+                    target.parent.mkdir(parents=True, exist_ok=True)
+                    with archive.open(member) as source, target.open("wb") as output:
+                        shutil.copyfileobj(source, output)
+        except (OSError, zipfile.BadZipFile):
+            raise FrontendRuntimeError("frontend_runtime_invalid") from None
+        runtime = destination / "runtime" / "apps" / "web"
+        if not (runtime / "server.js").is_file():
+            raise FrontendRuntimeError("frontend_runtime_invalid")
+        yield runtime
+
+
+def frontend_environment(
+    *,
+    api_url: str,
+    origin: str,
+    host: str,
+    port: int,
+    password: str,
+    read_token: str,
+    export_token: str,
+    layout_token: str,
+    session_secret: str,
+) -> dict[str, str]:
+    environment = {
+        name: value
+        for name in ("LANG", "LC_ALL", "PATH", "TMPDIR")
+        if (value := os.environ.get(name)) is not None
+    }
+    environment.update(
+        {
+            "CLI_CONSUMPTION_API_URL": api_url,
+            "CLI_CONSUMPTION_DASHBOARD_ORIGIN": origin,
+            "CLI_CONSUMPTION_DASHBOARD_PASSWORD": password,
+            "CLI_CONSUMPTION_EXPORT_TOKEN": export_token,
+            "CLI_CONSUMPTION_LAYOUT_TOKEN": layout_token,
+            "CLI_CONSUMPTION_READ_TOKEN": read_token,
+            "CLI_CONSUMPTION_SESSION_SECRET": session_secret,
+            "HOSTNAME": host,
+            "NEXT_TELEMETRY_DISABLED": "1",
+            "PORT": str(port),
+        }
+    )
+    return environment
+
+
+def start_frontend(
+    node: str, runtime: Path, environment: Mapping[str, str]
+) -> subprocess.Popen[bytes]:
+    try:
+        return subprocess.Popen(
+            [node, "server.js"],
+            cwd=runtime,
+            env=dict(environment),
+        )
+    except OSError:
+        raise FrontendRuntimeError("frontend_start_failed") from None
+
+
+def stop_frontend(process: subprocess.Popen[bytes]) -> None:
+    try:
+        if process.poll() is not None:
+            return
+        process.terminate()
+        try:
+            process.wait(timeout=5)
+        except subprocess.TimeoutExpired:
+            process.kill()
+            process.wait(timeout=5)
+    except (OSError, subprocess.SubprocessError):
+        raise FrontendRuntimeError("frontend_stop_failed") from None
+
+
+def _safe_runtime_member(member: zipfile.ZipInfo) -> bool:
+    path = PurePosixPath(member.filename)
+    file_type = member.external_attr >> 16 & 0o170000
+    return (
+        not member.is_dir()
+        and "\\" not in member.filename
+        and not path.is_absolute()
+        and path.parts[:1] == ("runtime",)
+        and ".." not in path.parts
+        and file_type in {0, 0o100000}
+    )