flywheel-bootstrap-staging 0.1.9.202601291439__tar.gz

flywheel_bootstrap_staging-0.1.9.202601291439/.gitignore

@@ -0,0 +1,222 @@
+# repo-specific
+data/
+.zshrc
+.moebial/
+# Byte-compiled / optimized / DLL files
+.DS_Store
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+config_new.toml
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#   Usually these files are written by a python script from a template
+#   before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+# Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+# uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+# poetry.lock
+# poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+# pdm.lock
+# pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+# pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# Redis
+*.rdb
+*.aof
+*.pid
+
+# RabbitMQ
+mnesia/
+rabbitmq/
+rabbitmq-data/
+
+# ActiveMQ
+activemq-data/
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.vercel/
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#   JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#   be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#   and can be added to the global gitignore or merged into this file.  For a more nuclear
+#   option (not recommended) you can uncomment the following to ignore the entire idea folder.
+# .idea/
+
+# Abstra
+#   Abstra is an AI-powered process automation framework.
+#   Ignore directories containing user credentials, local state, and settings.
+#   Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#   Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#   that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#   and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#   you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+# Streamlit
+.streamlit/secrets.toml

flywheel_bootstrap_staging-0.1.9.202601291439/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: flywheel-bootstrap-staging
+Version: 0.1.9.202601291439
+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.202601291439/README.md

@@ -0,0 +1,78 @@
+# 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.202601291439/bootstrap/__init__.py

@@ -0,0 +1,3 @@
+"""Bootstrap package."""
+
+__all__ = []

flywheel_bootstrap_staging-0.1.9.202601291439/bootstrap/__main__.py

@@ -0,0 +1,48 @@
+"""CLI entry point for the bootstrap flow.
+
+Usage (placeholder):
+    python -m bootstrap --run-id <id> --token <token> --config /path/to/config.toml
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+from bootstrap.orchestrator import BootstrapOrchestrator, build_config
+
+
+def _parse_args(argv: list[str]) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Flywheel BYOC bootstrapper")
+    parser.add_argument(
+        "--run-id",
+        help="Run identifier issued by the Flywheel backend (falls back to FLYWHEEL_RUN_ID)",
+        default=None,
+    )
+    parser.add_argument(
+        "--token",
+        help="Capability token for authenticating to the backend (or FLYWHEEL_RUN_TOKEN)",
+        default=None,
+    )
+    parser.add_argument(
+        "--server",
+        help="Backend base URL (default: http://localhost:8000 or FLYWHEEL_SERVER)",
+        default=None,
+    )
+    parser.add_argument(
+        "--config",
+        help="Path to the Codex config.toml file",
+        required=True,
+    )
+    return parser.parse_args(argv)
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = _parse_args(argv or sys.argv[1:])
+    config = build_config(args)
+    orchestrator = BootstrapOrchestrator(config)
+    return orchestrator.run()
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

flywheel_bootstrap_staging-0.1.9.202601291439/bootstrap/artifacts.py

@@ -0,0 +1,101 @@
+"""Artifact manifest helpers."""
+
+from __future__ import annotations
+
+import json
+import logging
+from dataclasses import dataclass
+from enum import Enum
+from pathlib import Path
+from typing import Mapping, Sequence
+
+logger = logging.getLogger(__name__)
+
+
+class ManifestStatus(Enum):
+    """Outcome of reading the artifact manifest."""
+
+    MISSING = "missing"
+    VALID = "valid"
+    MALFORMED = "malformed"
+
+
+@dataclass
+class ManifestResult:
+    """Result of reading the artifact manifest, with diagnostic info."""
+
+    status: ManifestStatus
+    artifacts: Sequence[Mapping[str, object]]
+    error: str | None = None
+
+
+def read_manifest(manifest_path: Path) -> ManifestResult:
+    """Load artifact entries from the manifest path.
+
+    Tolerant of common LLM output variations:
+    - A well-formed JSON list is returned as-is.
+    - A dict wrapping a list (e.g. ``{"artifacts": [...]}``) is unwrapped.
+    - A single artifact dict is wrapped in a list.
+    - Truncated / invalid JSON is reported as malformed.
+    - Non-dict, non-list scalars are reported as malformed.
+
+    Returns a ``ManifestResult`` carrying the parsed artifacts, the outcome
+    status, and an optional human-readable error description for feedback.
+    """
+    if not manifest_path.exists():
+        return ManifestResult(status=ManifestStatus.MISSING, artifacts=[])
+    raw = manifest_path.read_text(encoding="utf-8")
+    if not raw.strip():
+        msg = "artifact manifest file is empty"
+        logger.warning("%s: %s", msg, manifest_path)
+        return ManifestResult(status=ManifestStatus.MALFORMED, artifacts=[], error=msg)
+    try:
+        data = json.loads(raw)
+    except json.JSONDecodeError as exc:
+        msg = f"artifact manifest contains invalid JSON: {exc}"
+        logger.warning("%s: %s", msg, manifest_path)
+        return ManifestResult(status=ManifestStatus.MALFORMED, artifacts=[], error=msg)
+    return _coerce_manifest(data, manifest_path)
+
+
+def _coerce_manifest(data: object, manifest_path: Path) -> ManifestResult:
+    """Best-effort coercion of parsed JSON into a list of artifact dicts."""
+    if isinstance(data, list):
+        return ManifestResult(status=ManifestStatus.VALID, artifacts=data)
+    if isinstance(data, dict):
+        return _unwrap_dict(data, manifest_path)
+    msg = f"artifact manifest is a {type(data).__name__}, expected a JSON list"
+    logger.warning("%s: %s", msg, manifest_path)
+    return ManifestResult(status=ManifestStatus.MALFORMED, artifacts=[], error=msg)
+
+
+def _unwrap_dict(data: dict[str, object], manifest_path: Path) -> ManifestResult:
+    """Extract an artifact list from a dict, or treat it as a single artifact."""
+    # If the dict itself looks like an artifact, treat it as one.
+    # Check this BEFORE scanning for nested lists — a single artifact dict
+    # like {"artifact_type": "text", "payload": {"items": [...]}} must not
+    # have its nested list mistakenly extracted.
+    if "artifact_type" in data:
+        msg = "artifact manifest is a single artifact dict, wrapping in list"
+        logger.warning("%s: %s", msg, manifest_path)
+        return ManifestResult(
+            status=ManifestStatus.MALFORMED, artifacts=[data], error=msg
+        )
+    # Prefer the "artifacts" key if present and is a list.
+    if "artifacts" in data and isinstance(data["artifacts"], list):
+        msg = "artifact manifest wrapped in dict with 'artifacts' key, unwrapping"
+        logger.warning("%s: %s", msg, manifest_path)
+        return ManifestResult(
+            status=ManifestStatus.MALFORMED, artifacts=data["artifacts"], error=msg
+        )
+    # Fall back to the first value that is a list.
+    for key, value in data.items():
+        if isinstance(value, list):
+            msg = f"artifact manifest wrapped in dict with '{key}' key, unwrapping"
+            logger.warning("%s: %s", msg, manifest_path)
+            return ManifestResult(
+                status=ManifestStatus.MALFORMED, artifacts=value, error=msg
+            )
+    msg = "artifact manifest is a dict with no recognisable artifact data"
+    logger.warning("%s: %s", msg, manifest_path)
+    return ManifestResult(status=ManifestStatus.MALFORMED, artifacts=[], error=msg)

flywheel_bootstrap_staging-0.1.9.202601291439/bootstrap/config_loader.py

@@ -0,0 +1,122 @@
+"""Codex config parsing helpers (skeleton)."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Mapping
+import tomllib
+
+
+@dataclass
+class UserConfig:
+    """Parsed subset of Codex config relevant to bootstrap."""
+
+    raw: Mapping[str, Any]
+    working_dir: Path | None
+    sandbox_mode: str | None
+    approval_policy: str | None
+    oss_provider: str | None
+    writable_roots: tuple[Path, ...]
+    workspace_instructions: str
+    instructions_source: str
+    warnings: tuple[str, ...] = ()
+
+
+def load_codex_config(path: Path) -> UserConfig:
+    """Load and extract relevant fields from the user's Codex config."""
+
+    with path.open("rb") as fp:
+        data = tomllib.load(fp)
+
+    flywheel_raw = data.get("flywheel")
+    flywheel_section: Mapping[str, Any] = (
+        flywheel_raw if isinstance(flywheel_raw, Mapping) else {}
+    )
+
+    inline_instructions = _get_str(flywheel_section, "workspace_instructions")
+    instructions_file = _get_path(flywheel_section, "workspace_instructions_file", path)
+
+    warnings: list[str] = []
+    if instructions_file is not None and inline_instructions:
+        warnings.append(
+            "workspace_instructions ignored because workspace_instructions_file is set"
+        )
+
+    if instructions_file is not None:
+        try:
+            instructions_text = instructions_file.read_text(encoding="utf-8").strip()
+        except FileNotFoundError as exc:
+            raise SystemExit(
+                f"workspace_instructions_file not found: {instructions_file}"
+            ) from exc
+        if not instructions_text:
+            raise SystemExit(
+                f"workspace_instructions_file is empty: {instructions_file}"
+            )
+        source = "file"
+    else:
+        instructions_text = inline_instructions.strip() if inline_instructions else ""
+        source = "inline"
+
+    if not instructions_text:
+        raise SystemExit(
+            "workspace instructions are required; set [flywheel].workspace_instructions "
+            "or [flywheel].workspace_instructions_file"
+        )
+
+    # Best-effort extraction; Codex config schema may evolve.
+    working_dir = _get_path(data, "cd") or _get_path(data, "workspace_dir")
+    sandbox_mode = (
+        data.get("sandbox_mode") if isinstance(data.get("sandbox_mode"), str) else None
+    )
+    approval_policy = (
+        data.get("approval_policy")
+        if isinstance(data.get("approval_policy"), str)
+        else None
+    )
+    oss_provider = (
+        data.get("oss_provider") if isinstance(data.get("oss_provider"), str) else None
+    )
+
+    writable_roots: tuple[Path, ...] = tuple()
+    sandbox_write = data.get("sandbox_workspace_write")
+    if isinstance(sandbox_write, dict):
+        roots = sandbox_write.get("writable_roots")
+        if isinstance(roots, list):
+            writable_roots = tuple(
+                Path(str(r)).expanduser().resolve() for r in roots if isinstance(r, str)
+            )
+
+    return UserConfig(
+        raw=data,
+        working_dir=working_dir,
+        sandbox_mode=sandbox_mode,
+        approval_policy=approval_policy,
+        oss_provider=oss_provider,
+        writable_roots=writable_roots,
+        workspace_instructions=instructions_text,
+        instructions_source=source,
+        warnings=tuple(warnings),
+    )
+
+
+def _get_path(
+    data: Mapping[str, Any], key: str, relative_to: Path | None = None
+) -> Path | None:
+    value = data.get(key)
+    if isinstance(value, str) and value:
+        path = Path(value).expanduser()
+        if not path.is_absolute() and relative_to is not None:
+            path = (relative_to.parent / path).resolve()
+        else:
+            path = path.resolve()
+        return path
+    return None
+
+
+def _get_str(data: Mapping[str, Any], key: str) -> str | None:
+    value = data.get(key)
+    if isinstance(value, str) and value:
+        return value
+    return None

flywheel_bootstrap_staging-0.1.9.202601291439/bootstrap/constants.py

@@ -0,0 +1,20 @@
+"""Shared constants for the bootstrap flow."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+DEFAULT_SERVER_URL = "http://localhost:8000"
+DEFAULT_RUN_ROOT = Path.home() / ".flywheel" / "runs"
+DEFAULT_ARTIFACT_MANIFEST = "flywheel_artifacts.json"
+HEARTBEAT_INTERVAL_SECONDS = 30
+MAX_ARTIFACT_RETRIES = 2
+
+# Environment variables that let the backend command override defaults.
+ENV_SERVER_URL = "FLYWHEEL_SERVER"
+ENV_RUN_ID = "FLYWHEEL_RUN_ID"
+ENV_RUN_TOKEN = "FLYWHEEL_RUN_TOKEN"
+
+# Codex download
+DEFAULT_CODEX_VERSION = None  # latest
+CODEX_RELEASE_BASE = "https://github.com/openai/codex/releases/latest/download"