bladekit 4.5.0__py3-none-any.whl

bladekit/config.py

@@ -0,0 +1,181 @@
+"""Client configuration resolution.
+
+Precedence (task requirement 5): ``FABRIC_API_URL`` / ``FABRIC_TOKEN`` environment
+variables (or their legacy ``FORGE_*`` spelling) win over ``~/.blade/config.toml``.
+
+The TOML file is written by ``blade token set`` and read by ``blade token show``
+and every client. Kept dependency-light: stdlib ``tomllib`` on 3.11+, ``tomli``
+fallback on 3.10, and a tiny hand-rolled writer (we never need to serialize
+arbitrary TOML — only ``api_url`` and ``token``).
+
+Migration (PAAS-771): the file used to live at ``~/.forge/config.toml``. When the
+new file is absent and the legacy one exists, the legacy file is copied to the new
+location on first read and left in place, so an older ``forge`` CLI installed side
+by side keeps working.
+"""
+
+from __future__ import annotations
+
+import os
+import shutil
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+from . import _env
+from ._constants import DEFAULT_API_URL
+
+if sys.version_info >= (3, 11):
+    import tomllib as _toml
+else:  # pragma: no cover - exercised only on 3.10
+    import tomli as _toml  # type: ignore[no-redef]
+
+
+def default_config_path() -> Path:
+    """``~/.blade/config.toml`` — where the CLI keeps its token."""
+    return Path.home() / ".blade" / "config.toml"
+
+
+def legacy_config_path() -> Path:
+    """``~/.forge/config.toml`` — where the ``forge`` CLI kept it (pre-PAAS-771)."""
+    return Path.home() / ".forge" / "config.toml"
+
+
+def config_path() -> Path:
+    """Location of the config file (override with ``FABRIC_CONFIG`` for tests)."""
+    override = _env.get("CONFIG")
+    if override:
+        return Path(override)
+    return default_config_path()
+
+
+def migrate_legacy_config() -> Optional[Path]:
+    """Copy ``~/.forge/config.toml`` to ``~/.blade/config.toml`` if only the former exists.
+
+    Returns the path that now holds the configuration (the new one after a
+    successful copy, the legacy one if the copy failed — e.g. a read-only home —
+    so the caller can still read it), or None when there is nothing to migrate.
+    The legacy file is never modified or removed. Skipped when ``FABRIC_CONFIG``
+    / ``FORGE_CONFIG`` points somewhere explicit.
+    """
+    if _env.get("CONFIG"):
+        return None
+    new, old = default_config_path(), legacy_config_path()
+    if new.exists() or not old.is_file():
+        return None
+    try:
+        # Same private permissions write_config() uses: the file holds a token.
+        new.parent.mkdir(parents=True, exist_ok=True, mode=0o700)
+        shutil.copyfile(old, new)
+        new.chmod(0o600)
+    except OSError:
+        return old
+    return new
+
+@dataclass
+class Config:
+    api_url: str
+    token: Optional[str]
+    # Where each value came from, for ``blade token show``.
+    api_url_source: str = "default"
+    token_source: str = "none"
+
+
+def _read_file() -> dict:
+    path = config_path()
+    if not path.exists():
+        migrated = migrate_legacy_config()
+        if migrated is not None:
+            path = migrated
+    if not path.exists():
+        return {}
+    try:
+        with path.open("rb") as fh:
+            return _toml.load(fh)
+    except (OSError, _toml.TOMLDecodeError):
+        return {}
+
+
+def load_config() -> Config:
+    """Resolve effective config from env then file then defaults."""
+    file_data = _read_file()
+
+    env_url, env_url_var = _env.lookup("API_URL")
+    if env_url:
+        api_url, url_src = env_url, f"env ({env_url_var})"
+    elif file_data.get("api_url"):
+        api_url, url_src = str(file_data["api_url"]), f"file ({config_path()})"
+    else:
+        api_url, url_src = DEFAULT_API_URL, "default"
+
+    env_token, env_token_var = _env.lookup("TOKEN")
+    if env_token:
+        token, tok_src = env_token, f"env ({env_token_var})"
+    elif file_data.get("token"):
+        token, tok_src = str(file_data["token"]), f"file ({config_path()})"
+    else:
+        # In-container fallback: a function calling the AI Fabric API (Sandbox.create
+        # without secrets, Queue/Dict items) authenticates with the run's
+        # ephemeral runner token, obtained from the runner's in-process context —
+        # NOT from os.environ, which the runner scrubs before importing user code
+        # (PAAS-250). The server accepts that token as the run's owner only on
+        # the runner-token allowlist (control plane runnerTokenRoutes: no
+        # secrets in sandboxes, no volumes, no org-wide listings) and only while
+        # the run is alive. The env form is honoured for pre-1.4 runners.
+        from ._runner_api import runner_credentials
+
+        creds = runner_credentials()
+        if creds is not None:
+            token, tok_src = creds.token, creds.source
+        else:
+            token, tok_src = None, "none"
+
+    return Config(
+        api_url=api_url.rstrip("/"),
+        token=token,
+        api_url_source=url_src,
+        token_source=tok_src,
+    )
+
+
+def _toml_escape(value: str) -> str:
+    return value.replace("\\", "\\\\").replace('"', '\\"')
+
+
+def write_config(*, token: Optional[str] = None, api_url: Optional[str] = None) -> Path:
+    """Persist token and/or api_url to the config file (merging with existing)."""
+    data = _read_file()
+    if token is not None:
+        data["token"] = token
+    if api_url is not None:
+        data["api_url"] = api_url.rstrip("/")
+
+    path = config_path()
+    # The file holds a secret token: create both the dir and the file with private
+    # perms *from the start* (no world/group-readable window between create and
+    # chmod). mkdir(mode=0o700) + os.open(O_CREAT, 0o600) — the mode only applies on
+    # creation, so chmod afterwards keeps perms tight if the file already existed.
+    path.parent.mkdir(parents=True, exist_ok=True, mode=0o700)
+    lines = ["# Blade AI Fabric CLI configuration — written by `blade token set`.", ""]
+    if "api_url" in data:
+        lines.append(f'api_url = "{_toml_escape(str(data["api_url"]))}"')
+    if "token" in data:
+        lines.append(f'token = "{_toml_escape(str(data["token"]))}"')
+    lines.append("")
+    payload = "\n".join(lines).encode("utf-8")
+
+    try:
+        fd = os.open(str(path), os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+    except OSError:  # pragma: no cover - non-POSIX fallback
+        path.write_text("\n".join(lines), encoding="utf-8")
+    else:
+        with os.fdopen(fd, "wb") as fh:
+            fh.write(payload)
+    # Re-assert 0600 in case the file pre-existed with looser perms (O_CREAT mode
+    # is ignored for an existing file).
+    try:
+        path.chmod(0o600)
+    except OSError:  # pragma: no cover - non-POSIX
+        pass
+    return path