opsai-cli 0.1.0__py3-none-any.whl

opsai_cli/__init__.py

@@ -0,0 +1,8 @@
+"""Independent OpsAI Open API client package."""
+
+from importlib.metadata import version
+
+
+def get_version() -> str:
+    """Read the version from the installed distribution's metadata."""
+    return version("opsai-cli")

opsai_cli/__main__.py

@@ -0,0 +1,5 @@
+"""Allow python -m opsai_cli after installation."""
+
+from opsai_cli.cli import main
+
+raise SystemExit(main())

opsai_cli/business.py

@@ -0,0 +1,250 @@
+"""Business command registration and API v1 request admission."""
+
+import argparse
+import json
+from pathlib import Path
+import sys
+
+from pydantic import ValidationError
+
+from opsai_cli.client import ApiClient
+from opsai_cli.contracts import (
+    ListingSubmit, ActivitySubmit, OptimizationSubmit, AvailableActions, ListingPrices,
+)
+from opsai_cli.errors import CliError
+from opsai_cli.output import Output
+from opsai_cli.tasks import TaskSession, task_data, outcome, validate_options
+
+
+FAMILIES = {"listing": "listing", "activity": "activity", "optimization": "listing-optimization"}
+MODELS = {"listing": {"submit": ListingSubmit}, "activity": {
+    "submit": ActivitySubmit, "actions": AvailableActions, "prices": ListingPrices,
+}, "optimization": {"submit": OptimizationSubmit}}
+LIMIT = 10 * 1024 * 1024
+
+
+def positive(value):
+    try:
+        number = int(value)
+        if number <= 0:
+            raise ValueError
+        return number
+    except ValueError:
+        raise CliError("IDs and platform numbers must be positive integers.") from None
+
+
+def register(groups):
+    for family in FAMILIES:
+        group = groups.add_parser(family, allow_abbrev=False)
+        commands = group.add_subparsers(dest="command", required=True)
+        stores = commands.add_parser("stores", allow_abbrev=False)
+        stores.add_argument("--platform", type=int)
+        submit = commands.add_parser("submit", allow_abbrev=False)
+        submit.add_argument("--file")
+        modes = submit.add_mutually_exclusive_group()
+        modes.add_argument("--wait", action="store_true")
+        if family != "activity":
+            modes.add_argument("--stream", action="store_true")
+        if family == "optimization":
+            submit.add_argument("--store-id", type=int)
+            submit.add_argument("--listing-sku")
+            submit.add_argument("--mode", choices=("update", "create"))
+            submit.add_argument("--request-id")
+        task = commands.add_parser("task", allow_abbrev=False)
+        task_commands = task.add_subparsers(dest="task_command", required=True)
+        get = task_commands.add_parser("get", allow_abbrev=False)
+        get.add_argument("task_id", type=int)
+        leaves = [stores, submit, get]
+        watch = task_commands.add_parser("watch", allow_abbrev=False)
+        watch.add_argument("task_id", type=int)
+        leaves.append(watch)
+        if family != "activity":
+            stop = task_commands.add_parser("stop", allow_abbrev=False)
+            stop.add_argument("task_id", type=int)
+            leaves.append(stop)
+        if family == "activity":
+            actions = commands.add_parser("actions", allow_abbrev=False)
+            actions.add_argument("--file")
+            actions.add_argument("--store-id", type=int)
+            actions.add_argument("--listing-sku")
+            actions.add_argument("--platform", type=int)
+            prices = commands.add_parser("prices", allow_abbrev=False)
+            prices.add_argument("--file", required=True)
+            leaves.extend([actions, prices])
+        for command in ("template", "validate"):
+            local = commands.add_parser(command, allow_abbrev=False)
+            local.add_argument("--kind", choices=tuple(MODELS[family]), default="submit")
+            if command == "template":
+                local.add_argument("--out", required=True)
+                local.add_argument("--force", action="store_true")
+            else:
+                local.add_argument("--file", required=True)
+            leaves.append(local)
+        for leaf in leaves:
+            # SUPPRESS preserves a global --profile passed before the group.
+            leaf.add_argument("--profile", default=argparse.SUPPRESS)
+            leaf.add_argument("--output", choices=("table", "json", "ndjson"), default=argparse.SUPPRESS)
+            if leaf.get_default("kind") is None:
+                leaf.add_argument("--request-timeout", type=float, default=30)
+                leaf.add_argument("--wait-timeout", type=float, default=1800)
+                leaf.add_argument("--poll-interval", type=float, default=5)
+                leaf.add_argument("--max-retries", type=int, default=2)
+
+
+def read_json(filename):
+    def reject_constant(value):
+        raise ValueError
+
+    def unique_pairs(pairs):
+        data = {}
+        for key, value in pairs:
+            if key in data:
+                raise ValueError
+            data[key] = value
+        return data
+
+    try:
+        if filename == "-":
+            binary = getattr(sys.stdin, "buffer", None)
+            content = binary.read(LIMIT + 1).decode("utf-8-sig") if binary is not None else sys.stdin.read(LIMIT + 1)
+            if len(content.encode("utf-8")) > LIMIT:
+                raise ValueError
+        else:
+            with Path(filename).open("rb") as stream:
+                content = stream.read(LIMIT + 1)
+            if len(content) > LIMIT:
+                raise ValueError
+            content = content.decode("utf-8-sig")
+        return json.loads(content, parse_constant=reject_constant, object_pairs_hook=unique_pairs)
+    except (OSError, ValueError, UnicodeError, RecursionError):
+        raise CliError("Cannot read request JSON: use UTF-8, unique fields, finite numbers and at most 10 MiB.") from None
+
+
+def validate(family, kind, body):
+    try:
+        return MODELS[family][kind].model_validate(body).model_dump(mode="json")
+    except (ValidationError, ValueError, RecursionError) as exc:
+        if isinstance(exc, ValidationError):
+            issues = []
+            for error in exc.errors(include_input=False, include_context=False)[:8]:
+                loc = list(error["loc"])
+                if error["type"] == "extra_forbidden" and loc:
+                    loc[-1] = "<unknown-field>"
+                path = ".".join(str(x) for x in loc) or "request"
+                issues.append(f"{path}: {error['type']}")
+            raise CliError("Request validation failed: " + "; ".join(issues)) from None
+        raise CliError("Request validation failed.") from None
+
+
+def template(family, kind="submit"):
+    if kind == "actions":
+        return {"store_id": 1001, "listing_sku": "L-0001", "platform": 9}
+    if kind == "prices":
+        return {"store_id": 1001, "listing_skus": ["L-0001"], "action_id": 1977747, "platform": 9}
+    if family == "listing":
+        return {"request_id": "replace-with-stable-listing-request-id", "store_ids": [1001],
+                "prices": [{"store_id": 1001, "site_prices": [{"site": "RU", "price": 1999, "currency": "RUB"}]}],
+                "products": [{"sku": "YOUR-SKU-001", "title": "Your product title",
+                              "images": {"main_img": "https://cdn.example.com/product.jpg"}}]}
+    if family == "activity":
+        return {"request_id": "replace-with-stable-activity-request-id", "store_id": 1001,
+                "action_id": 1977747, "items": [{"listing_sku": "L-0001", "action_price": 1899}]}
+    return {"request_id": "replace-with-stable-optimization-request-id", "store_id": 1001,
+            "listing_sku": "L-0001", "mode": "update"}
+
+
+def request_body(args):
+    fields = ("store_id", "listing_sku", "mode", "request_id") if args.group == "optimization" else ("store_id", "listing_sku", "platform")
+    flags = {field: getattr(args, field) for field in fields if getattr(args, field, None) is not None}
+    filename = getattr(args, "file", None)
+    if filename is not None:
+        if flags:
+            raise CliError("Do not mix --file with business parameter flags.")
+        body = read_json(filename)
+    elif flags:
+        body = flags
+    else:
+        raise CliError("Provide --file (use - for stdin), or all required shortcut parameters.")
+    return validate(args.group, args.command, body)
+
+
+def run(args):
+    family, command = args.group, args.command
+    output = Output(getattr(args, "output", None))
+    if command == "template":
+        # Exclusive creation protects user data unless overwrite is explicit.
+        content = template(family, args.kind)
+        validate(family, args.kind, content)
+        try:
+            with Path(args.out).open("w" if args.force else "x", encoding="utf-8") as stream:
+                json.dump(content, stream, ensure_ascii=False, indent=2)
+                stream.write("\n")
+        except FileExistsError:
+            raise CliError("Template target exists; use --force to overwrite it.") from None
+        except OSError:
+            raise CliError("Cannot write template file; check the directory and permissions.") from None
+        output.emit({"template_written": True, "kind": args.kind, "message": "Replace examples and use a stable request_id before submission."})
+        return 0
+    if command == "validate":
+        validate(family, args.kind, read_json(args.file))
+        output.emit({"valid": True, "message": "Server permissions and platform acceptance have not been checked."})
+        return 0
+    path = f"/{FAMILIES[family]}/v1"
+    method, body, params = "GET", None, None
+    if command == "stores":
+        platform = args.platform
+        if platform is not None:
+            positive(str(platform))
+            allowed = {9} if family == "activity" else {1, 2, 3, 9, 10, 11, 12}
+            if platform not in allowed:
+                raise CliError("Platform is not supported by this API family.")
+            params = {"platform": platform}
+        path += "/stores"
+    elif command == "task":
+        path += f"/tasks/{positive(str(args.task_id))}"
+    else:
+        body = request_body(args)  # Validate before reading credentials or sending.
+        method = "POST"
+        path += {"submit": "/tasks", "actions": "/available-actions", "prices": "/listing-prices"}[command]
+    validate_options(args.request_timeout, args.wait_timeout, args.poll_interval, args.max_retries)
+    with ApiClient.from_profile(getattr(args, "profile", None)) as client:
+        output.secrets += (client._key,)
+        waiting = (getattr(args, "wait", False) or getattr(args, "stream", False)
+                   or (command == "task" and args.task_command in {"watch", "stop"}))
+        session = TaskSession(client, output, family=family, prefix=f"/{FAMILIES[family]}/v1",
+            request_timeout=args.request_timeout, wait_timeout=args.wait_timeout,
+            poll_interval=args.poll_interval, max_retries=args.max_retries, waiting=waiting)
+        if command == "submit":
+            session.request_id = body["request_id"]
+        if command == "task":
+            session.task_id = args.task_id
+        try:
+            if command == "submit" and getattr(args, "stream", False):
+                result = session.submit_stream(body)
+            elif command == "task" and args.task_command == "watch":
+                result = session.watch()
+            elif command == "task" and args.task_command == "stop":
+                result = session.stop()
+            else:
+                result = session.request(method, path, body=body, params=params)
+                if command == "submit":
+                    data = task_data(result)
+                    session.accepted(data)
+                    if args.wait:
+                        result = session.watch()
+            if not (command == "submit" and not waiting):
+                output.emit(result["data"] if output.mode == "ndjson" and waiting else result)
+            elif output.mode != "ndjson":
+                output.emit(result)
+            # Submit-only and task get report request success, not business success.
+            if waiting and not (command == "task" and args.task_command == "stop"):
+                return outcome(family, task_data(result, session.task_id))
+            return 0
+        except CliError as exc:
+            session.recovery_note()
+            output.error(exc)
+            return exc.exit_code
+        except KeyboardInterrupt:
+            session.recovery_note()
+            output.error(CliError("Local command interrupted; no stop request was sent automatically.", 130))
+            return 130

opsai_cli/cli.py

@@ -0,0 +1,98 @@
+"""Console entry point. Business commands are added in later milestones."""
+
+import argparse
+from collections.abc import Sequence
+import getpass
+import sys
+import warnings
+import os
+
+from opsai_cli import get_version
+from opsai_cli.config import ConfigStore, select_profile
+from opsai_cli.credentials import CredentialStore
+from opsai_cli.errors import CliError
+
+
+class SafeArgumentParser(argparse.ArgumentParser):
+    def error(self, message):
+        # argparse normally repeats invalid input, potentially including a key
+        # mistakenly provided as a positional argument or unknown option.
+        from opsai_cli.output import Output
+        Output().error(CliError("Invalid command arguments; run --help for usage."))
+        self.exit(2)
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = SafeArgumentParser(
+        prog="opsai",
+        description="OpsAI Open API command-line client.",
+        epilog="M4/M5 provide task waiting, bounded retries, SSE and explicit task stop.",
+        allow_abbrev=False,
+    )
+    parser.add_argument("--version", action="version", version=f"%(prog)s {get_version()}")
+    parser.add_argument("--profile", default=argparse.SUPPRESS, help="Profile name (otherwise OPSAI_PROFILE or default).")
+    parser.add_argument("--output", choices=("table", "json", "ndjson"), default=argparse.SUPPRESS)
+    groups = parser.add_subparsers(dest="group")
+    config = groups.add_parser("config", allow_abbrev=False)
+    config_commands = config.add_subparsers(dest="command", required=True)
+    set_profile = config_commands.add_parser("set-profile", allow_abbrev=False)
+    set_profile.add_argument("name")
+    config_commands.add_parser("profiles", allow_abbrev=False)
+    auth = groups.add_parser("auth", allow_abbrev=False)
+    auth_commands = auth.add_subparsers(dest="command", required=True)
+    configure = auth_commands.add_parser("configure", allow_abbrev=False)
+    configure.add_argument("--profile", default=argparse.SUPPRESS)
+    for leaf in (set_profile, config_commands.choices["profiles"], configure):
+        leaf.add_argument("--output", choices=("table", "json", "ndjson"), default=argparse.SUPPRESS)
+    # Load business models only when needed; help/version stay lightweight.
+    business_groups = {"listing", "activity", "optimization"}
+    supplied = list(argv) if argv is not None else sys.argv[1:]
+    if any(arg in business_groups for arg in supplied):
+        from opsai_cli.business import register
+        register(groups)
+    else:
+        for name in sorted(business_groups):
+            groups.add_parser(name, help="Use this command with --help for business operations.")
+    args = parser.parse_args(argv)
+    try:
+        if args.group in business_groups:
+            from opsai_cli.business import run
+            return run(args)
+        elif args.group == "config":
+            from opsai_cli.output import Output
+            output = Output(getattr(args, "output", None))
+            store = ConfigStore()
+            if args.command == "set-profile":
+                address = store.set_profile(args.name)
+                output.emit({"profile": args.name, "base_url": address})
+            else:
+                profiles = store.load()["profiles"]
+                if not profiles:
+                    profiles = {"default": {"base_url": store.get("default")}}
+                output.emit([{"profile": name, "base_url": entry["base_url"]} for name, entry in sorted(profiles.items())])
+        elif args.group == "auth":
+            store = ConfigStore()
+            name = select_profile(getattr(args, "profile", None))
+            address = store.get(name)
+            if not sys.stdin.isatty():
+                raise CliError("Interactive terminal required; use OPSAI_API_KEY for non-interactive requests.")
+            try:
+                with warnings.catch_warnings():
+                    warnings.simplefilter("error", getpass.GetPassWarning)
+                    key = getpass.getpass(f"API Key for {name} ({address}): ")
+            except (getpass.GetPassWarning, EOFError):
+                raise CliError("Hidden input unavailable; use OPSAI_API_KEY instead.") from None
+            CredentialStore().save(name, address, key)
+            from opsai_cli.output import Output
+            Output(getattr(args, "output", None)).emit({"saved": True, "message": "API Key saved to system credential storage; server permissions have not been verified."})
+        else:
+            parser.print_help()
+        return 0
+    except CliError as exc:
+        from opsai_cli.output import Output
+        Output(getattr(args, "output", None), secrets=(os.environ.get("OPSAI_API_KEY", ""),)).error(exc)
+        return exc.exit_code
+    except KeyboardInterrupt:
+        from opsai_cli.output import Output
+        Output(getattr(args, "output", None)).error(CliError("Local command interrupted.", 130))
+        return 130

opsai_cli/client.py

@@ -0,0 +1,120 @@
+"""Synchronous Open API transport. Retry/task orchestration belongs to M4."""
+
+import math
+import re
+from datetime import datetime, timezone
+from email.utils import parsedate_to_datetime
+
+import httpx
+
+from opsai_cli.config import normalize_base_url, select_profile, ConfigStore
+from opsai_cli.credentials import CredentialStore, validate_key
+from opsai_cli.errors import CliError
+
+
+class ApiClient:
+    def __init__(self, base_url: str, api_key: str, *, request_timeout: float = 30,
+                 transport: httpx.BaseTransport | None = None):
+        self.base_url = normalize_base_url(base_url)
+        self._key = validate_key(api_key)
+        if (isinstance(request_timeout, bool) or not isinstance(request_timeout, (int, float))
+                or not math.isfinite(request_timeout) or request_timeout <= 0):
+            raise CliError("Request timeout must be a finite positive number of seconds.")
+        self._client = httpx.Client(
+            headers={"Authorization": f"Bearer {self._key}", "Accept": "application/json"},
+            timeout=httpx.Timeout(request_timeout, connect=min(10, request_timeout)),
+            verify=True, follow_redirects=False, trust_env=False, transport=transport,
+        )
+
+    @classmethod
+    def from_profile(cls, profile=None, *, config=None, credentials=None, **kwargs):
+        name = select_profile(profile)
+        base_url = (config or ConfigStore()).get(name)
+        key = (credentials or CredentialStore()).resolve(name, base_url)
+        return cls(base_url, key, **kwargs)
+
+    def close(self):
+        self._client.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.close()
+
+    def _url(self, path):
+        if (not isinstance(path, str) or not re.fullmatch(r"/[A-Za-z0-9_/-]+", path)
+                or "//" in path):
+            raise CliError("Use a relative API path without a host, query or traversal.")
+        return self.base_url + "/api/open" + path
+
+    @staticmethod
+    def _status(response):
+        status = response.status_code
+        if 200 <= status < 300:
+            return
+        retry_after = None
+        header = response.headers.get("Retry-After", "")
+        try:
+            retry_after = float(header)
+            if not math.isfinite(retry_after) or retry_after < 0:
+                retry_after = None
+        except ValueError:
+            try:
+                date = parsedate_to_datetime(header)
+                if date.tzinfo is not None:
+                    retry_after = max(0, (date - datetime.now(timezone.utc)).total_seconds())
+            except (ValueError, TypeError, OverflowError):
+                pass
+        code = 3 if status in (401, 403) else 5 if status >= 500 or 300 <= status < 400 else 4
+        message = {
+            401: "API authentication failed; check the Key and account status.",
+            403: "API permission denied; check scopes, business permissions and resource ownership.",
+            429: "API rate limit exceeded; retry later.",
+        }.get(status, "API request rejected; check service configuration and request parameters.")
+        if 300 <= status < 400:
+            message = "API redirect refused; the CLI uses the official service root."
+        raise CliError(f"HTTP {status}: {message}", code, status=status,
+                       retryable=status in {408, 425, 429, 500, 502, 503, 504}, retry_after=retry_after)
+
+    @staticmethod
+    def _payload(response):
+        try:
+            payload = response.json()
+        except ValueError:
+            raise CliError("API returned an invalid JSON response.", 5) from None
+        if (not isinstance(payload, dict) or type(payload.get("code")) is not int
+                or "data" not in payload or not isinstance(payload.get("message"), str)):
+            raise CliError("API returned an unsupported response format.", 5)
+        if payload["code"] != 0:
+            code = 3 if payload["code"] in (401, 403) else 4
+            raise CliError("API reported a business error; check request parameters and permissions.", code)
+        return payload
+
+    def request_json(self, method, path, *, params=None, json=None, timeout=None):
+        url = self._url(path)
+        options = {} if timeout is None else {"timeout": httpx.Timeout(timeout, connect=min(10, timeout))}
+        try:
+            response = self._client.request(method, url, params=params, json=json, **options)
+        except httpx.TimeoutException:
+            raise CliError("API request timed out; a submitted operation may still have been accepted.", 5, retryable=True) from None
+        except httpx.RequestError:
+            raise CliError("Cannot reach the API service; check connectivity and TLS configuration.", 5, retryable=True) from None
+        except (ValueError, TypeError):
+            raise CliError("Cannot encode API request parameters.") from None
+        self._status(response)
+        return self._payload(response)
+
+    def stream_events(self, path, body, *, timeout=30, check=lambda: None):
+        from opsai_cli.sse import parse_events, utf8_lines
+        url = self._url(path)
+        try:
+            with self._client.stream("POST", url, json=body,
+                    headers={"Accept": "text/event-stream"},
+                    timeout=httpx.Timeout(timeout, connect=min(10, timeout))) as response:
+                self._status(response)
+                if response.headers.get("content-type", "").split(";", 1)[0].strip() != "text/event-stream":
+                    raise CliError("API did not return an SSE stream; submission outcome may be unknown.", 5)
+                yield from parse_events(utf8_lines(response.iter_bytes(), check), check)
+        except httpx.RequestError:
+            raise CliError("SSE connection failed; submission outcome may be unknown.", 5, retryable=True) from None

opsai_cli/config.py

@@ -0,0 +1,124 @@
+"""Non-secret, versioned profile configuration."""
+
+import ipaddress
+from contextlib import suppress
+import json
+import os
+from pathlib import Path
+import re
+import tempfile
+from urllib.parse import urlsplit
+
+from opsai_cli.errors import CliError
+
+DEFAULT_BASE_URL = "https://www.krossray.com"
+
+
+def profile_name(value: str) -> str:
+    if not isinstance(value, str) or not re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9_-]{0,63}", value):
+        raise CliError("Profile names must contain 1-64 letters, digits, underscores or hyphens.")
+    return value
+
+
+def select_profile(explicit: str | None = None) -> str:
+    return profile_name(explicit if explicit is not None else os.environ.get("OPSAI_PROFILE", "default"))
+
+
+def normalize_base_url(value: str) -> str:
+    try:
+        if not isinstance(value, str) or not value or any(c.isspace() or ord(c) < 32 for c in value):
+            raise ValueError
+        if any(c in value for c in ("\\", "%", "?", "#")):
+            raise ValueError
+        parts = urlsplit(value)
+        if (parts.scheme not in {"https", "http"} or not parts.hostname
+                or parts.username is not None or parts.password is not None
+                or parts.path not in {"", "/"}):
+            raise ValueError
+        host = parts.hostname.lower()
+        if host != "localhost":
+            try:
+                address = ipaddress.ip_address(host)
+                local = address.is_loopback
+                host = address.compressed
+            except ValueError:
+                local = False
+                host = host.encode("idna").decode("ascii")
+                if not re.fullmatch(r"[a-z0-9.-]+", host):
+                    raise ValueError
+        else:
+            local = True
+        if parts.scheme == "http" and not local:
+            raise ValueError
+        port = parts.port
+        if port is not None and port < 1:
+            raise ValueError
+        authority = f"[{host}]" if ":" in host else host
+        if port is not None and port != (443 if parts.scheme == "https" else 80):
+            authority += f":{port}"
+        return f"{parts.scheme}://{authority}"
+    except (ValueError, UnicodeError):
+        raise CliError("Use an HTTPS service root without credentials, path, query or fragment; HTTP is allowed only for localhost/loopback.") from None
+
+
+def default_config_dir() -> Path:
+    override = os.environ.get("OPSAI_CONFIG_DIR")
+    if override:
+        return Path(override).expanduser()
+    if os.name == "nt":
+        root = os.environ.get("APPDATA")
+        return (Path(root) if root else Path.home() / "AppData/Roaming") / "opsai"
+    root = os.environ.get("XDG_CONFIG_HOME")
+    return (Path(root) if root else Path.home() / ".config") / "opsai"
+
+
+class ConfigStore:
+    def __init__(self, directory: Path | None = None):
+        self.path = (directory if directory is not None else default_config_dir()) / "config.json"
+
+    def load(self) -> dict:
+        try:
+            raw = json.loads(self.path.read_text(encoding="utf-8"))
+        except FileNotFoundError:
+            return {"version": 1, "profiles": {}}
+        except (OSError, ValueError, UnicodeError):
+            raise CliError("Cannot read profile configuration; check config.json permissions and JSON format.") from None
+        if (not isinstance(raw, dict) or set(raw) != {"version", "profiles"}
+                or type(raw["version"]) is not int or raw["version"] != 1
+                or not isinstance(raw["profiles"], dict)):
+            raise CliError("Unsupported profile configuration format.")
+        for name, entry in raw["profiles"].items():
+            profile_name(name)
+            if not isinstance(entry, dict) or set(entry) != {"base_url"}:
+                raise CliError("Profile configuration may contain only base_url; keep keys in the system credential store or OPSAI_API_KEY.")
+            # Legacy profiles may contain custom origins. Never use them for
+            # requests: the public CLI always connects to the official site.
+            entry["base_url"] = DEFAULT_BASE_URL
+        return raw
+
+    def get(self, name: str) -> str:
+        name = profile_name(name)
+        return DEFAULT_BASE_URL
+
+    def set_profile(self, name: str) -> str:
+        name, base_url = profile_name(name), DEFAULT_BASE_URL
+        data = self.load()
+        data["profiles"][name] = {"base_url": base_url}
+        temporary = None
+        try:
+            self.path.parent.mkdir(parents=True, exist_ok=True, mode=0o700)
+            with tempfile.NamedTemporaryFile(mode="w", encoding="utf-8", dir=self.path.parent,
+                                             prefix=".config-", suffix=".tmp", delete=False) as stream:
+                temporary = Path(stream.name)
+                json.dump(data, stream, ensure_ascii=False, indent=2)
+                stream.write("\n")
+                stream.flush()
+                os.fsync(stream.fileno())
+            temporary.replace(self.path)
+        except OSError:
+            raise CliError("Cannot save profile configuration; check directory permissions.") from None
+        finally:
+            if temporary is not None:
+                with suppress(OSError):
+                    temporary.unlink(missing_ok=True)
+        return base_url