rlmness-cli 0.2.0__py3-none-any.whl

rlmagent/cli/update.py

@@ -0,0 +1,188 @@
+"""Upgrade an installed application using its package manager."""
+
+from __future__ import annotations
+
+import argparse
+import importlib.metadata
+import json
+import re
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+from packaging.specifiers import InvalidSpecifier, SpecifierSet
+from packaging.version import InvalidVersion, Version
+
+
+def select_release(document: dict, channel: str) -> str:
+    """Select a published, non-yanked release from the requested channel."""
+    candidates = []
+    current_python = ".".join(str(part) for part in sys.version_info[:3])
+    for text, files in document.get("releases", {}).items():
+        try:
+            version = Version(text)
+        except InvalidVersion:
+            continue
+        eligible = {
+            "stable": not version.is_prerelease and not version.is_devrelease,
+            "preview": version.is_prerelease and not version.is_devrelease,
+            "nightly": version.is_devrelease,
+        }[channel]
+        if not eligible:
+            continue
+        for artifact in files:
+            if artifact.get("yanked", False):
+                continue
+            try:
+                supported = SpecifierSet(artifact.get("requires_python") or "")
+            except InvalidSpecifier:
+                continue
+            if supported.contains(current_python, prereleases=True):
+                candidates.append(version)
+                break
+    if not candidates:
+        raise ValueError(f"No compatible, non-yanked {channel} release is published")
+    return str(max(candidates))
+
+
+def run(argv: list[str]) -> int:
+    if argv[:1] == ["--run"]:
+        from rlmagent.managed_release import run as managed_run
+
+        try:
+            return managed_run(argv[1:])
+        except (OSError, ValueError) as error:
+            print(str(error), file=sys.stderr)
+            return 1
+    parser = argparse.ArgumentParser(prog="rlm-agent update")
+    parser.add_argument("--manifest", type=Path, help="Verified offline wheel-bundle manifest")
+    parser.add_argument(
+        "--managed", action="store_true", help="Use isolated installations and atomic activation"
+    )
+    parser.add_argument("--drain", action="store_true", help="Let workers finish before activation")
+    parser.add_argument("--wait", type=float, default=60)
+    parser.add_argument("--restart-workers", action="store_true")
+    parser.add_argument("--apply", action="store_true", help="Run the upgrade command.")
+    choice = parser.add_mutually_exclusive_group()
+    choice.add_argument("--check", action="store_true", help="Compare against the package index.")
+    choice.add_argument("--version", dest="target", help="Install a specific package version.")
+    choice.add_argument(
+        "--rollback", action="store_true", help="Reinstall the previously recorded version."
+    )
+    parser.add_argument("--channel", choices=("stable", "preview", "nightly"), default="stable")
+    args = parser.parse_args(argv)
+    if args.managed or args.manifest is not None:
+        if args.target is not None or args.check or (args.manifest is not None and args.rollback):
+            parser.error(
+                "Use one managed manifest or --managed --rollback; omit --version and --check"
+            )
+        from rlmagent import managed_release
+
+        try:
+            if not args.apply:
+                if args.manifest is not None:
+                    print(json.dumps(managed_release.manifest(args.manifest), indent=2))
+                print("Use --apply to install or roll back the reviewed managed release.")
+                return 0
+            if args.rollback:
+                record = managed_release.rollback(
+                    drain=args.drain, wait=args.wait, restart=args.restart_workers
+                )
+            elif args.manifest is not None:
+                record = managed_release.install(
+                    args.manifest, drain=args.drain, wait=args.wait, restart=args.restart_workers
+                )
+            else:
+                raise ValueError("Managed installation needs --manifest, or --rollback")
+            print(f"Active managed release: {record['version']} ({record['channel']})")
+            return 0
+        except (OSError, ValueError, subprocess.SubprocessError) as error:
+            print(f"Managed update failed: {error}", file=sys.stderr)
+            return 1
+    if args.drain or args.restart_workers:
+        parser.error("Worker drain and restart require a managed installation")
+    try:
+        package = importlib.metadata.distribution("rlmness-cli")
+    except importlib.metadata.PackageNotFoundError:
+        parser.exit(1, "rlmagent must be installed to update it.\n")
+    if package.read_text("direct_url.json"):
+        parser.exit(1, "Update this local or URL installation from its original source.\n")
+
+    from rlmagent.plugins import rlm_agent_home
+
+    receipt = rlm_agent_home() / "updates" / "previous.json"
+    target = args.target
+    if args.rollback:
+        try:
+            target = json.loads(receipt.read_text(encoding="utf-8"))["version"]
+        except (OSError, ValueError, KeyError):
+            parser.exit(1, "No successful earlier upgrade has been recorded.\n")
+    if target is not None and (
+        not isinstance(target, str) or not re.fullmatch(r"[0-9][A-Za-z0-9.!+_-]*", target)
+    ):
+        parser.error("invalid package version")
+    if args.check or (args.channel != "stable" and target is None):
+        import os
+
+        if os.environ.get("RLM_AGENT_OFFLINE") == "1":
+            parser.exit(1, "Update checks are disabled in offline startup mode.\n")
+        from rlmagent.model.transport.client import fetch_json
+
+        try:
+            latest = select_release(
+                fetch_json("https://pypi.org/pypi/rlmness-cli/json", timeout=15), args.channel
+            )
+        except ValueError as error:
+            parser.exit(1, str(error) + "\n")
+        except Exception:
+            parser.exit(1, "Could not check the package index.\n")
+        if args.check:
+            print(f"Installed rlmagent {package.version}; index {args.channel} release {latest}")
+            return 0
+        target = latest
+
+    prefix = Path(sys.prefix)
+    if (prefix / "uv-receipt.toml").is_file():
+        command = ["uv", "tool", "upgrade", "rlmness-cli"]
+    elif (prefix / "pipx_metadata.json").is_file():
+        command = ["pipx", "upgrade", "rlmness-cli"]
+    elif (package.read_text("INSTALLER") or "").strip() == "uv":
+        command = ["uv", "pip", "install", "--python", sys.executable, "--upgrade", "rlmness-cli"]
+    else:
+        command = [sys.executable, "-m", "pip", "install", "--upgrade", "rlmness-cli"]
+
+    if target is not None:
+        spec = f"rlmness-cli=={target}"
+        if command[:3] == ["uv", "tool", "upgrade"]:
+            command = ["uv", "tool", "install", "--force", spec]
+        elif command[:2] == ["pipx", "upgrade"]:
+            command = ["pipx", "install", "--force", spec]
+        else:
+            command[-1] = spec
+    if args.channel in ("preview", "nightly"):
+        if command[0] != "pipx":
+            command.extend(["--prerelease", "allow"] if command[0] == "uv" else ["--pre"])
+
+    print(f"Installed rlmagent {package.version}", flush=True)
+    if not args.apply:
+        print("Run rlm-agent update --apply with the same options to install the requested update.")
+        return 0
+    executable = shutil.which(command[0])
+    if executable is None:
+        parser.exit(1, f"The installer {command[0]} is missing from PATH.\n")
+    try:
+        status = subprocess.run([executable, *command[1:]], check=False).returncode
+        if status == 0:
+            receipt.parent.mkdir(parents=True, exist_ok=True)
+            from uuid import uuid4
+
+            staged = receipt.with_suffix(f".{uuid4().hex}.tmp")
+            try:
+                staged.write_text(json.dumps({"version": package.version}), encoding="utf-8")
+                staged.replace(receipt)
+            finally:
+                staged.unlink(missing_ok=True)
+        return status
+    except OSError as exc:
+        parser.exit(1, f"Could not start the installer: {exc}\n")

rlmagent/clipboard.py

@@ -0,0 +1,63 @@
+"""Native clipboard writes with explicit terminal-delivery fallback."""
+
+import base64
+import os
+import shutil
+import subprocess
+import sys
+
+
+def sequence(text: str, *, tmux=False) -> str:
+    encoded = base64.b64encode(text.encode()).decode()
+    value = f"\x1b]52;c;{encoded}\x07"
+    return "\x1bPtmux;" + value.replace("\x1b", "\x1b\x1b") + "\x1b\\" if tmux else value
+
+
+def copy(text: str, terminal_write) -> str:
+    if len(text.encode()) > 1024 * 1024:
+        raise ValueError("Clipboard content exceeds the 1 MiB limit")
+    remote = bool(
+        os.environ.get("SSH_CONNECTION") or os.environ.get("SSH_TTY") or os.environ.get("TMUX")
+    )
+    command = None
+    if not remote:
+        if sys.platform == "win32":
+            shell = shutil.which("powershell.exe")
+            if shell:
+                command = [
+                    shell,
+                    "-NoProfile",
+                    "-NonInteractive",
+                    "-Command",
+                    "[Console]::InputEncoding = [Text.UTF8Encoding]::new(); "
+                    "Set-Clipboard -Value ([Console]::In.ReadToEnd())",
+                ]
+        else:
+            for candidate in (
+                ("pbcopy",) if sys.platform == "darwin" else ("wl-copy", "xclip", "xsel")
+            ):
+                executable = shutil.which(candidate)
+                if executable:
+                    command = [executable]
+                    if candidate == "xclip":
+                        command += ["-selection", "clipboard"]
+                    elif candidate == "xsel":
+                        command += ["--clipboard", "--input"]
+                    break
+    if command is not None:
+        try:
+            result = subprocess.run(
+                command,
+                input=text.encode(),
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                timeout=5,
+                check=False,
+                creationflags=getattr(subprocess, "CREATE_NO_WINDOW", 0) if os.name == "nt" else 0,
+            )
+            if result.returncode == 0:
+                return "Copied to the native clipboard."
+        except (OSError, subprocess.TimeoutExpired):
+            pass
+    terminal_write(sequence(text, tmux=bool(os.environ.get("TMUX"))))
+    return "Clipboard delivery requested from the terminal; delivery is unconfirmed."

rlmagent/config/__init__.py

@@ -0,0 +1,37 @@
+"""rlm-agent config: application configuration and provider selection."""
+
+from rlmagent.config.config import (
+    list_providers,
+    resolve_provider,
+    select_provider,
+    setup_provider,
+)
+from rlmagent.config.loader import (
+    apply_config,
+    load_api_key,
+    load_model,
+    load_provider,
+)
+from rlmagent.config.store import (
+    RlmAgentConfig,
+    config_path,
+    load_config,
+    mask_key,
+    save_config,
+)
+
+__all__ = [
+    "RlmAgentConfig",
+    "apply_config",
+    "config_path",
+    "list_providers",
+    "load_api_key",
+    "load_config",
+    "load_model",
+    "load_provider",
+    "mask_key",
+    "resolve_provider",
+    "save_config",
+    "select_provider",
+    "setup_provider",
+]

rlmagent/config/config.py

@@ -0,0 +1,297 @@
+"""Provider resolution, catalog, and environment-based auto-detection."""
+
+from __future__ import annotations
+
+import os
+import sys
+from dataclasses import replace
+
+from rlmagent.harness.provider.base import ModelProvider
+from rlmagent.model.settings import (
+    AnthropicProfile,
+    ConfigError,
+    OpenAIProfile,
+    load_anthropic_profile,
+    load_openai_profile,
+)
+
+# ---------------------------------------------------------------------------
+# Known provider identifiers
+# ---------------------------------------------------------------------------
+
+_KNOWN_PROVIDERS = ("anthropic", "openai", "openrouter", "ollama", "huggingface", "scripted", "cli", "vertex",
+                    "google", "mistral", "azure", "codex", "copilot", "claude-subscription", "xai", "xai-subscription")
+
+# OpenAI-compatible backends reuse the OpenAI adapter with a different base URL.
+_OPENAI_COMPATIBLE = ("openai", "openrouter", "ollama", "huggingface")
+
+
+# ---------------------------------------------------------------------------
+# Detection
+# ---------------------------------------------------------------------------
+
+
+def _detect_provider_name() -> str | None:
+    """Infer the provider name from environment variables, then saved config."""
+    explicit = os.environ.get("RLM_AGENT_PROVIDER")
+    if explicit:
+        return explicit.strip().lower()
+
+    from rlmagent.config.loader import project_settings
+    from rlmagent.config.store import load_config
+
+    project = project_settings().get("provider")
+    if project:
+        return project.lower()
+
+    saved = load_config().provider
+    if saved:
+        return saved.strip().lower()
+
+    if os.environ.get("ANTHROPIC_API_KEY"):
+        return "anthropic"
+    if os.environ.get("OPENAI_API_KEY"):
+        return "openai"
+
+    return None
+
+
+# ---------------------------------------------------------------------------
+# Builder helpers (one per provider)
+# ---------------------------------------------------------------------------
+
+
+def _build_anthropic(profile: AnthropicProfile) -> ModelProvider:
+    """Instantiate an Anthropic adapter from a loaded profile."""
+    try:
+        from rlmagent.model.claude import AnthropicProvider  # type: ignore[import-not-found]
+    except ImportError:
+        raise ConfigError(
+            "The 'anthropic' provider requires the httpx extra.\n"
+            "  Install it with: pip install rlmness-cli[providers]"
+        ) from None
+    return AnthropicProvider(profile)  # type: ignore[return-value]
+
+
+def _build_openai(profile: OpenAIProfile) -> ModelProvider:
+    """Instantiate an OpenAI-compatible adapter from a loaded profile."""
+    try:
+        from rlmagent.model.oai_compatible import OpenAIProvider  # type: ignore[import-not-found]
+    except ImportError:
+        raise ConfigError(
+            "The 'openai' provider requires the httpx extra.\n"
+            "  Install it with: pip install rlmness-cli[providers]"
+        ) from None
+    return OpenAIProvider(profile)  # type: ignore[return-value]
+
+
+# ---------------------------------------------------------------------------
+# Resolution
+# ---------------------------------------------------------------------------
+
+
+def resolve_provider(name: str | None = None) -> ModelProvider:
+    """Return a ready-to-use ``ModelProvider`` for *name*, with any fallbacks."""
+    from rlmagent.model.failover import with_fallbacks
+
+    return with_fallbacks(_resolve_one(name), _resolve_one)
+
+
+def _resolve_one(name: str | None = None) -> ModelProvider:
+    """Build the provider for *name* alone."""
+    resolved = name or _detect_provider_name()
+    if resolved is None:
+        raise ConfigError(
+            "No provider configured.\n"
+            "  Set RLM_AGENT_PROVIDER or export an API key env var.\n"
+            "  Run 'rlm-agent' to pick a provider and model, or 'rlm-agent config'."
+        )
+
+    resolved = resolved.strip().lower()
+    if resolved == "copilot":
+        from rlmagent.model.copilot import CopilotProvider
+        return CopilotProvider()
+    if resolved == "xai-subscription":
+        from rlmagent.model.registered_oauth import BASE, resolve
+        from rlmagent.model.settings import Credential
+
+        return _build_openai(OpenAIProfile(name=resolved, credential=Credential(None, BASE),
+                                          resolver=resolve, endpoint="chat"))
+    if resolved == "claude-subscription":
+        from rlmagent.model.external import ExternalAgentProvider
+        return ExternalAgentProvider()
+
+    if resolved == "codex":
+        from rlmagent.model.settings import Credential
+        from rlmagent.model.subscription import RESOURCE, resolve
+
+        transport = os.environ.get("RLM_AGENT_CODEX_TRANSPORT", "http")
+        if transport not in ("http", "websocket"):
+            raise ConfigError("RLM_AGENT_CODEX_TRANSPORT must be http or websocket")
+        return _build_openai(OpenAIProfile(
+            name="codex", credential=Credential(None, RESOURCE),
+            resolver=resolve, endpoint="responses", transport=transport,
+        ))
+
+    if resolved == "anthropic":
+        profile = load_anthropic_profile()
+        return _build_anthropic(profile)
+
+    if resolved == "google":
+        from rlmagent.model.google import build_google
+
+        return build_google()
+
+    if resolved in ("mistral", "azure", "xai"):
+        from rlmagent.config.loader import load_api_key
+        from rlmagent.config.store import load_config, provider_info
+        from rlmagent.model.settings import Credential
+
+        info = provider_info(resolved)
+        key = load_api_key(resolved)
+        if not key:
+            raise ConfigError(f"{info.key_env} is not set")
+        base = os.environ.get("AZURE_OPENAI_BASE_URL" if resolved == "azure" else resolved.upper() + "_BASE_URL")
+        base = base or load_config().base_urls.get(resolved) or info.base_url
+        if not base:
+            raise ConfigError("Set AZURE_OPENAI_BASE_URL to your deployed /openai/v1 endpoint")
+        credential = (Credential(None, base, (("api-key", key),)) if resolved == "azure"
+                      else Credential(key, base))
+        return _build_openai(OpenAIProfile(name=resolved, credential=credential,
+                                          endpoint="responses" if resolved == "azure" else "chat"))
+
+    if resolved in _OPENAI_COMPATIBLE:
+        # Named for the chosen provider, so replies, stats, and errors say
+        # "openrouter" or "ollama" rather than the shared adapter's "openai".
+        profile = replace(load_openai_profile(), name=resolved)
+        return _build_openai(profile)
+
+    if resolved == "vertex":
+        from rlmagent.model.vertex import build_vertex
+        return build_vertex()
+
+    if resolved == "cli":
+        from rlmagent.model.external import ExternalAgentProvider
+
+        return ExternalAgentProvider()  # type: ignore[return-value]
+
+    if resolved == "scripted":
+        from rlmagent.model.scripted import ReplayProvider
+
+        return ReplayProvider([])  # type: ignore[return-value]
+
+    raise ConfigError(
+        f"Unknown provider: {resolved!r}.\n"
+        f"  Known providers: {', '.join(_KNOWN_PROVIDERS)}"
+    )
+
+
+# ---------------------------------------------------------------------------
+# Catalog
+# ---------------------------------------------------------------------------
+
+
+def _probe_status(provider_name: str) -> str:
+    """Return a short status string for a provider: 'ready', 'no key', etc."""
+    if provider_name == "codex":
+        return "subscription  (rlm-agent provider login codex)"
+    if provider_name in ("google", "mistral", "azure"):
+        from rlmagent.config.loader import load_api_key
+        from rlmagent.config.store import provider_info
+
+        return "key configured" if load_api_key(provider_name) else (
+            f"no key  (set {provider_info(provider_name).key_env})")
+    if provider_name == "anthropic":
+        if not os.environ.get("ANTHROPIC_API_KEY"):
+            return "no key  (set ANTHROPIC_API_KEY)"
+        try:
+            load_anthropic_profile()
+            return "ready"
+        except ConfigError as exc:
+            return f"misconfigured  ({exc})"
+
+    if provider_name == "openai":
+        if not os.environ.get("OPENAI_API_KEY"):
+            return "no key  (set OPENAI_API_KEY)"
+        try:
+            load_openai_profile()
+            return "ready"
+        except ConfigError as exc:
+            return f"misconfigured  ({exc})"
+
+    if provider_name == "scripted":
+        return "available  (test only)"
+
+    return "unknown"
+
+
+def list_providers() -> None:
+    """Print available providers and their configuration status to stderr."""
+    active = _detect_provider_name()
+    sys.stderr.write("Providers:\n")
+    for name in _KNOWN_PROVIDERS:
+        marker = "*" if name == active else " "
+        status = _probe_status(name)
+        sys.stderr.write(f"  {marker} {name:<12}  {status}\n")
+    sys.stderr.flush()
+
+
+def setup_provider() -> None:
+    """Print environment-variable guidance for configuring each provider."""
+    sys.stderr.write(
+        "Provider setup\n"
+        "\nCodex subscription:\n"
+        "  Install rlmagent[subscription], then run rlm-agent provider login codex.\n"
+        "  Use --provider codex; tokens stay in the platform credential store.\n"
+        "\nNative providers:\n"
+        "  GOOGLE_API_KEY, MISTRAL_API_KEY, or AZURE_OPENAI_API_KEY\n"
+        "  Azure also requires AZURE_OPENAI_BASE_URL ending in /openai/v1.\n"
+        "\n"
+        "Set the following environment variables for your chosen provider.\n"
+        "\n"
+        "Anthropic:\n"
+        "  ANTHROPIC_API_KEY       (required)\n"
+        "  ANTHROPIC_BASE_URL      (default: https://api.anthropic.com)\n"
+        "  ANTHROPIC_TIMEOUT       (seconds, default: 120)\n"
+        "  ANTHROPIC_MAX_TOKENS    (default: 16384)\n"
+        "  ANTHROPIC_EXTRA_HEADERS (semicolon-separated Key: Value pairs)\n"
+        "\n"
+        "OpenAI-compatible:\n"
+        "  OPENAI_API_KEY          (required)\n"
+        "  OPENAI_BASE_URL         (default: https://api.openai.com/v1)\n"
+        "  OPENAI_TIMEOUT          (seconds, default: 120)\n"
+        "  OPENAI_ORG_ID           (optional)\n"
+        "  OPENAI_EXTRA_HEADERS    (semicolon-separated Key: Value pairs)\n"
+        "\n"
+        "Google Vertex:\n"
+        "  Install rlmagent[vertex]; configure Application Default Credentials.\n"
+        "  GOOGLE_CLOUD_PROJECT  (required unless ADC supplies a project)\n"
+        "  GOOGLE_CLOUD_LOCATION (default: global)\n"
+        "\n"
+        "Shared:\n"
+        "  RLM_AGENT_PROVIDER          (anthropic | openai | scripted)\n"
+        "  RLM_AGENT_MODEL             (model identifier override)\n"
+        "  RLM_AGENT_MAX_RETRIES       (default: 2)\n"
+        "  RLM_AGENT_MAX_RETRY_DELAY   (seconds, default: 30)\n"
+        "  RLM_AGENT_THINKING_ENABLED  (true/false, default: false)\n"
+        "  RLM_AGENT_THINKING_BUDGET   (token count, optional)\n"
+    )
+    sys.stderr.flush()
+
+
+def select_provider(name: str) -> None:
+    """Validate a provider name for selection."""
+    normalized = name.strip().lower()
+    if normalized not in _KNOWN_PROVIDERS:
+        raise ConfigError(
+            f"Unknown provider: {name!r}.\n"
+            f"  Known providers: {', '.join(_KNOWN_PROVIDERS)}"
+        )
+
+
+__all__ = [
+    "list_providers",
+    "resolve_provider",
+    "select_provider",
+    "setup_provider",
+]