ellf-cli 19.0.18__tar.gz → 20.0.0__tar.gz

{ellf_cli-19.0.18/ellf_cli.egg-info → ellf_cli-20.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ellf-cli
-Version: 19.0.18
+Version: 20.0.0
 Summary: Ellf Command Line Interface
 Home-page: https://prodi.gy
 Author: ExplosionAI GmbH

{ellf_cli-19.0.18 → ellf_cli-20.0.0}/README.md

@@ -939,6 +939,14 @@ Stop a job on the cluster by its ID. Works for workloads that have no matching j
 | `--type` | `str` | Job type, if the cluster does not report one | `None` |
 | `--json` | `bool` | Output the result as JSON | `False` |
 
+### `ellf mcp`
+
+MCP servers that coding agents start themselves after 'ellf login --agent'
+
+#### `ellf mcp kb`
+
+Run the Ellf knowledge base MCP server over stdio, using your ellf login. Coding agents start this themselves once 'ellf login --agent' has set them up.
+
 ### `ellf packages`
 
 View and manage Python packages on the cluster
@@ -1401,8 +1409,8 @@ Send a support request to the Ellf team.
 | `--project` | `str` | Name, slug, or ID of support request's project or the last project if not set | `None` |
 | `--no-project` | `bool` | Explicitly send the request without any project association | `False` |
 | `--conversation` | `UUID` | Conversation ID to attach from PAM when available | `None` |
-| `--session-id` | `str` | Claude Code session ID to use for transcript/debug attachment lookup | `None` |
-| `--transcript-path` | `str` | Path to a Claude transcript .jsonl file to attach explicitly | `None` |
+| `--session-id` | `str` | Agent session ID to use for transcript/debug attachment lookup (defaults to the current session) | `None` |
+| `--transcript-path` | `str` | Path to a session transcript file to attach explicitly | `None` |
 | `--transcript-consent` | `str` | Explicit transcript consent mode: 'summary_only' or 'attach_full_transcript' | `'summary_only'` |
 | `--json` | `bool` | Output the result as JSON | `False` |
 
@@ -1671,7 +1679,8 @@ Log in to your Ellf account. You normally don't need to call this manually. It w
 | `--org` | `str` | Name or ID of the organization to log into. If omitted: auto-select when only one is available, or prompt interactively | `None` |
 | `--cluster` | `str` | Name or ID of the cluster to log into. If omitted: auto-select when only one is available, or prompt interactively | `None` |
 | `--json` | `bool` | Output the result as JSON | `False` |
-| `--claude` | `bool` | Install Ellf Claude Code skills and transcript hook into ~/.claude/ | `False` |
+| `--agent` | `str` | Set up coding agents to work with Ellf: install the Ellf skills and the knowledge base MCP server. One of claude, codex, opencode, copilot; repeat the option or comma-separate them for several | `None` |
+| `--claude` | `bool` | Shortcut for --agent claude | `False` |
 
 ### `ellf logout`
 

ellf_cli-20.0.0/ellf_cli/agents.py

@@ -0,0 +1,367 @@
+"""Local coding agents: where their skills and MCP servers are configured, and
+where they keep session transcripts."""
+
+import importlib.util
+import json
+import os
+import re
+import shutil
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from types import ModuleType
+from typing import Any, Callable, Optional, Union
+
+AGENTS = ("claude", "codex", "opencode", "copilot")
+AGENT_NAMES = {
+    "claude": "Claude Code",
+    "codex": "Codex",
+    "opencode": "OpenCode",
+    "copilot": "GitHub Copilot",
+}
+MCP_SERVER_NAME = "ellf-kb"
+
+
+def _home() -> Path:
+    return Path.home()
+
+
+def _env_dir(var: str, default: Path) -> Path:
+    value = (os.environ.get(var) or "").strip()
+    return Path(value).expanduser() if value else default
+
+
+def _codex_home() -> Path:
+    return _env_dir("CODEX_HOME", _home() / ".codex")
+
+
+def _copilot_home() -> Path:
+    return _env_dir("COPILOT_HOME", _home() / ".copilot")
+
+
+def _opencode_config_dir() -> Path:
+    return _env_dir("XDG_CONFIG_HOME", _home() / ".config") / "opencode"
+
+
+def _vscode_user_dir() -> Path:
+    if sys.platform == "darwin":
+        return _home() / "Library" / "Application Support" / "Code" / "User"
+    if sys.platform == "win32":
+        return _env_dir("APPDATA", _home() / "AppData" / "Roaming") / "Code" / "User"
+    return _env_dir("XDG_CONFIG_HOME", _home() / ".config") / "Code" / "User"
+
+
+def skills_dirs(agent: str) -> list[Path]:
+    """The user-level skill directories an agent reads ellf skills from."""
+    if agent == "claude":
+        return [_home() / ".claude" / "skills"]
+    # Codex, OpenCode and Copilot (CLI and VS Code) all read ~/.agents/skills.
+    dirs = [_home() / ".agents" / "skills"]
+    if agent == "copilot" and os.environ.get("COPILOT_HOME"):
+        # Copilot CLI stops reading ~/.agents/skills when COPILOT_HOME is set.
+        dirs.append(_copilot_home() / "skills")
+    return dirs
+
+
+def ellf_skills_dir() -> Optional[Path]:
+    path = Path(__file__).resolve().parent / "ellf_skills"
+    return path if (path / "render.py").exists() else None
+
+
+def _load_renderer(skills_dir: Path) -> ModuleType:
+    spec = importlib.util.spec_from_file_location(
+        "ellf_skills_render", skills_dir / "render.py"
+    )
+    assert spec is not None and spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def install_skills(
+    agents: list[str],
+    skills_dir: Path,
+    confirm_removal: Callable[[list[Path]], bool],
+) -> dict[Path, list[str]]:
+    """Render the coding skills into every directory the agents read.
+
+    Skill folders left by an install from before the renderer kept a record
+    are passed to ``confirm_removal`` and only removed if it returns True.
+    """
+    renderer = _load_renderer(skills_dir)
+    dests: list[Path] = []
+    for agent in agents:
+        for path in skills_dirs(agent):
+            if path not in dests:
+                dests.append(path)
+    installed = {}
+    for dest in dests:
+        stale = renderer.unrecorded_skills("coding", dest)
+        if stale and not confirm_removal([dest / name for name in stale]):
+            stale = []
+        installed[dest] = renderer.render_skills("coding", dest, remove=stale)
+    return installed
+
+
+# MCP configuration
+
+
+def mcp_command() -> Optional[list[str]]:
+    """How agents start the knowledge base server: this install's ellf script
+    by absolute path, as agents don't run it from the user's shell. Not
+    ``python -m ellf_cli``, which puts the agent's working directory first on
+    sys.path, where a project's own modules would shadow the CLI's imports."""
+    script = Path(sys.argv[0])
+    if not (script.stem == "ellf" and script.is_file()):
+        found = shutil.which("ellf")
+        if found is None:
+            return None
+        script = Path(found)
+    return [str(script.absolute()), "mcp", "kb"]
+
+
+class MCPConfigError(Exception):
+    """The agent's config file couldn't be updated; ``snippet`` is what to add
+    by hand."""
+
+    def __init__(self, path: Path, reason: str, snippet: str) -> None:
+        super().__init__(f"Could not update {path}: {reason}")
+        self.path = path
+        self.snippet = snippet
+
+
+def _write_private(path: Path, text: str) -> None:
+    """Replace a config file atomically. Agent configs often hold other MCP
+    servers' tokens, so the file is readable by the user only, from the moment
+    it's created. A symlinked config is written through to its target."""
+    path = path.resolve()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp_path = path.with_name(path.name + ".ellf.tmp")
+    tmp_path.unlink(missing_ok=True)
+    flags = os.O_WRONLY | os.O_CREAT | os.O_EXCL | getattr(os, "O_BINARY", 0)
+    with open(os.open(tmp_path, flags, 0o600), "w", encoding="utf-8") as f:
+        f.write(text)
+    tmp_path.replace(path)
+
+
+def _set_json_entry(path: Path, keys: tuple[str, ...], entry: dict) -> None:
+    nested: dict[str, Any] = entry
+    for key in reversed(keys):
+        nested = {key: nested}
+    snippet = json.dumps(nested, indent=2)
+    config: dict[str, Any] = {}
+    if path.exists():
+        try:
+            config = json.loads(path.read_text(encoding="utf-8") or "{}")
+        except json.JSONDecodeError as e:
+            raise MCPConfigError(path, f"not plain JSON ({e})", snippet) from e
+        if not isinstance(config, dict):
+            raise MCPConfigError(path, "not a JSON object", snippet)
+    parent = config
+    for key in keys[:-1]:
+        child = parent.setdefault(key, {})
+        if not isinstance(child, dict):
+            raise MCPConfigError(path, f"'{key}' is not an object", snippet)
+        parent = child
+    parent[keys[-1]] = entry
+    _write_private(path, json.dumps(config, indent=2, ensure_ascii=False) + "\n")
+
+
+_TOML_HEADER_RE = re.compile(r"^\s*\[")
+
+
+def _is_server_table(line: str, name: str) -> bool:
+    quoted = rf"(?:{re.escape(name)}|\"{re.escape(name)}\"|'{re.escape(name)}')"
+    return bool(
+        re.match(
+            rf"^\s*\[\s*mcp_servers\s*\.\s*{quoted}\s*(\.[^\]]*)?\]\s*(#.*)?$", line
+        )
+    )
+
+
+def _trailing_comments(lines: list[str]) -> list[str]:
+    start = len(lines)
+    while start > 0 and lines[start - 1].strip()[:1] in ("", "#"):
+        start -= 1
+    return lines[start:]
+
+
+def set_codex_mcp_server(text: str, name: str, command: list[str]) -> str:
+    """Return config.toml with the ``[mcp_servers.<name>]`` table replaced.
+
+    Edited as text so the user's formatting and comments survive; the result
+    is re-parsed and refused unless it holds exactly the new server.
+    """
+    table = (
+        f"[mcp_servers.{name}]\n"
+        f"command = {json.dumps(command[0])}\n"
+        f"args = {json.dumps(command[1:])}\n"
+    )
+    kept: list[str] = []
+    dropped: list[str] = []
+    skipping = False
+    for line in text.splitlines(keepends=True):
+        if _TOML_HEADER_RE.match(line):
+            ours = _is_server_table(line, name)
+            if skipping and not ours:
+                # Comments right above the next table belong to it.
+                kept.extend(_trailing_comments(dropped))
+            skipping = ours
+            dropped = []
+        (dropped if skipping else kept).append(line)
+    body = "".join(kept).rstrip("\n")
+    result = (body + "\n\n" if body else "") + table
+    try:
+        import tomllib
+    except ImportError:
+        if body.strip():
+            raise ValueError("can't check the edited file without Python 3.11+")
+        return result
+    try:
+        parsed = tomllib.loads(result)
+    except tomllib.TOMLDecodeError as e:
+        raise ValueError(f"not valid TOML after the edit ({e})") from e
+    server = parsed.get("mcp_servers", {}).get(name)
+    if server != {"command": command[0], "args": command[1:]}:
+        raise ValueError(f"mcp_servers.{name} is also defined outside its own table")
+    return result
+
+
+def _configure_codex(command: list[str]) -> Path:
+    path = _codex_home() / "config.toml"
+    text = path.read_text(encoding="utf-8") if path.exists() else ""
+    try:
+        updated = set_codex_mcp_server(text, MCP_SERVER_NAME, command)
+    except ValueError as e:
+        snippet = set_codex_mcp_server("", MCP_SERVER_NAME, command)
+        raise MCPConfigError(path, str(e), snippet) from e
+    _write_private(path, updated)
+    return path
+
+
+def _configure_claude(command: list[str]) -> Path:
+    # Claude Code keeps user-scoped MCP servers at the top level of
+    # ~/.claude.json, which makes the server available in every project.
+    path = _home() / ".claude.json"
+    entry = {"type": "stdio", "command": command[0], "args": command[1:]}
+    _set_json_entry(path, ("mcpServers", MCP_SERVER_NAME), entry)
+    return path
+
+
+def _configure_opencode(command: list[str]) -> Path:
+    config_dir = _opencode_config_dir()
+    candidates = [
+        config_dir / n for n in ("opencode.json", "opencode.jsonc", "config.json")
+    ]
+    path = next((p for p in candidates if p.exists()), candidates[0])
+    entry = {"type": "local", "command": command, "enabled": True}
+    _set_json_entry(path, ("mcp", MCP_SERVER_NAME), entry)
+    return path
+
+
+def _configure_copilot_cli(command: list[str]) -> Path:
+    path = _copilot_home() / "mcp-config.json"
+    entry = {
+        "type": "local",
+        "command": command[0],
+        "args": command[1:],
+        "tools": ["*"],
+    }
+    _set_json_entry(path, ("mcpServers", MCP_SERVER_NAME), entry)
+    return path
+
+
+def _configure_vscode(command: list[str]) -> Optional[Path]:
+    # VS Code keeps its own user mcp.json; only touch it when VS Code is there.
+    vscode_dir = _vscode_user_dir()
+    if not vscode_dir.is_dir():
+        return None
+    path = vscode_dir / "mcp.json"
+    entry = {"type": "stdio", "command": command[0], "args": command[1:]}
+    _set_json_entry(path, ("servers", MCP_SERVER_NAME), entry)
+    return path
+
+
+_MCP_CONFIGURERS: dict[str, list[Callable[[list[str]], Optional[Path]]]] = {
+    "claude": [_configure_claude],
+    "codex": [_configure_codex],
+    "opencode": [_configure_opencode],
+    "copilot": [_configure_copilot_cli, _configure_vscode],
+}
+
+
+def configure_mcp(agent: str, command: list[str]) -> list[Union[Path, MCPConfigError]]:
+    """Point the agent's user MCP configs at the knowledge base ``command``.
+
+    Returns, per config file, the path written or the error that left it as
+    it was, so one file that can't be edited doesn't hide the others.
+    """
+    results: list[Union[Path, MCPConfigError]] = []
+    for configure in _MCP_CONFIGURERS[agent]:
+        try:
+            path = configure(command)
+        except MCPConfigError as e:
+            results.append(e)
+        else:
+            if path is not None:
+                results.append(path)
+    return results
+
+
+# Session transcripts
+
+
+@dataclass
+class AgentSession:
+    agent: str
+    session_id: str
+
+
+# Ordered: Codex sets both, and its rollout files are named after the thread.
+_SESSION_ENV_VARS = (
+    ("CLAUDE_CODE_SESSION_ID", "claude"),
+    ("CODEX_THREAD_ID", "codex"),
+    ("CODEX_SESSION_ID", "codex"),
+    ("COPILOT_AGENT_SESSION_ID", "copilot"),
+)
+
+
+def current_session() -> Optional[AgentSession]:
+    """The agent session this process runs in, from the variables agents set
+    for the commands they run. OpenCode sets none.
+
+    An agent started from another agent's shell inherits the outer agent's
+    variables too, and nothing says which one is running this command. Rather
+    than attach the wrong conversation, that case counts as no session.
+    """
+    sessions = {}
+    for var, agent in _SESSION_ENV_VARS:
+        value = (os.environ.get(var) or "").strip()
+        if value and agent not in sessions:
+            sessions[agent] = AgentSession(agent=agent, session_id=value)
+    return next(iter(sessions.values())) if len(sessions) == 1 else None
+
+
+def find_transcript(session: AgentSession) -> Optional[Path]:
+    if session.agent == "claude":
+        root = _home() / ".claude" / "projects"
+        pattern = f"{session.session_id}.jsonl"
+    elif session.agent == "codex":
+        root = _codex_home() / "sessions"
+        pattern = f"rollout-*-{session.session_id}.jsonl"
+    elif session.agent == "copilot":
+        path = _copilot_home() / "session-state" / session.session_id / "events.jsonl"
+        return path if path.exists() else None
+    else:
+        return None
+    if not root.exists():
+        return None
+    matches = sorted(root.rglob(pattern))
+    return matches[0] if matches else None
+
+
+def debug_log_path(session: AgentSession) -> Optional[Path]:
+    """Only Claude Code keeps a per-session debug log."""
+    if session.agent != "claude":
+        return None
+    return _home() / ".claude" / "debug" / f"{session.session_id}.txt"

{ellf_cli-19.0.18 → ellf_cli-20.0.0}/ellf_cli/cli.py

@@ -114,6 +114,7 @@ cli.placeholder("files", description=Messages.doc_files)
 cli.placeholder("gcp", description=Messages.doc_gcp)
 cli.placeholder("infra", description=Messages.doc_infra)
 cli.placeholder("jobs", description=Messages.doc_jobs)
+cli.placeholder("mcp", description=Messages.doc_mcp)
 cli.placeholder("packages", description=Messages.doc_packages)
 cli.placeholder("plans", description="Manage project plans")
 cli.placeholder("paths", description=Messages.doc_paths)

{ellf_cli-19.0.18 → ellf_cli-20.0.0}/ellf_cli/commands/__init__.py

@@ -11,6 +11,7 @@ from . import (
     import_export,
     infra,
     jobs,
+    mcp,
     packages,
     paths,
     plans,
@@ -45,6 +46,7 @@ __all__ = [
     "files",
     "infra",
     "jobs",
+    "mcp",
     "packages",
     "paths",
     "projects",

{ellf_cli-19.0.18 → ellf_cli-20.0.0}/ellf_cli/commands/general.py

@@ -1,6 +1,6 @@
-import json
 import os
-import shutil
+import shlex
+import sys
 from pathlib import Path
 from typing import Any, Dict, List, Literal, Optional, Union
 from uuid import UUID
@@ -12,91 +12,111 @@ from wasabi import msg
 from ellf_pam_sdk.models import OrgMembership
 
 from .. import about
+from ..agents import (
+    AGENT_NAMES,
+    AGENTS,
+    MCP_SERVER_NAME,
+    MCPConfigError,
+    configure_mcp,
+    ellf_skills_dir,
+    install_skills,
+    mcp_command,
+)
 from ..auth import AuthState
 from ..cli import cli
 from ..config import SavedSettings, global_config_dir
 from ..errors import CLIError, EllfError, NoClustersError
 from ..messages import CLUSTER_DOCS_URL, Messages
-from ..ui import is_silent, print_as_json, print_mutation_result
+from ..ui import is_silent, isatty, print_as_json, print_mutation_result
 from ..util import URL
 from ._cluster_select import select_cluster
 from ._org_select import list_person_orgs, select_org
 from ._state import get_auth_state, get_root_cfg, get_saved_settings
 
 
-def _ellf_claude_plugin_dir() -> Path | None:
-    package_root = Path(__file__).resolve().parents[1]
-    plugin_dir = package_root / "ellf_skills"
-    if (plugin_dir / "skill_variants.json").exists():
-        return plugin_dir
-    return None
-
-
-def _ellf_skill_variants(plugin_dir: Path) -> dict[str, dict[str, str]]:
-    manifest_path = plugin_dir / "skill_variants.json"
-    return json.loads(manifest_path.read_text(encoding="utf-8"))
+def _resolve_agents(agent: Optional[List[str]], claude: bool) -> List[str]:
+    agents = [
+        name.strip().lower()
+        for value in agent or []
+        for name in value.split(",")
+        if name.strip()
+    ]
+    if claude:
+        agents.append("claude")
+    unknown = sorted(set(agents) - set(AGENTS))
+    if unknown:
+        raise CLIError(
+            f"Unknown agent: {', '.join(unknown)}",
+            f"Choose from: {', '.join(AGENTS)}",
+        )
+    return [a for a in AGENTS if a in agents]
+
+
+def _confirm_skill_removal(paths: List[Path]) -> bool:
+    """Ask before removing skills an older ellf login installed. They're
+    named after Ellf skills but may hold the user's own edits."""
+    msg.warn("Found Ellf skills that Ellf no longer installs:")
+    for path in paths:
+        print(f"  - {path}")
+    if isatty(sys.stdin) and isatty(sys.stdout):
+        if input("Remove them? [y/N]: ").strip().lower() in ("y", "yes"):
+            return True
+    print(
+        "Kept them. To remove them later, run: rm -rf "
+        + " ".join(shlex.quote(str(path)) for path in paths)
+    )
+    return False
 
 
-def _configure_claude_mcp(auth: AuthState) -> None:
-    ellf_core_token = auth.get_ellf_core_token()
-    if not ellf_core_token:
+def _install_agent_skills(agents: List[str]) -> None:
+    skills_dir = ellf_skills_dir()
+    if skills_dir is None:
         msg.warn(
-            "Could not get ellf-core token; skipping MCP server configuration. "
-            "Re-run 'ellf login --claude' after a fresh login."
+            "Packaged Ellf skills not found; skipping skill installation. "
+            "Reinstall ellf-cli to get them."
         )
         return
-    mcp_url = str(auth.pam_url / "ellf-core" / "mcp")
-    # CC stores user-scoped MCP servers at the top level of ~/.claude.json.
-    # Writing there makes the KB available in every project, not just this one.
-    claude_json_path = Path.home() / ".claude.json"
-    config: dict = {}
-    if claude_json_path.exists():
-        try:
-            config = json.loads(claude_json_path.read_text(encoding="utf-8"))
-        except json.JSONDecodeError as e:
-            msg.fail(
-                f"Could not parse {claude_json_path}: {e}",
-                "Fix the file manually, then re-run 'ellf login --claude'.",
-            )
-            return
-    config.setdefault("mcpServers", {})
-    config["mcpServers"]["ellf-kb"] = {
-        "type": "http",
-        "url": mcp_url,
-        "headers": {"Authorization": f"Bearer {ellf_core_token}"},
-    }
-    tmp_path = claude_json_path.with_suffix(".json.tmp")
-    tmp_path.write_text(
-        json.dumps(config, indent=2, ensure_ascii=False), encoding="utf-8"
-    )
-    tmp_path.replace(claude_json_path)
-    msg.good(f"Configured ellf-kb MCP server in {claude_json_path}")
+    try:
+        installed = install_skills(agents, skills_dir, _confirm_skill_removal)
+    except (OSError, ValueError) as e:
+        msg.fail(
+            f"Could not install the Ellf skills: {e}",
+            "Fix that, then re-run 'ellf login --agent <agent>'.",
+        )
+        return
+    for dest, names in installed.items():
+        msg.good(f"Installed {len(names)} Ellf skills to {dest}")
+        for name in names:
+            print(f"  - {name}")
 
 
-def _install_claude_skills() -> None:
-    plugin_dir = _ellf_claude_plugin_dir()
-    if plugin_dir is None:
+def _configure_agent_mcp(auth: AuthState, agents: List[str]) -> None:
+    if not auth.get_ellf_core_token():
+        msg.warn(
+            "Could not get an ellf-core token, so the knowledge base MCP server "
+            "won't work until a fresh 'ellf login'."
+        )
+    command = mcp_command()
+    if command is None:
         msg.warn(
-            "Packaged ellf Claude plugin not found. "
-            "Install the ellf-skills plugin assets to use --claude."
+            "Could not find the ellf command; skipping MCP server configuration. "
+            "Run 'ellf login --agent <agent>' from the environment it's installed in."
         )
         return
-    claude_dir = Path.home() / ".claude"
-    dest = claude_dir / "skills"
-    dest.mkdir(parents=True, exist_ok=True)
-    selected_skills = {
-        canonical_name: plugin_dir / "skills" / variants["coding"]
-        for canonical_name, variants in _ellf_skill_variants(plugin_dir).items()
-        if "coding" in variants
-    }
-    for canonical_name, skill_dir in sorted(selected_skills.items()):
-        dst = dest / canonical_name
-        if dst.exists():
-            shutil.rmtree(dst)
-        shutil.copytree(skill_dir, dst)
-    msg.good(f"Installed {len(selected_skills)} Claude Code skills to {dest}")
-    for canonical_name in sorted(selected_skills):
-        print(f"  - {canonical_name}")
+    for agent in agents:
+        try:
+            results = configure_mcp(agent, command)
+        except (OSError, ValueError) as e:
+            msg.fail(f"Could not configure {AGENT_NAMES[agent]}: {e}")
+            continue
+        for result in results:
+            if isinstance(result, MCPConfigError):
+                msg.fail(str(result), f"Add this to it by hand:\n{result.snippet}")
+            else:
+                msg.good(
+                    f"Configured {MCP_SERVER_NAME} MCP server for "
+                    f"{AGENT_NAMES[agent]} in {result}"
+                )
 
 
 def _configure_venv_pypi(auth: AuthState, *, as_json: bool = False) -> None:
@@ -158,6 +178,7 @@ def _configure_venv_pypi(auth: AuthState, *, as_json: bool = False) -> None:
     org=Arg("--org", help=Messages.login_org),
     cluster=Arg("--cluster", help=Messages.login_cluster),
     as_json=Arg("--json", help=Messages.as_json),
+    agent=Arg("--agent", help=Messages.login_agent),
     claude=Arg("--claude", help=Messages.claude),
 )
 def login(
@@ -167,12 +188,14 @@ def login(
     org: Optional[Union[str, UUID]] = None,
     cluster: Optional[Union[str, UUID]] = None,
     as_json: bool = False,
+    agent: Optional[List[str]] = None,
     claude: bool = False,
 ) -> None:
     """
     Log in to your Ellf account. You normally don't need to call this
     manually. It will automatically authenticate when needed.
     """
+    agents = _resolve_agents(agent, claude)
     auth = get_auth_state()
     auth.no_browser = no_browser
     auth._ensure_readable_secrets()
@@ -187,14 +210,14 @@ def login(
         # --no-org keeps whatever org the device flow landed in, so the role
         # check has to look that org's membership up itself.
         _require_cli_role(_active_org_membership(auth))
-    if claude:
-        # Claude setup needs only the packaged skill assets and the
+    if agents:
+        # Agent setup needs only the packaged skill assets and the
         # ellf-core token minted by the device flow above — not the
         # cluster. Run it before cluster selection so cluster failures
         # (token mint errors, unreachable broker, no cluster registered)
         # can't block skill installation.
-        _install_claude_skills()
-        _configure_claude_mcp(auth)
+        _install_agent_skills(agents)
+        _configure_agent_mcp(auth, agents)
     # Best-effort: needs only the api token minted above, and must not
     # block login (or cluster selection below) when it fails.
     _configure_venv_pypi(auth, as_json=as_json)