devcopilot 0.2.0__py3-none-any.whl

cli/entrypoints.py

@@ -0,0 +1,166 @@
+"""CLI entry points for the installed package."""
+
+from __future__ import annotations
+
+import os
+import shutil
+import threading
+import time
+import webbrowser
+from pathlib import Path
+
+import uvicorn
+
+from api.admin_urls import local_admin_url, local_proxy_root_url
+from api.app import GracefulLifespanApp, create_app
+from cli.launchers.common import preflight_proxy
+from cli.process_registry import (
+    kill_all_best_effort,
+)
+from config.paths import (
+    config_dir_path,
+    legacy_env_paths,
+    managed_env_path,
+)
+from config.settings import Settings, get_settings
+
+SERVER_GRACEFUL_SHUTDOWN_SECONDS = 5
+
+
+def _load_env_template() -> str:
+    """Load the canonical root env template from package resources or source."""
+    import importlib.resources
+
+    packaged = importlib.resources.files("cli").joinpath("env.example")
+    if packaged.is_file():
+        return packaged.read_text("utf-8")
+
+    source_template = Path(__file__).resolve().parents[1] / ".env.example"
+    if source_template.is_file():
+        return source_template.read_text(encoding="utf-8")
+
+    raise FileNotFoundError("Could not find bundled or source .env.example template.")
+
+
+def serve() -> None:
+    """Start the FastAPI server (registered as `devcopilot-server` script)."""
+    opened_admin_browser = False
+    try:
+        try:
+            while True:
+                _migrate_legacy_env_if_missing()
+                settings = get_settings()
+                if not _run_supervised_server(
+                    settings, open_admin_browser=not opened_admin_browser
+                ):
+                    return
+                opened_admin_browser = True
+                get_settings.cache_clear()
+        except KeyboardInterrupt:
+            return
+    finally:
+        kill_all_best_effort()
+
+
+def _admin_browser_open_enabled() -> bool:
+    """Whether to open /admin when the server becomes reachable (FCC_OPEN_BROWSER)."""
+
+    raw = os.environ.get("FCC_OPEN_BROWSER", "true").strip().lower()
+    return raw not in {"", "0", "false", "no"}
+
+
+def _schedule_open_admin_browser(settings: Settings) -> None:
+    """After /health succeeds, open the admin UI in the default browser (daemon thread)."""
+
+    if not _admin_browser_open_enabled():
+        return
+
+    admin_url = local_admin_url(settings)
+    proxy_root_url = local_proxy_root_url(settings)
+
+    def open_when_ready() -> None:
+        deadline = time.monotonic() + 30.0
+        while time.monotonic() < deadline:
+            if preflight_proxy(proxy_root_url) is None:
+                webbrowser.open(admin_url)
+                return
+            time.sleep(0.15)
+
+    threading.Thread(
+        target=open_when_ready, name="devcopilot-open-admin-browser", daemon=True
+    ).start()
+
+
+def _run_supervised_server(settings: Settings, *, open_admin_browser: bool) -> bool:
+    """Run one uvicorn server instance; return whether admin requested restart."""
+
+    restart_requested = False
+    server_holder: dict[str, uvicorn.Server] = {}
+
+    def request_restart() -> None:
+        nonlocal restart_requested
+        restart_requested = True
+        if server := server_holder.get("server"):
+            server.should_exit = True
+
+    app = create_app(lifespan_enabled=False)
+    app.state.admin_restart_callback = request_restart
+    asgi_app = GracefulLifespanApp(app)
+    config = uvicorn.Config(
+        asgi_app,
+        host=settings.host,
+        port=settings.port,
+        log_level="debug",
+        timeout_graceful_shutdown=SERVER_GRACEFUL_SHUTDOWN_SECONDS,
+    )
+    server = uvicorn.Server(config)
+    server_holder["server"] = server
+    if open_admin_browser:
+        _schedule_open_admin_browser(settings)
+    server.run()
+    return restart_requested
+
+
+def init() -> None:
+    """Scaffold config at ~/.fcc/.env (registered as `devcopilot-init`)."""
+    config_dir = config_dir_path()
+    env_file = managed_env_path()
+
+    migrated_from = _migrate_legacy_env_if_missing()
+    if migrated_from is not None:
+        print(f"Config migrated from {migrated_from} to {env_file}")
+        print(
+            "Edit it to set your API keys and model preferences, then run: devcopilot-server"
+        )
+        return
+
+    if env_file.exists():
+        print(f"Config already exists at {env_file}")
+        print("Delete it first if you want to reset to defaults.")
+        return
+
+    config_dir.mkdir(parents=True, exist_ok=True)
+    template = _load_env_template()
+    env_file.write_text(template, encoding="utf-8")
+    print(f"Config created at {env_file}")
+    print(
+        "Edit it to set your API keys and model preferences, then run: devcopilot-server"
+    )
+
+
+def _migrate_legacy_env_if_missing() -> Path | None:
+    """Copy a legacy user env into the managed config path when absent."""
+
+    env_file = managed_env_path()
+    if env_file.exists():
+        return None
+
+    # TODO: Remove after the ~/.fcc/.env migration has had a release cycle.
+    for legacy_env in legacy_env_paths():
+        if not legacy_env.is_file():
+            continue
+        env_file.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copyfile(legacy_env, env_file)
+        return legacy_env
+
+    return None

cli/env.example

@@ -0,0 +1,209 @@
+# NVIDIA NIM Config
+NVIDIA_NIM_API_KEY=""
+
+
+# OpenRouter Config
+OPENROUTER_API_KEY=""
+
+
+# Mistral La Plateforme Config (Experiment plan free tier – rate limits; OpenAI-compatible at api.mistral.ai/v1)
+MISTRAL_API_KEY=""
+
+
+# Mistral Codestral (separate key from La Plateforme; OpenAI-compatible at codestral.mistral.ai/v1)
+CODESTRAL_API_KEY=""
+
+
+# DeepSeek Config (uses native Anthropic Messages at api.deepseek.com/anthropic)
+DEEPSEEK_API_KEY=""
+
+
+# Kimi Config (Anthropic-compatible Messages at api.moonshot.ai/anthropic/v1)
+KIMI_API_KEY=""
+
+
+# Wafer Config (uses native Anthropic Messages at pass.wafer.ai/v1/messages)
+WAFER_API_KEY=""
+
+
+# OpenCode Zen (opencode.ai/zen/v1) and OpenCode Go (opencode.ai/zen/go/v1) share OPENCODE_API_KEY
+OPENCODE_API_KEY=""
+
+
+# Z.ai Config (Anthropic-compatible Messages at api.z.ai/api/anthropic/v1)
+ZAI_API_KEY=""
+
+
+# Fireworks AI Config (Anthropic-compatible Messages at api.fireworks.ai/inference/v1)
+FIREWORKS_API_KEY=""
+
+
+# Gemini / Google AI Studio (OpenAI-compatible Chat Completions; see https://ai.google.dev/gemini-api/docs/openai)
+GEMINI_API_KEY=""
+
+
+# Groq Cloud (OpenAI-compatible Chat Completions; see https://console.groq.com/docs/openai)
+GROQ_API_KEY=""
+
+
+# Cerebras Inference (OpenAI-compatible Chat Completions; see https://inference-docs.cerebras.ai/resources/openai)
+CEREBRAS_API_KEY=""
+
+
+# LM Studio Config (local provider, no API key required)
+LM_STUDIO_BASE_URL="http://localhost:1234/v1"
+
+
+# Llama.cpp Config (local provider, no API key required)
+LLAMACPP_BASE_URL="http://localhost:8080/v1"
+
+
+# Ollama Config (local provider, no API key required)
+OLLAMA_BASE_URL="http://localhost:11434"
+
+
+# All Claude model requests are mapped to these models, plain model is fallback
+# Format: provider_type/model/name
+# Valid providers: "nvidia_nim" | "open_router" | "gemini" | "deepseek" | "mistral" | "mistral_codestral" | "opencode" | "opencode_go" | "wafer" | "kimi" | "cerebras" | "groq" | "fireworks" | "zai" | "lmstudio" | "llamacpp" | "ollama"
+MODEL_OPUS=
+MODEL_SONNET=
+MODEL_HAIKU=
+MODEL="nvidia_nim/nvidia/nemotron-3-super-120b-a12b"
+
+
+# Optional live smoke model overrides. Provider smoke runs once per configured
+# provider even when MODEL/MODEL_* route to a different provider.
+DEVCOPILOT_SMOKE_MODEL_NVIDIA_NIM=
+DEVCOPILOT_SMOKE_MODEL_OPEN_ROUTER=
+DEVCOPILOT_SMOKE_MODEL_MISTRAL=
+DEVCOPILOT_SMOKE_MODEL_MISTRAL_CODESTRAL=
+DEVCOPILOT_SMOKE_MODEL_DEEPSEEK=
+DEVCOPILOT_SMOKE_MODEL_LMSTUDIO=
+DEVCOPILOT_SMOKE_MODEL_LLAMACPP=
+DEVCOPILOT_SMOKE_MODEL_OLLAMA=
+FCC_SMOKE_MODEL_KIMI=
+FCC_SMOKE_MODEL_WAFER=
+FCC_SMOKE_MODEL_OPENCODE=
+FCC_SMOKE_MODEL_OPENCODE_GO=
+FCC_SMOKE_MODEL_ZAI=
+FCC_SMOKE_MODEL_FIREWORKS=
+FCC_SMOKE_MODEL_GEMINI=
+FCC_SMOKE_MODEL_GROQ=
+FCC_SMOKE_MODEL_CEREBRAS=
+FCC_SMOKE_NIM_MODELS=
+FCC_SMOKE_NIM_EXTRA_MODELS=
+FCC_SMOKE_OPENROUTER_FREE_MODELS=
+FCC_SMOKE_OPENROUTER_FREE_EXTRA_MODELS=
+
+
+# Thinking output
+# Per-Claude-model switches for provider reasoning requests and Claude thinking blocks.
+# Blank per-model switches inherit ENABLE_MODEL_THINKING.
+ENABLE_OPUS_THINKING=
+ENABLE_SONNET_THINKING=
+ENABLE_HAIKU_THINKING=
+ENABLE_MODEL_THINKING=true
+
+
+# Provider config
+# Per-provider proxy support: http and socks5, example: "http://username:password@host:port"
+NVIDIA_NIM_PROXY=""
+OPENROUTER_PROXY=""
+MISTRAL_PROXY=""
+CODESTRAL_PROXY=""
+LMSTUDIO_PROXY=""
+LLAMACPP_PROXY=""
+KIMI_PROXY=""
+WAFER_PROXY=""
+OPENCODE_PROXY=""
+OPENCODE_GO_PROXY=""
+ZAI_PROXY=""
+FIREWORKS_PROXY=""
+GEMINI_PROXY=""
+GROQ_PROXY=""
+CEREBRAS_PROXY=""
+
+PROVIDER_RATE_LIMIT=1
+PROVIDER_RATE_WINDOW=3
+PROVIDER_MAX_CONCURRENCY=5
+
+
+# HTTP client timeouts (seconds) for provider API requests
+HTTP_READ_TIMEOUT=300
+HTTP_WRITE_TIMEOUT=60
+HTTP_CONNECT_TIMEOUT=60
+
+
+# Optional server API key (Anthropic-style)
+ANTHROPIC_AUTH_TOKEN="freecc"
+
+
+# Open /admin in the default browser when fcc-server becomes healthy (set 0/false/no to disable)
+FCC_OPEN_BROWSER=true
+
+
+# Messaging Platform: "telegram" | "discord" | "none"
+MESSAGING_PLATFORM="discord"
+MESSAGING_RATE_LIMIT=1
+MESSAGING_RATE_WINDOW=1
+
+
+# Voice Note Transcription
+VOICE_NOTE_ENABLED=false
+# WHISPER_DEVICE: "cpu" | "cuda" | "nvidia_nim"
+# - "cpu"/"cuda": Hugging Face transformers Whisper (offline, free; install with: uv sync --extra voice_local)
+# - "nvidia_nim": NVIDIA NIM Whisper via Riva gRPC (requires NVIDIA_NIM_API_KEY; install with: uv sync --extra voice)
+# (Independent of MODEL=nvidia_nim/...: that selects the *chat* provider; this selects voice STT only.)
+WHISPER_DEVICE="nvidia_nim"
+# WHISPER_MODEL:
+# - For cpu/cuda: Hugging Face ID or short name (tiny, base, small, medium, large-v2, large-v3, large-v3-turbo)
+# - For nvidia_nim: NVIDIA NIM model (e.g., "nvidia/parakeet-ctc-1.1b-asr", "openai/whisper-large-v3")
+# - For nvidia_nim, default to "openai/whisper-large-v3" for best performance
+WHISPER_MODEL="openai/whisper-large-v3"
+HF_TOKEN=""
+
+
+# Telegram Config
+TELEGRAM_BOT_TOKEN=""
+ALLOWED_TELEGRAM_USER_ID=""
+
+
+# Discord Config
+DISCORD_BOT_TOKEN=""
+ALLOWED_DISCORD_CHANNELS=""
+
+
+# Agent Config
+ALLOWED_DIR=""
+FAST_PREFIX_DETECTION=true
+ENABLE_NETWORK_PROBE_MOCK=true
+ENABLE_TITLE_GENERATION_SKIP=true
+ENABLE_SUGGESTION_MODE_SKIP=true
+ENABLE_FILEPATH_EXTRACTION_MOCK=true
+
+
+# Local Anthropic web_search / web_fetch handling (performs outbound HTTP; on by default)
+ENABLE_WEB_SERVER_TOOLS=true
+WEB_FETCH_ALLOWED_SCHEMES=http,https
+WEB_FETCH_ALLOW_PRIVATE_NETWORKS=false
+
+
+# Structured TRACE logs: lines with `"trace": true` merge ingress/routing/cli/provider/egress
+# stages. Conversation text is logged in those payloads (verbatim). Values under keys named
+# like ``api_key`` / ``authorization`` are redacted. Raw transport payloads still require
+# the LOG_RAW_* toggles below.
+#
+# Verbose diagnostics (avoid logging raw prompts / SSE bodies in production)
+DEBUG_PLATFORM_EDITS=false
+DEBUG_SUBAGENT_STACK=false
+# When true, also allows DEBUG-level httpx/httpcore/telegram log noise (not just payload logging).
+LOG_RAW_API_PAYLOADS=false
+LOG_RAW_SSE_EVENTS=false
+# When true, log full exception text and tracebacks for unhandled errors (may leak request-derived data).
+LOG_API_ERROR_TRACEBACKS=false
+# When true, log message/transcription text previews in messaging adapters only (handler ingress always TRACEs verbatim text separately).
+LOG_RAW_MESSAGING_CONTENT=false
+# When true, log full Claude CLI stderr, non-JSON stdout lines, and parser error text.
+LOG_RAW_CLI_DIAGNOSTICS=false
+# When true, log full exception and CLI error message strings in messaging (may leak user content).
+LOG_MESSAGING_ERROR_DETAILS=false

cli/launchers/__init__.py

@@ -0,0 +1 @@
+"""Installed FCC client CLI launchers."""

cli/launchers/claude.py

@@ -0,0 +1,84 @@
+"""Installed `devcopilot-claude` launcher."""
+
+from __future__ import annotations
+
+import os
+import sys
+from collections.abc import Mapping, Sequence
+
+from api.admin_urls import local_proxy_root_url
+from cli.claude_env import CLAUDE_CODE_AUTO_COMPACT_WINDOW, claude_auth_token
+from config.settings import Settings, get_settings
+
+from .common import preflight_proxy, resolve_client_binary, run_client_process
+
+_DISPLAY_NAME = "Claude Code"
+_DEFAULT_BINARY = "claude"
+_INSTALL_HINT = "Install Claude Code with: npm install -g @anthropic-ai/claude-code"
+
+
+def launch(argv: Sequence[str] | None = None) -> None:
+    """Launch Claude Code with DevCopilot proxy environment variables."""
+
+    settings = get_settings()
+    proxy_root_url = local_proxy_root_url(settings)
+    if error := preflight_proxy(proxy_root_url):
+        print(
+            f"DevCopilot proxy is not reachable at {proxy_root_url}: {error}",
+            file=sys.stderr,
+        )
+        print("Start it in another terminal with: devcopilot-server", file=sys.stderr)
+        raise SystemExit(1)
+
+    binary_name = claude_binary_name(settings)
+    binary_path = resolve_client_binary(
+        binary_name=binary_name,
+        display_name=_DISPLAY_NAME,
+        install_hint=_INSTALL_HINT,
+    )
+    args = list(sys.argv[1:] if argv is None else argv)
+    run_client_process(
+        command=build_claude_launcher_command(binary_path=binary_path, argv=args),
+        env=build_claude_launcher_env(
+            proxy_root_url=proxy_root_url,
+            auth_token=settings.anthropic_auth_token,
+            base_env=os.environ,
+        ),
+        binary_name=binary_name,
+        display_name=_DISPLAY_NAME,
+        install_hint=_INSTALL_HINT,
+    )
+
+
+def claude_binary_name(settings: Settings) -> str:
+    """Return the configured Claude Code binary name."""
+
+    return settings.claude_cli_bin or _DEFAULT_BINARY
+
+
+def build_claude_launcher_command(
+    *, binary_path: str, argv: Sequence[str]
+) -> list[str]:
+    """Return the Claude wrapper command without changing user arguments."""
+
+    return [binary_path, *argv]
+
+
+def build_claude_launcher_env(
+    *,
+    proxy_root_url: str,
+    auth_token: str,
+    base_env: Mapping[str, str],
+) -> dict[str, str]:
+    """Return a Claude Code environment that targets the local proxy."""
+
+    env = {
+        key: value
+        for key, value in base_env.items()
+        if not key.startswith("ANTHROPIC_")
+    }
+    env["ANTHROPIC_BASE_URL"] = proxy_root_url
+    env["CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY"] = "1"
+    env["CLAUDE_CODE_AUTO_COMPACT_WINDOW"] = CLAUDE_CODE_AUTO_COMPACT_WINDOW
+    env["ANTHROPIC_AUTH_TOKEN"] = claude_auth_token(auth_token)
+    return env

cli/launchers/codex.py

@@ -0,0 +1,204 @@
+"""Installed `devcopilot-codex` launcher."""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+from collections.abc import Mapping, Sequence
+from urllib.request import Request, urlopen
+
+from api.admin_urls import local_proxy_root_url
+from config.paths import codex_model_catalog_path
+from config.settings import Settings, get_settings
+
+from .codex_model_catalog import build_codex_model_catalog, write_codex_model_catalog
+from .common import (
+    PROXY_PREFLIGHT_TIMEOUT_SECONDS,
+    preflight_proxy,
+    resolve_client_binary,
+    run_client_process,
+)
+
+_CODEX_AUTH_ENV_KEY = "FCC_CODEX_API_KEY"
+_DISPLAY_NAME = "Codex CLI"
+_DEFAULT_BINARY = "codex"
+_INSTALL_HINT = "Install Codex with: npm install -g @openai/codex"
+_STRIPPED_CODEX_ENV_KEYS = frozenset(
+    {
+        "OPENAI_API_KEY",
+        "OPENAI_BASE_URL",
+        "OPENAI_API_BASE",
+        "OPENAI_ORG_ID",
+        "OPENAI_ORGANIZATION",
+        "CODEX_API_KEY",
+        _CODEX_AUTH_ENV_KEY,
+    }
+)
+
+
+def launch(argv: Sequence[str] | None = None) -> None:
+    """Launch Codex CLI with DevCopilot proxy configuration."""
+
+    settings = get_settings()
+    proxy_root_url = local_proxy_root_url(settings)
+    if error := preflight_proxy(proxy_root_url):
+        print(
+            f"DevCopilot proxy is not reachable at {proxy_root_url}: {error}",
+            file=sys.stderr,
+        )
+        print("Start it in another terminal with: devcopilot-server", file=sys.stderr)
+        raise SystemExit(1)
+
+    binary_name = codex_binary_name(settings)
+    binary_path = resolve_client_binary(
+        binary_name=binary_name,
+        display_name=_DISPLAY_NAME,
+        install_hint=_INSTALL_HINT,
+    )
+    catalog_args = codex_model_catalog_config_args(proxy_root_url, settings)
+    args = list(sys.argv[1:] if argv is None else argv)
+    run_client_process(
+        command=build_codex_launcher_command(
+            binary_path=binary_path,
+            argv=args,
+            settings=settings,
+            proxy_root_url=proxy_root_url,
+            catalog_config_args=catalog_args,
+        ),
+        env=build_codex_launcher_env(
+            auth_token=settings.anthropic_auth_token,
+            base_env=os.environ,
+        ),
+        binary_name=binary_name,
+        display_name=_DISPLAY_NAME,
+        install_hint=_INSTALL_HINT,
+    )
+
+
+def codex_binary_name(settings: Settings) -> str:
+    """Return the configured Codex binary name."""
+
+    return settings.codex_cli_bin or _DEFAULT_BINARY
+
+
+def build_codex_launcher_command(
+    *,
+    binary_path: str,
+    argv: Sequence[str],
+    settings: Settings,
+    proxy_root_url: str,
+    catalog_config_args: Sequence[str] = (),
+) -> list[str]:
+    """Return a Codex command with ephemeral DevCopilot provider config."""
+
+    return [
+        binary_path,
+        *catalog_config_args,
+        *codex_config_args(
+            api_url=_ensure_v1_url(proxy_root_url),
+            model=getattr(settings, "model", None),
+        ),
+        *argv,
+    ]
+
+
+def build_codex_launcher_env(
+    *,
+    auth_token: str,
+    base_env: Mapping[str, str],
+) -> dict[str, str]:
+    """Return a Codex environment that targets the local proxy provider."""
+
+    env = {
+        key: value
+        for key, value in base_env.items()
+        if key not in _STRIPPED_CODEX_ENV_KEYS and not key.startswith("OPENAI_")
+    }
+    env[_CODEX_AUTH_ENV_KEY] = auth_token.strip() or "fcc-no-auth"
+    return env
+
+
+def codex_model_catalog_config_args(
+    proxy_root_url: str, settings: Settings
+) -> list[str]:
+    """Prepare the generated Codex model catalog and return its config args."""
+
+    try:
+        models_response = fetch_proxy_models_response(
+            proxy_root_url, settings.anthropic_auth_token
+        )
+        catalog = build_codex_model_catalog(models_response)
+        models = catalog.get("models")
+        if not isinstance(models, list) or not models:
+            print(
+                "DevCopilot warning: Codex model catalog is empty; "
+                "launching without model picker catalog.",
+                file=sys.stderr,
+            )
+            return []
+        catalog_path = codex_model_catalog_path()
+        write_codex_model_catalog(catalog_path, catalog)
+    except Exception as exc:
+        print(
+            "DevCopilot warning: could not prepare Codex model catalog "
+            f"({exc}); launching without model picker catalog.",
+            file=sys.stderr,
+        )
+        return []
+
+    return build_model_catalog_config_args(str(catalog_path))
+
+
+def fetch_proxy_models_response(
+    proxy_root_url: str, auth_token: str
+) -> dict[str, object]:
+    """Fetch the local proxy `/v1/models` response for Codex catalog generation."""
+
+    url = f"{proxy_root_url.rstrip('/')}/v1/models"
+    headers: dict[str, str] = {}
+    if token := auth_token.strip():
+        headers["X-API-Key"] = token
+
+    request = Request(url, headers=headers, method="GET")
+    with urlopen(request, timeout=PROXY_PREFLIGHT_TIMEOUT_SECONDS) as response:
+        payload = json.loads(response.read().decode("utf-8"))
+
+    if not isinstance(payload, dict):
+        raise ValueError("model list response was not a JSON object")
+    return payload
+
+
+def build_model_catalog_config_args(catalog_path: str) -> list[str]:
+    """Return Codex config args for a generated model catalog."""
+
+    return ["-c", _toml_assignment("model_catalog_json", catalog_path)]
+
+
+def codex_config_args(*, api_url: str, model: str | None = None) -> list[str]:
+    """Return Codex `-c` assignments for the ephemeral FCC provider."""
+
+    args = [
+        "-c",
+        _toml_assignment("model_provider", "fcc"),
+        "-c",
+        _toml_assignment("model_providers.fcc.name", "DevCopilot"),
+        "-c",
+        _toml_assignment("model_providers.fcc.base_url", _ensure_v1_url(api_url)),
+        "-c",
+        _toml_assignment("model_providers.fcc.env_key", _CODEX_AUTH_ENV_KEY),
+        "-c",
+        _toml_assignment("model_providers.fcc.wire_api", "responses"),
+    ]
+    if model:
+        args.extend(["-c", _toml_assignment("model", model)])
+    return args
+
+
+def _ensure_v1_url(url: str) -> str:
+    stripped = url.rstrip("/")
+    return stripped if stripped.endswith("/v1") else f"{stripped}/v1"
+
+
+def _toml_assignment(key: str, value: str) -> str:
+    return f"{key}={json.dumps(value)}"