rlmness-cli 0.2.0__py3-none-any.whl

rlmagent/backend_context.py

@@ -0,0 +1,74 @@
+"""Frontend metadata and policies for a backend-owned execution tree."""
+from types import SimpleNamespace
+
+from rlmagent.agents.approval import Approver
+from rlmagent.agents.budget import BudgetedProvider
+from rlmagent.agents.trace import TracedProvider, Tracer
+from rlmagent.model.external import with_external
+
+
+class BackendContext:
+    def __init__(self, *, provider, provider_name, model, cwd, allowance,
+                 sessions_dir, kernel="wasm", approver=None, network=False,
+                 cell_timeout=300, max_agents=50, tracer=None, **metadata):
+        self.provider = BudgetedProvider(with_external(provider), allowance)
+        self.provider_name, self.model, self.cwd = provider_name, model, cwd
+        self.allowance, self.sessions_dir = allowance, sessions_dir
+        self.kernel_kind, self.network = kernel, network
+        self.approver = approver or Approver("deny")
+        self.cell_timeout, self.max_agents = cell_timeout, max_agents
+        self.tracer = tracer or Tracer(None)
+        self.improver = None
+        self.records, self.backend_agents = {}, {}
+        self.nodes = {"root": SimpleNamespace(context=None)}
+        self._finished = False
+        self.__dict__.update(metadata)
+
+    async def start(self):
+        pass
+
+    def root_id(self):
+        return "root"
+
+    def root_kernel(self):
+        # Tool metadata identifies the coding route. The solver owns execution.
+        return self
+
+    async def run(self, code, timeout=None):
+        raise RuntimeError("submit code through the backend solver")
+
+    def attach(self, agent, session):
+        self.session = session
+
+    def provider_for(self, agent):
+        return TracedProvider(self, agent)
+
+    def use_provider(self, provider, provider_name):
+        self.provider = BudgetedProvider(with_external(provider), self.allowance)
+        self.provider_name = provider_name
+        return self.provider
+
+    def _role(self, name):
+        if self.improver is None:
+            raise RuntimeError("playbook unavailable")
+        entry = self.improver.entry(name)
+        if entry['kind'] != 'role':
+            raise ValueError("entry is not a role")
+        return entry['content']
+
+    def child_session_ids(self, parent):
+        return []
+
+    def finish_trace(self, complete=True):
+        if self._finished:
+            return None
+        self._finished = True
+        agents = [{"agent": key, "parent": value.get("parent_run_id"),
+                   "task": value.get("instruction"), "status": value.get("status"),
+                   "session": getattr(getattr(self, "session", None), "session_id", None)
+                   if key == "root" else None}
+                  for key, value in self.backend_agents.items()]
+        return self.tracer.finish(agents, self.provider.refusal, complete)
+
+    async def close(self):
+        self.finish_trace()

rlmagent/cli/__init__.py

@@ -0,0 +1,5 @@
+"""rlm-agent cli: the command-line entry point."""
+
+from rlmagent.cli.main import get_version, main
+
+__all__ = ["get_version", "main"]

rlmagent/cli/config_cmd.py

@@ -0,0 +1,177 @@
+"""``rlm-agent config`` — interactive provider configuration."""
+
+from __future__ import annotations
+
+import argparse
+import os
+from collections.abc import Sequence
+
+from rlmagent.config import prompts
+from rlmagent.config.store import (
+    PROVIDERS,
+    config_path,
+    load_config,
+    mask_key,
+    provider_info,
+    save_config,
+)
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(prog="rlm-agent config")
+    p.add_argument("--provider", default=None, help="Provider key (skips the menu).")
+    p.add_argument("--model", default=None, help="Model identifier (skips the menu).")
+    p.add_argument(
+        "--api-key", default=None,
+        help="API key (skips the prompt). Also read from RLM_AGENT_API_KEY.",
+    )
+    p.add_argument(
+        "--visible", action="store_true",
+        help="Type the API key visibly, for terminals without hidden input.",
+    )
+    sub = p.add_subparsers(dest="action")
+    sub.add_parser("show", help="Show the saved configuration (keys masked).")
+    sub.add_parser("path", help="Print the configuration file path.")
+    sub.add_parser("doctor", help="Report this terminal's hidden-input support.")
+    return p
+
+
+def _doctor() -> int:
+    """Print terminal capability diagnostics."""
+    from rlmagent.config.secure_input import describe_terminal
+
+    prompts.info("Terminal hidden-input diagnostics:\n")
+    for line in describe_terminal():
+        prompts.info(f"  {line}")
+    prompts.info(
+        "\nIf hidden input is unavailable, use one of:\n"
+        "  rlm-agent config --visible\n"
+        "  rlm-agent config --provider openai --model gpt-5 --api-key sk-...\n"
+        "  $env:RLM_AGENT_API_KEY='sk-...'; rlm-agent config --provider openai"
+    )
+    return 0
+
+
+def _save_noninteractive(
+    provider: str, model: str | None, api_key: str | None,
+) -> int:
+    """Save configuration without prompting."""
+    try:
+        info = provider_info(provider.strip().lower())
+    except KeyError:
+        valid = ", ".join(p.key for p in PROVIDERS)
+        prompts.info(f"Unknown provider {provider!r}. Choose one of: {valid}")
+        return 1
+
+    cfg = load_config()
+    key = (api_key or "").strip()
+    if not key and info.needs_key and info.key not in cfg.api_keys:
+        prompts.info(f"{info.label} requires an API key (--api-key or RLM_AGENT_API_KEY).")
+        return 1
+
+    cfg.provider = info.key
+    cfg.model = model or cfg.model or info.models[0]
+    if key:
+        cfg.api_keys[info.key] = key
+    path = save_config(cfg)
+
+    prompts.info(f"Configuration saved to {path}")
+    prompts.info(f"Provider: {info.label}")
+    prompts.info(f"Model:    {cfg.model}")
+    return 0
+
+
+#: Environment variables that take precedence over the saved file for a run.
+OVERRIDES = ("RLM_AGENT_PROVIDER", "RLM_AGENT_MODEL", "RLM_AGENT_API_KEY", "RLM_AGENT_HOME")
+
+
+def _show() -> int:
+    """Print the saved configuration with API keys masked, and what the environment overrides."""
+    import os
+
+    cfg = load_config()
+    path = config_path()
+    overrides = [(name, os.environ[name]) for name in OVERRIDES if os.environ.get(name)]
+    if not path.exists():
+        prompts.info(f"No configuration at {path}. Run 'rlm-agent config' to create one.")
+    else:
+        prompts.info(f"Config: {path}")
+        prompts.info(f"Provider: {cfg.provider or '(unset)'}")
+        prompts.info(f"Model:    {cfg.model or '(unset)'}")
+        for name in sorted(cfg.api_keys):
+            prompts.info(f"  {name}: {mask_key(cfg.api_keys[name])}")
+    if overrides:
+        prompts.info("Set in the environment, used instead of the file:")
+        for name, value in overrides:
+            shown = mask_key(value) if name.endswith("_KEY") else value
+            prompts.info(f"  {name}={shown}")
+    return 0 if path.exists() or overrides else 1
+
+
+def _configure(*, visible: bool = False) -> int:
+    """Run the interactive setup flow."""
+    cfg = load_config()
+
+    labels = [p.label for p in PROVIDERS]
+    default = next(
+        (i for i, p in enumerate(PROVIDERS) if p.key == cfg.provider), 0,
+    )
+    info = PROVIDERS[prompts.choose("Select provider", labels, default=default)]
+
+    prompts.info(f"\n{info.label}")
+
+    existing = cfg.api_keys.get(info.key)
+    key = prompts.ask_api_key(
+        info.label,
+        required=info.needs_key,
+        has_existing=bool(existing),
+        visible=visible,
+    )
+    if key is None:
+        key = existing or ""
+    if info.needs_key and not key.strip():
+        prompts.info("API key must not be empty. Nothing saved.")
+        return 1
+
+    current_model = cfg.model if cfg.provider == info.key else None
+    model = prompts.choose_model(list(info.models), current=current_model)
+
+    if not prompts.confirm("Save as default?"):
+        prompts.info("Nothing saved.")
+        return 1
+
+    cfg.provider = info.key
+    cfg.model = model
+    if key.strip():
+        cfg.api_keys[info.key] = key.strip()
+    path = save_config(cfg)
+
+    prompts.info(f"\nConfiguration saved to {path}")
+    prompts.info(f"Provider: {info.label}")
+    prompts.info(f"Model:    {model}")
+    return 0
+
+
+def handle_config(argv: Sequence[str]) -> int:
+    """Entry point for the ``config`` subcommand."""
+    ns = _build_parser().parse_args(list(argv))
+    if ns.action == "show":
+        return _show()
+    if ns.action == "path":
+        prompts.info(str(config_path()))
+        return 0
+    if ns.action == "doctor":
+        return _doctor()
+
+    api_key = ns.api_key or os.environ.get("RLM_AGENT_API_KEY")
+    if ns.provider and (api_key or ns.model):
+        return _save_noninteractive(ns.provider, ns.model, api_key)
+
+    try:
+        return _configure(visible=ns.visible)
+    except prompts.PromptAborted:
+        prompts.info("\nCancelled. Nothing saved.")
+        return 130
+
+
+__all__ = ["handle_config"]

rlmagent/cli/health.py

@@ -0,0 +1,156 @@
+"""`rlm-agent status` and `rlm-agent doctor`: what is set up, what is running, what is stale."""
+
+from __future__ import annotations
+
+import os
+import shutil
+import sys
+from dataclasses import dataclass
+
+
+@dataclass
+class Check:
+    name: str
+    ok: bool
+    detail: str
+    fix: str = ""  # what doctor --fix would do; empty when it cannot fix this
+
+
+def _config() -> Check:
+    from rlmagent.config.store import config_path, load_config
+
+    path = config_path()
+    if not path.exists():
+        env = next((n for n in ("OPENROUTER_API_KEY", "ANTHROPIC_API_KEY", "OPENAI_API_KEY",
+                                "RLM_AGENT_API_KEY") if os.environ.get(n)), None)
+        if env:
+            return Check("provider", True, f"no saved configuration; {env} is set")
+        return Check("provider", False, "no configuration; run rlm-agent to pick a provider, or rlm-agent config")
+    cfg = load_config()
+    has_key = bool(cfg.api_keys.get(cfg.provider or "", ""))
+    return Check("provider", bool(cfg.provider),
+                 f"{cfg.provider or '(unset)'} / {cfg.model or '(unset)'}, "
+                 f"key {'saved' if has_key else 'not saved (environment or none)'}")
+
+
+def _sandbox() -> Check:
+    try:
+        from rlmness.wasm_runtime import wasm_available
+    except ImportError:
+        return Check("sandbox", False, "rlmness is not installed")
+    if shutil.which("node") is None:
+        return Check("sandbox", False, "Node.js 18+ is not on PATH; install it for --kernel wasm")
+    if not wasm_available():
+        return Check("sandbox", False, "Pyodide is not installed", "install Pyodide (rlmness --setup)")
+    return Check("sandbox", True, "Node and Pyodide found")
+
+
+def _git() -> Check:
+    ok = shutil.which("git") is not None
+    return Check("git", ok, "found; /undo and /diff work" if ok else "not on PATH; /undo and /diff are off")
+
+
+def _workers() -> list[Check]:
+    from rlmagent import worker
+
+    base = worker.root()
+    rows = []
+    for path in sorted(base.iterdir()) if base.is_dir() else []:
+        if not path.is_dir():
+            continue
+        meta = worker.state_of(path.name)
+        recorded = meta.get("state", "?")
+        if meta["alive"]:
+            rows.append(Check(f"worker {path.name}", True, f"{recorded}, session {meta.get('session')}"))
+        elif recorded in ("starting", "idle", "busy"):
+            rows.append(Check(f"worker {path.name}", False,
+                              f"recorded as {recorded} but its process is gone", "mark it stopped"))
+        else:
+            rows.append(Check(f"worker {path.name}", True, recorded))
+    return rows
+
+
+def _sessions_open() -> list[Check]:
+    from rlmagent.agentnet import _home, _read
+    from rlmagent.worker import _pid_alive
+
+    base = _home()
+    rows = []
+    for path in sorted(base.iterdir()) if base.is_dir() else []:
+        meta = _read(path / "meta.json")
+        if meta is None:
+            continue
+        if meta.get("pid") and _pid_alive(int(meta["pid"])):
+            rows.append(Check(f"session {path.name}", True, f"open in {meta.get('cwd')}"))
+        else:
+            rows.append(Check(f"session {path.name}", False, "registered but its process is gone",
+                              "remove the registration"))
+    return rows
+
+
+def _mcp() -> Check:
+    from rlmagent.mcp import load_configs
+    from rlmagent.plugins import rlm_agent_home
+
+    servers, problems = load_configs(rlm_agent_home(), None)
+    if problems:
+        return Check("mcp", False, "; ".join(problems))
+    return Check("mcp", True, f"{len(servers)} server(s) in the home mcp.json")
+
+
+def _search() -> Check:
+    from rlmagent.websearch import SERVICES, configured
+
+    name = configured()
+    return Check("web search", True,
+                 f"{name} is set" if name else f"off; set one of {', '.join(SERVICES)}")
+
+
+def checks() -> list[Check]:
+    return [_config(), _sandbox(), _git(), _mcp(), _search(), *_workers(), *_sessions_open()]
+
+
+def _fix(check: Check) -> str:
+    if check.name == "sandbox":
+        from rlmness import home
+
+        return "installed Pyodide" if home.setup() == 0 else "Pyodide install failed"
+    if check.name.startswith("worker "):
+        from rlmagent import worker
+
+        name = check.name.split(" ", 1)[1]
+        meta = worker.state_of(name)
+        meta.update(state="stopped", pid=None)
+        meta.pop("alive", None)
+        worker._write(worker.folder(name) / "meta.json", meta)
+        return "marked stopped"
+    if check.name.startswith("session "):
+        from rlmagent.agentnet import _home
+
+        (_home() / check.name.split(" ", 1)[1] / "meta.json").unlink(missing_ok=True)
+        return "removed"
+    return "nothing done"
+
+
+def run(argv: list[str], *, doctor: bool) -> int:
+    from rlmagent.cli.main import get_version
+    from rlmagent.plugins import rlm_agent_home
+
+    fix = "--fix" in argv
+    out = sys.stdout
+    out.write(f"rlm-agent {get_version()}, home {rlm_agent_home()}\n")
+    found = checks()
+    problems = 0
+    for check in found:
+        mark = "ok " if check.ok else "!! "
+        out.write(f"{mark}{check.name}: {check.detail}\n")
+        if not check.ok:
+            problems += 1
+            if doctor and check.fix:
+                out.write(f"    {'fixing: ' + _fix(check) if fix else 'doctor --fix would ' + check.fix}\n")
+    if doctor:
+        out.write("no problems found\n" if not problems else f"{problems} problem(s)\n")
+    return 1 if doctor and problems and not fix else 0
+
+
+__all__ = ["Check", "checks", "run"]