flywheel-bootstrap-staging 0.1.9.202601272054__py3-none-any.whl

bootstrap/payload.py

@@ -0,0 +1,119 @@
+"""Bootstrap payload fetch/validation (skeleton)."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+import time
+import urllib.request
+import urllib.error
+import ssl
+import http.client
+from typing import Any, Mapping
+
+
+@dataclass
+class RepoContext:
+    """Repository context for code persistence.
+
+    Mirrors the core.models.RepoContext class but is a standalone
+    definition to avoid tight coupling between bootstrap and core.
+    """
+
+    repo_url: str
+    repo_owner: str
+    repo_name: str
+    branch_name: str
+    base_branch: str
+    is_fork: bool = False
+    fork_source_url: str | None = None
+    base_commit_sha: str | None = None
+    head_commit_sha: str | None = None
+
+    @classmethod
+    def from_dict(cls, payload: Mapping[str, Any]) -> "RepoContext":
+        return cls(
+            repo_url=str(payload["repo_url"]),
+            repo_owner=str(payload["repo_owner"]),
+            repo_name=str(payload["repo_name"]),
+            branch_name=str(payload["branch_name"]),
+            base_branch=str(payload["base_branch"]),
+            is_fork=bool(payload.get("is_fork", False)),
+            fork_source_url=payload.get("fork_source_url"),
+            base_commit_sha=payload.get("base_commit_sha"),
+            head_commit_sha=payload.get("head_commit_sha"),
+        )
+
+
+@dataclass
+class BootstrapPayload:
+    """Representation of the backend bootstrap payload."""
+
+    prompt: str
+    repo_context: RepoContext | None = None
+    github_token: str | None = None
+
+
+def fetch_bootstrap_payload(
+    server_url: str,
+    run_id: str,
+    token: str,
+) -> BootstrapPayload:
+    """Retrieve bootstrap payload from the backend server.
+
+    Raises:
+        NotImplementedError: placeholder until HTTP wiring is added.
+    """
+
+    url = f"{server_url.rstrip('/')}/runs/{run_id}/bootstrap"
+    req = urllib.request.Request(url, headers={"X-Run-Token": token})
+    payload = _urlopen_json_with_retries(
+        req,
+        timeout_seconds=30,
+        attempts=6,
+        base_delay_seconds=0.5,
+    )
+    inner = payload.get("payload", {})
+
+    # Parse repo context if present
+    repo_context = None
+    if inner.get("repo_context"):
+        repo_context = RepoContext.from_dict(inner["repo_context"])
+
+    return BootstrapPayload(
+        prompt=str(inner.get("prompt", "")),
+        repo_context=repo_context,
+        github_token=inner.get("github_token"),
+    )
+
+
+def _urlopen_json_with_retries(
+    req: urllib.request.Request,
+    timeout_seconds: int,
+    attempts: int,
+    base_delay_seconds: float,
+) -> dict:
+    """Best-effort JSON fetch with retries.
+
+    Fly.io apps can be cold-started (min_machines_running=0), and network edges
+    can occasionally drop connections. This helper retries common transient
+    failures with exponential backoff.
+    """
+    last_exc: Exception | None = None
+    for i in range(attempts):
+        try:
+            with urllib.request.urlopen(req, timeout=timeout_seconds) as resp:
+                return json.loads(resp.read().decode("utf-8"))
+        except (
+            TimeoutError,
+            urllib.error.URLError,
+            http.client.RemoteDisconnected,
+            ssl.SSLError,
+        ) as exc:
+            last_exc = exc
+            if i == attempts - 1:
+                break
+            delay = base_delay_seconds * (2**i)
+            time.sleep(delay)
+    assert last_exc is not None
+    raise last_exc

bootstrap/prompts.py

@@ -0,0 +1,79 @@
+"""Prompt assembly helpers for bootstrap."""
+
+from __future__ import annotations
+
+import textwrap
+
+
+def build_prompt_text(
+    *, server_prompt: str, workspace_instructions: str, artifact_manifest: str
+) -> str:
+    """Combine base context, task prompt, and user workspace instructions."""
+
+    base_context = textwrap.dedent(
+        f"""
+        You are an autonomous engineer with FULL SYSTEM ACCESS. Your job is to complete the task by ACTUALLY EXECUTING commands and writing files—not by describing what to do.
+
+        CRITICAL: You must USE your shell and file-writing capabilities to:
+        - Create files directly (don't tell the user to save code—write it yourself)
+        - Run commands directly (don't tell the user to run something—execute it yourself)
+        - Install dependencies if needed
+        - Execute training scripts and collect results
+
+        Work autonomously until completion—there is no user to respond to questions. Execute all necessary commands yourself. The task description and workspace instructions below contain the context you need. Leverage the provided GPU hardware fully.
+
+        ARTIFACT MANIFEST (CRITICAL):
+        - The environment variable $FLYWHEEL_WORKSPACE contains the absolute path to your workspace root.
+        - When finished, write the manifest to: $FLYWHEEL_WORKSPACE/{artifact_manifest}
+        - The manifest MUST be a top-level JSON array (list). Do NOT wrap it in an object.
+        - All file paths in the manifest must be relative to $FLYWHEEL_WORKSPACE.
+        - Each entry must be an object with "artifact_type" and "payload" keys.
+
+        MANIFEST FORMAT — the file must look exactly like this (a JSON array):
+        [
+          {{"artifact_type": "text", "payload": {{"content": "Summary of results..."}}}},
+          {{"artifact_type": "image", "payload": {{"path": "plots/loss_curve.png", "format": "png"}}}},
+          {{"artifact_type": "table", "payload": {{"path": "results/metrics.csv", "format": "csv"}}}}
+        ]
+
+        IMPORTANT: The file must start with [ and end with ]. Do NOT write {{"artifacts": [...]}} or any other wrapper object.
+
+        SUPPORTED ARTIFACT TYPES (use ONLY these):
+        - "text": For text/markdown. Payload: {{"content": "..."}} or {{"path": "path/to/file.txt"}}
+        - "table": For CSV data. Payload: {{"path": "path/to/data.csv", "format": "csv"}}
+        - "json": For JSON data. Payload: {{"path": "path/to/data.json"}} or inline the object directly
+        - "image": For PNG/JPEG. Payload: {{"path": "path/to/plot.png", "format": "png"}}
+        - "html": For interactive HTML (e.g., Plotly). Payload: {{"path": "path/to/chart.html"}} or {{"content": "<!doctype html>..."}}
+        - "vega": For Vega/Vega-Lite specs. Payload: {{"spec": {{...}}}} or {{"path": "path/to/chart.vl.json"}}
+
+        OUTPUT:
+        - Print concise progress updates to stdout; they will be forwarded as logs.
+
+        ARTIFACT QUALITY TIPS:
+        Before finalizing any artifact, verify it renders correctly. Common pitfalls:
+
+        Plots & Visualizations:
+        - Convert tensors to plain Python/numpy BEFORE plotting: use .detach().cpu().numpy() or .item()
+        - Verify numeric axes show numbers, not categorical labels (symptom of unconverted data)
+        - Always label axes and include a title
+        - For Plotly HTML, save with include_plotlyjs=True to make it self-contained
+
+        Tables & Data:
+        - Ensure consistent column types (don't mix strings and numbers in a column)
+        - Handle NaN/None values explicitly rather than leaving them as raw representations
+        - Round floats to reasonable precision for readability
+
+        General:
+        - Inspect your output files before declaring success
+        - If something looks wrong (e.g., a blank plot, garbled text), debug and fix it
+        - Prefer self-contained artifacts (inline CSS/JS, no external dependencies)
+        """
+    ).strip()
+
+    return (
+        f"{base_context}\n\n"
+        "Task Description:\n"
+        f"{server_prompt.strip()}\n\n"
+        "Workspace Instructions:\n"
+        f"{workspace_instructions.strip()}"
+    )

bootstrap/py.typed

@@ -0,0 +1 @@
+

bootstrap/runner.py

@@ -0,0 +1,145 @@
+"""Codex process launcher and stream parser (skeleton)."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Iterable, Mapping, Iterator
+import json
+import subprocess
+import sys
+
+
+@dataclass
+class CodexInvocation:
+    """Command and environment prepared for invoking codex."""
+
+    args: list[str]
+    env: Mapping[str, str]
+    workdir: Path
+    prompt: str = ""  # Prompt to pass via stdin
+    exit_code: int | None = None
+    stderr_output: str = ""  # Captured stderr for debugging
+
+
+@dataclass
+class CodexEvent:
+    """Structured event emitted by codex --json."""
+
+    raw: dict
+
+
+def build_invocation(
+    codex_executable: Path,
+    prompt: str,
+    workdir: Path,
+    env: Mapping[str, str],
+    extra_flags: Iterable[str] = (),
+) -> CodexInvocation:
+    """Assemble the codex exec command.
+
+    The prompt is written to a file in the workdir and passed via --prompt-file
+    to avoid shell argument length limits and stdin handling issues.
+    """
+    # Write prompt to file in the workdir (which Codex has access to)
+    prompt_file = workdir / "flywheel_prompt.txt"
+    prompt_file.write_text(prompt, encoding="utf-8")
+
+    # Use '-' to read prompt from stdin (avoids CLI arg length limits)
+    args = [
+        str(codex_executable),
+        "exec",
+        "--json",
+        "--cd",
+        str(workdir),
+        "--skip-git-repo-check",
+        *list(extra_flags),
+        "-",  # Read prompt from stdin
+    ]
+    return CodexInvocation(args=args, env=dict(env), workdir=workdir, prompt=prompt)
+
+
+def run_and_stream(invocation: CodexInvocation) -> Iterator[CodexEvent]:
+    """Launch codex and yield parsed events as they arrive.
+
+    The prompt is passed via file (referenced in args) to avoid stdin issues.
+    """
+    # Log the command being run (redact prompt for brevity)
+    cmd_display = " ".join(invocation.args)
+    print(f"[bootstrap] Running: {cmd_display}", file=sys.stderr)
+    print(f"[bootstrap] Workdir: {invocation.workdir}", file=sys.stderr)
+    print(f"[bootstrap] Prompt length: {len(invocation.prompt)} chars", file=sys.stderr)
+
+    # Emit command info as first event for server-side logging
+    yield CodexEvent(
+        raw={
+            "bootstrap_debug": "codex_launch",
+            "command": invocation.args,
+            "workdir": str(invocation.workdir),
+            "prompt_length": len(invocation.prompt),
+        }
+    )
+
+    try:
+        proc = subprocess.Popen(
+            invocation.args,
+            cwd=invocation.workdir,
+            env=invocation.env if invocation.env else None,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            encoding="utf-8",  # Explicit UTF-8 for cross-platform Unicode support
+            bufsize=1,
+        )
+    except Exception as e:
+        error_msg = f"Failed to start codex process: {e}"
+        print(f"[bootstrap] ERROR: {error_msg}", file=sys.stderr)
+        yield CodexEvent(raw={"bootstrap_error": error_msg})
+        invocation.exit_code = 127
+        return
+
+    assert proc.stdin is not None
+    assert proc.stdout is not None
+
+    # Write prompt to stdin and close it so Codex knows input is complete
+    try:
+        proc.stdin.write(invocation.prompt)
+        proc.stdin.close()
+    except Exception as e:
+        error_msg = f"Failed to write prompt to stdin: {e}"
+        print(f"[bootstrap] ERROR: {error_msg}", file=sys.stderr)
+        yield CodexEvent(raw={"bootstrap_error": error_msg})
+
+    for line in proc.stdout:
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            payload = json.loads(line)
+        except json.JSONDecodeError:
+            payload = {"message": line}
+        yield CodexEvent(raw=payload)
+
+    proc.wait()
+    invocation.exit_code = proc.returncode
+
+    # Always capture stderr for debugging
+    stderr_content = ""
+    if proc.stderr:
+        stderr_content = proc.stderr.read().strip()
+        invocation.stderr_output = stderr_content
+
+    # Log exit status
+    print(f"[bootstrap] Codex exited with code: {proc.returncode}", file=sys.stderr)
+    if stderr_content:
+        print(f"[bootstrap] Codex stderr:\n{stderr_content}", file=sys.stderr)
+
+    # Emit detailed exit info
+    yield CodexEvent(
+        raw={
+            "bootstrap_debug": "codex_exit",
+            "exit_code": proc.returncode,
+            "stderr": stderr_content if stderr_content else None,
+        }
+    )

bootstrap/telemetry.py

@@ -0,0 +1,147 @@
+"""Heartbeat, log, and artifact POST helpers (skeleton)."""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Mapping, Sequence
+import json
+import time
+import urllib.request
+import urllib.error
+import ssl
+import http.client
+import sys
+
+# Defaults are tuned to be tolerant of transient backend stalls.
+READ_TIMEOUT_SECONDS = 30
+MAX_ATTEMPTS = 3
+BASE_DELAY_SECONDS = 0.5
+
+
+def utcnow() -> datetime:
+    """Return a timezone-aware UTC timestamp."""
+    return datetime.now(tz=timezone.utc)
+
+
+def post_heartbeat(
+    server_url: str, run_id: str, token: str, summary: str | None
+) -> None:
+    """Send a heartbeat to the backend."""
+    _post(
+        f"{server_url.rstrip('/')}/runs/{run_id}/heartbeat",
+        token,
+        {"observed_at": utcnow().isoformat(), "summary": summary},
+    )
+
+
+def post_log(
+    server_url: str,
+    run_id: str,
+    token: str,
+    level: str,
+    message: str,
+    extra: Mapping[str, object] | None = None,
+) -> None:
+    """Send a log entry to the backend."""
+    _post(
+        f"{server_url.rstrip('/')}/runs/{run_id}/logs",
+        token,
+        {
+            "created_at": utcnow().isoformat(),
+            "level": level,
+            "message": message,
+            "extra": extra or {},
+        },
+    )
+
+
+def post_artifacts(
+    server_url: str,
+    run_id: str,
+    token: str,
+    artifacts: Sequence[Mapping[str, object]],
+) -> None:
+    """Send artifact manifest entries to the backend."""
+    for artifact in artifacts:
+        payload: Mapping[str, object] | object = artifact
+        if isinstance(artifact, Mapping):
+            inner = artifact.get("payload", artifact)
+            if isinstance(inner, Mapping):
+                payload = inner
+        _post(
+            f"{server_url.rstrip('/')}/runs/{run_id}/artifacts",
+            token,
+            {
+                "artifact_type": str(artifact.get("artifact_type", "unknown")),
+                "payload": payload,
+            },
+        )
+
+
+def post_completion(server_url: str, run_id: str, token: str, summary: str) -> None:
+    """Mark run complete."""
+    _post(
+        f"{server_url.rstrip('/')}/runs/{run_id}/complete",
+        token,
+        {"summary": summary},
+    )
+
+
+def post_error(
+    server_url: str, run_id: str, token: str, reason: str, summary: str | None = None
+) -> None:
+    """Mark run errored."""
+    _post(
+        f"{server_url.rstrip('/')}/runs/{run_id}/error",
+        token,
+        {"summary": summary or "", "reason": reason},
+    )
+
+
+def _post(url: str, token: str, body: Mapping[str, object]) -> None:
+    data = json.dumps(body).encode("utf-8")
+    req = urllib.request.Request(
+        url,
+        data=data,
+        headers={
+            "Content-Type": "application/json",
+            "X-Run-Token": token,
+        },
+        method="POST",
+    )
+    success = _urlopen_with_retries(
+        req,
+        timeout_seconds=READ_TIMEOUT_SECONDS,
+        attempts=MAX_ATTEMPTS,
+        base_delay_seconds=BASE_DELAY_SECONDS,
+    )
+    if not success:
+        # Best-effort: log locally but do not raise, to avoid failing the run on transient stalls.
+        print(f"telemetry POST to {url} failed after retries", file=sys.stderr)
+
+
+def _urlopen_with_retries(
+    req: urllib.request.Request,
+    timeout_seconds: int,
+    attempts: int,
+    base_delay_seconds: float,
+) -> bool:
+    """Best-effort POST with retries for transient network errors."""
+    for i in range(attempts):
+        try:
+            with urllib.request.urlopen(
+                req, timeout=timeout_seconds
+            ) as resp:  # pragma: no cover - network
+                resp.read()
+            return True
+        except (
+            TimeoutError,
+            urllib.error.URLError,
+            http.client.RemoteDisconnected,
+            ssl.SSLError,
+        ):
+            if i == attempts - 1:
+                break
+            delay = base_delay_seconds * (2**i)
+            time.sleep(delay)
+    return False

flywheel_bootstrap_staging-0.1.9.202601272054.dist-info/METADATA

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: flywheel-bootstrap-staging
+Version: 0.1.9.202601272054
+Summary: Bootstrap runner for Flywheel provisioned GPU instances
+Project-URL: Homepage, http://paradigma.inc/
+Author: Paradigma Labs
+License: MIT
+Keywords: bootstrap,flywheel,gpu,machine-learning,ml
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# Bootstrap
+
+This package hosts the BYOC bootstrapper that:
+
+- Ensures Codex is available (prefers release tarball; skips install if already
+  on `PATH`).
+- Fetches the bootstrap payload for a run from the Flywheel backend.
+- Launches `codex exec` with the provided prompt/config and streams logs.
+- Collects artifacts (manifest-on-exit) and reports completion or error back to
+  the backend.
+
+## Configuration
+
+Bootstrap reads the user's Codex `config.toml` and requires one of:
+
+```toml
+[flywheel]
+# inline instructions (host-specific tips, paths, sandbox notes)
+workspace_instructions = """
+Use /mnt/work as your workspace. Write artifacts under ./artifacts.
+"""
+
+# or: reference a file (relative paths are resolved against the config file directory)
+workspace_instructions_file = "workspace_notes.md"
+```
+
+Rules:
+
+- At least one of `workspace_instructions` or `workspace_instructions_file` is
+  required; otherwise bootstrap exits before contacting the server.
+- If both are set, the file wins and the inline value is ignored (warns once).
+- File contents must be non-empty; the path is resolved relative to the config
+  file if not absolute.
+
+Prompt assembly written to `flywheel_prompt.txt`:
+
+1. Flywheel engineer context (logging/artifact expectations).
+2. Task Description (prompt fetched from the server).
+3. Workspace Instructions (resolved from config as above).
+
+Example config: `project/bootstrap/examples/config.example.toml` can be used as
+a starting point; update the paths and instructions for your machine.
+
+## End-to-end flow (bootstrap.sh → Python bootstrapper)
+
+1. User runs `bash ./bootstrap.sh --run-id <id> --token <token> --config /path/to/config.toml [--server <url>]` on their BYOC machine.
+2. The shim:
+   - Ensures `uvx` is available (installs via `https://astral.sh/uv/install.sh` if missing, then rechecks PATH with `~/.cargo/bin`).
+   - Points `PKG_PATH` to the local repo copy `project/bootstrap`.
+   - Executes `uvx --no-cache --from "$PKG_PATH" flywheel-bootstrap "$@"` so the latest local package runs.
+3. Python entrypoint (`python -m bootstrap`):
+   - Parses args/env: requires run id + token, required `--config`, optional `--server` (default `http://localhost:8000`).
+   - Loads Codex config.toml, enforces presence of workspace instructions (inline or file), extracts workspace/sandbox settings.
+4. Workspace resolution:
+   - Uses `cd`/`workspace_dir` from config if set; otherwise `~/.flywheel/runs/<run_id>`.
+   - Creates the workspace and validates the artifact manifest path is inside sandbox `writable_roots` when sandboxing is enabled; else exits with an error.
+5. Codex availability:
+   - If `BOOTSTRAP_MOCK_CODEX` is set, skips install and runs a mock flow.
+   - Else, if `codex` is already on PATH, reuse it; otherwise download the Codex release tarball to the workspace/run root and mark it executable.
+6. Fetch bootstrap payload:
+   - `GET <server>/runs/<run_id>/bootstrap` with `X-Run-Token`; payload contains the task prompt.
+7. Build prompt file:
+   - Combine base Flywheel engineer context, “Task Description” (server prompt), and “Workspace Instructions” (user config) into `flywheel_prompt.txt` in the workspace.
+8. Launch Codex:
+   - Run `codex exec --json --cd <workspace> --skip-git-repo-check flywheel_prompt.txt` with env `FLYWHEEL_RUN_ID/TOKEN/SERVER`.
+   - Start a heartbeat thread posting `/runs/{id}/heartbeat` every 30s.
+   - Stream Codex stdout lines as logs to `/runs/{id}/logs`; capture Codex `run_id` if emitted.
+9. After Codex exits:
+   - Read `flywheel_artifacts.json`; if empty and Codex `run_id` is known, attempt one `codex resume <id>` then re-read.
+   - POST artifacts to `/runs/{id}/artifacts`; POST `/complete` on exit 0, else `/error` with the exit code.
+   - Stop/join the heartbeat thread.
+10. Mock mode (`BOOTSTRAP_MOCK_CODEX=1`):
+    - Sends a heartbeat, a few logs, writes a mock artifact manifest, returns 0 (used in e2e tests).
+
+## Next steps
+
+- Publish bootstrap package and switch `uvx --from` to a release URL.
+- Iterate on prompts / general polish

flywheel_bootstrap_staging-0.1.9.202601272054.dist-info/RECORD

@@ -0,0 +1,17 @@
+bootstrap/__init__.py,sha256=vRTDRRAXOf9l3PGRNGMUowKObnxFzmWCYUwtn31LzIM,39
+bootstrap/__main__.py,sha256=F94dlGd3P4icWVZnb16LjrKpBhLPCvjwqyWDqhX3JjE,1338
+bootstrap/artifacts.py,sha256=pdwDfxduT-G9VMJiGdm9MHkfUf35TzMGhFTHn135nU4,4188
+bootstrap/config_loader.py,sha256=dgypIOi4a5auGsarIDB5MI6qJO38UWO6RJkRTzvA9Zs,3936
+bootstrap/constants.py,sha256=Q3bNGvKKgQxyP9Hrx6o5GydFHwDq2SRkLnxwRNyM-OY,633
+bootstrap/git_ops.py,sha256=HPn-CAURQEMRSLJRUuy1Lor7YwPYZjb6i6ku6WhJo7M,9267
+bootstrap/install.py,sha256=Es1F0UBOYDhuv7i9veA5Bt-yyTyTZ-dAsHmGc-iRY5k,4166
+bootstrap/orchestrator.py,sha256=zWRroJSoC6rjyNS1-YAnl4frk-uCWveWO_BeQnr_iRw,33468
+bootstrap/payload.py,sha256=JugHguvdjHuoEY_wTE72PFDWlmFFgEk8_wiINNNjV_Q,3417
+bootstrap/prompts.py,sha256=jywNCfrMN30uYV6cIBSex7NxWDM9IS-y7aD_x_bj3XY,4149
+bootstrap/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+bootstrap/runner.py,sha256=qFqDnHKxUIOBAfk9cX7EipXz7mJCwTJPeKMQI30x4Do,4509
+bootstrap/telemetry.py,sha256=ONPvKTpc2puCygkakdQW7-Kkrx_yqEzZz-0FMtCQ-RQ,3983
+flywheel_bootstrap_staging-0.1.9.202601272054.dist-info/METADATA,sha256=YhfSR1Mi1W1prvFmZ1MUasmuUwv6MxeRzPj7djlD06g,4638
+flywheel_bootstrap_staging-0.1.9.202601272054.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+flywheel_bootstrap_staging-0.1.9.202601272054.dist-info/entry_points.txt,sha256=uluR7l4k_RhY5K4nYN5e6uwtceW3_7h_kvpM-csjzrg,63
+flywheel_bootstrap_staging-0.1.9.202601272054.dist-info/RECORD,,

flywheel_bootstrap_staging-0.1.9.202601272054.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

flywheel_bootstrap_staging-0.1.9.202601272054.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+flywheel-bootstrap = bootstrap.__main__:main