hypercli-cli 2026.4.24__tar.gz → 2026.5.21__tar.gz

{hypercli_cli-2026.4.24 → hypercli_cli-2026.5.21}/.gitignore

@@ -26,6 +26,7 @@ coverage
 
 # Misc
 .DS_Store
+.agents/
 *.pem
 
 # IDE

{hypercli_cli-2026.4.24 → hypercli_cli-2026.5.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypercli-cli
-Version: 2026.4.24
+Version: 2026.5.21
 Summary: CLI for HyperCLI - GPU orchestration and LLM API
 Project-URL: Homepage, https://hypercli.com
 Project-URL: Documentation, https://docs.hypercli.com
@@ -9,22 +9,21 @@ Author-email: HyperCLI <support@hypercli.com>
 License: MIT
 Requires-Python: >=3.10
 Requires-Dist: httpx>=0.27.0
-Requires-Dist: hypercli-sdk>=2026.4.24
+Requires-Dist: hypercli-sdk>=2026.5.21
 Requires-Dist: mutagen>=1.47.0
 Requires-Dist: openai>=2.8.1
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: rich>=14.2.0
 Requires-Dist: typer>=0.20.0
-Requires-Dist: websocket-client>=1.6.0
 Provides-Extra: all
 Requires-Dist: argon2-cffi>=25.0.0; extra == 'all'
 Requires-Dist: eth-account>=0.13.0; extra == 'all'
 Requires-Dist: faster-whisper>=1.1.0; extra == 'all'
-Requires-Dist: hypercli-sdk[comfyui]>=2026.4.24; extra == 'all'
+Requires-Dist: hypercli-sdk[comfyui]>=2026.5.21; extra == 'all'
 Requires-Dist: web3>=7.0.0; extra == 'all'
 Requires-Dist: x402[evm,httpx]>=2.0.0; extra == 'all'
 Provides-Extra: comfyui
-Requires-Dist: hypercli-sdk[comfyui]>=2026.4.24; extra == 'comfyui'
+Requires-Dist: hypercli-sdk[comfyui]>=2026.5.21; extra == 'comfyui'
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0.0; extra == 'dev'
 Requires-Dist: ruff>=0.3.0; extra == 'dev'
@@ -81,6 +80,7 @@ hyper flow text-to-image "a cinematic portrait" --x402
 # HyperClaw checkout/config
 hyper agent plans
 hyper agent subscribe basic
+hyper agent activate-code PROMO123
 hyper agent config env
 hyper agent exec <agent_id> "ls -la"
 hyper agent shell <agent_id>

{hypercli_cli-2026.4.24 → hypercli_cli-2026.5.21}/README.md

@@ -41,6 +41,7 @@ hyper flow text-to-image "a cinematic portrait" --x402
 # HyperClaw checkout/config
 hyper agent plans
 hyper agent subscribe basic
+hyper agent activate-code PROMO123
 hyper agent config env
 hyper agent exec <agent_id> "ls -la"
 hyper agent shell <agent_id>

hypercli_cli-2026.5.21/hypercli_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "2026.5.21"

{hypercli_cli-2026.4.24 → hypercli_cli-2026.5.21}/hypercli_cli/agent.py

@@ -12,7 +12,7 @@ from rich.console import Console
 from rich.table import Table
 
 from hypercli import HyperCLI
-from hypercli.config import get_agents_api_base_url_from_product_base
+from hypercli.config import get_agent_api_key, get_agents_api_base_url_from_product_base
 
 from .onboard import onboard as _onboard_fn
 from .voice import app as voice_app
@@ -54,7 +54,7 @@ def require_x402_deps():
 
 
 def _resolve_agent_query_key() -> str:
-    key = os.getenv("HYPER_AGENTS_API_KEY", "").strip() or os.getenv("HYPER_API_KEY", "").strip()
+    key = (get_agent_api_key() or "").strip()
     if key:
         return key
     if AGENT_KEY_PATH.exists():
@@ -498,6 +498,34 @@ def subscription_summary(
         )
 
 
+@app.command("activate-code")
+def activate_code(
+    code: str = typer.Argument(..., help="Activation or promo code to redeem"),
+    dev: bool = typer.Option(False, "--dev", help="Use dev API"),
+    json_output: bool = typer.Option(False, "--json", help="Print raw JSON response"),
+):
+    """Redeem a HyperClaw activation code for the current account."""
+    client = _get_agent_query_client(dev)
+    result = client.agent.redeem_grant_code(code)
+
+    if json_output:
+        console.print_json(json.dumps(result, indent=2, default=str))
+        return
+
+    grant = result.get("grant") or {}
+    entitlement = result.get("entitlement") or {}
+    console.print("\n[bold]HyperClaw Code Activated[/bold]\n")
+    console.print(f"Code: [bold]{grant.get('code') or code}[/bold]")
+    console.print(f"Plan: [bold]{entitlement.get('plan_name') or entitlement.get('plan_id') or grant.get('plan_id') or ''}[/bold]")
+    if entitlement.get("starts_at"):
+        console.print(f"Starts: {entitlement.get('starts_at')}")
+    if entitlement.get("expires_at"):
+        console.print(f"Expires: {entitlement.get('expires_at')}")
+    tags = entitlement.get("tags") or grant.get("tags") or []
+    if tags:
+        console.print(f"Tags: {', '.join(str(tag) for tag in tags)}")
+
+
 @app.command("models")
 def models(
     dev: bool = typer.Option(False, "--dev", help="Use dev API"),
@@ -721,7 +749,21 @@ def fetch_models(api_key: str, api_base: str = PROD_INFERENCE_API_BASE) -> list[
         normalized = (model_id or "").strip().lower()
         aliases = {
             "kimi-k2.5": {"name": "Kimi K2.5", "reasoning": True, "contextWindow": 262144},
+            "kimi-k2.5-anthropic": {"name": "Kimi K2.5 Anthropic", "reasoning": True, "contextWindow": 262144},
+            "kimi-k2.6": {"name": "Kimi K2.6", "reasoning": True, "contextWindow": 262144},
+            "kimi-k2.6-anthropic": {"name": "Kimi K2.6 Anthropic", "reasoning": True, "contextWindow": 262144},
             "moonshotai/kimi-k2.5": {"name": "Kimi K2.5", "reasoning": True, "contextWindow": 262144},
+            "moonshotai/kimi-k2.5-anthropic": {
+                "name": "Kimi K2.5 Anthropic",
+                "reasoning": True,
+                "contextWindow": 262144,
+            },
+            "moonshotai/kimi-k2.6": {"name": "Kimi K2.6", "reasoning": True, "contextWindow": 262144},
+            "moonshotai/kimi-k2.6-anthropic": {
+                "name": "Kimi K2.6 Anthropic",
+                "reasoning": True,
+                "contextWindow": 262144,
+            },
             "glm-5": {"name": "GLM-5", "reasoning": True, "contextWindow": 202752},
             "zai-org/glm-5": {"name": "GLM-5", "reasoning": True, "contextWindow": 202752},
             "qwen3-embedding-4b": {
@@ -786,9 +828,21 @@ def fetch_models(api_key: str, api_base: str = PROD_INFERENCE_API_BASE) -> list[
         ]
 
 
+def _preferred_agent_models(models: list[dict]) -> list[dict]:
+    """Return the recommended agent models in priority order."""
+    preferred = ["kimi-k2.6-anthropic", "kimi-k2.5-anthropic"]
+    picked = [model for model_id in preferred for model in models if model["id"] == model_id]
+    if picked:
+        return picked
+    anthropic = [model for model in models if model["id"].endswith("-anthropic")]
+    if anthropic:
+        return anthropic
+    return models[:1]
+
+
 @app.command("openclaw-setup")
 def openclaw_setup(
-    default: bool = typer.Option(False, "--default", help="Set hyperclaw/kimi-k2.5 as the default model"),
+    default: bool = typer.Option(False, "--default", help="Set hyperclaw/kimi-k2.6-anthropic as the default model"),
 ):
     """Patch OpenClaw config with your HyperClaw API key.
 
@@ -884,8 +938,8 @@ def _config_openclaw(
 
     api_base = api_base.rstrip("/")
     supported_models = [m for m in models if _is_supported_openclaw_model(m)]
-    chat_models = [m for m in supported_models if m.get("mode") != "embedding"]
     embedding_models = [m for m in supported_models if m.get("mode") == "embedding"]
+    chat_models = _preferred_agent_models([m for m in supported_models if m.get("mode") != "embedding"])
     kimi_models = [m for m in chat_models if "kimi" in _model_suffix(m.get("id", ""))]
     glm_models = [m for m in chat_models if _model_suffix(m.get("id", "")) == "glm-5"]
     other_chat_models = [
@@ -946,6 +1000,7 @@ def _config_openclaw(
 def _config_opencode(api_key: str, models: list[dict], api_base: str = PROD_INFERENCE_API_BASE) -> dict:
     """OpenCode opencode.json provider snippet."""
     api_base = api_base.rstrip("/")
+    models = _preferred_agent_models(models)
     model_entries = {}
     for m in models:
         model_entries[m["id"]] = {"name": m["id"]}
@@ -953,7 +1008,7 @@ def _config_opencode(api_key: str, models: list[dict], api_base: str = PROD_INFE
         "$schema": "https://opencode.ai/config.json",
         "provider": {
             "hypercli": {
-                "npm": "@ai-sdk/openai-compatible",
+                "npm": "@ai-sdk/anthropic",
                 "name": "HyperCLI",
                 "options": {
                     "baseURL": f"{api_base}/v1",
@@ -961,13 +1016,15 @@ def _config_opencode(api_key: str, models: list[dict], api_base: str = PROD_INFE
                 },
                 "models": model_entries,
             }
-        }
+        },
+        "model": f"hypercli/{models[0]['id']}",
     }
 
 
 def _config_env(api_key: str, models: list[dict], api_base: str = PROD_INFERENCE_API_BASE) -> str:
     """Shell env vars for generic OpenAI-compatible tools."""
     api_base = api_base.rstrip("/")
+    models = _preferred_agent_models(models)
     lines = [
         f'export OPENAI_API_KEY="{api_key}"',
         f'export OPENAI_BASE_URL="{api_base}/v1"',

{hypercli_cli-2026.4.24 → hypercli_cli-2026.5.21}/hypercli_cli/agents.py

@@ -13,6 +13,7 @@ from rich.console import Console
 from rich.table import Table
 
 from hypercli.agents import Agent, Deployments, OpenClawAgent, DEFAULT_OPENCLAW_IMAGE
+from hypercli.config import get_agent_api_key as get_config_agent_api_key
 
 app = typer.Typer(help="Manage OpenClaw agent pods")
 console = Console()
@@ -46,11 +47,8 @@ def agents_root(
 
 
 def _get_agent_api_key() -> str:
-    """Resolve HyperClaw API key from env or saved key file."""
-    key = os.environ.get("HYPER_AGENTS_API_KEY", "").strip()
-    if key:
-        return key
-    key = os.environ.get("HYPER_API_KEY", "").strip()
+    """Resolve HyperClaw API key from canonical config before legacy key file."""
+    key = (get_config_agent_api_key() or "").strip()
     if key:
         return key
     if AGENT_KEY_PATH.exists():

{hypercli_cli-2026.4.24 → hypercli_cli-2026.5.21}/hypercli_cli/cli.py

@@ -1,6 +1,7 @@
 """HyperCLI - Main entry point"""
 import sys
 import json
+from datetime import datetime, timezone
 import typer
 from rich.console import Console
 from rich.prompt import Prompt
@@ -15,6 +16,24 @@ from .output import output, spinner
 console = Console()
 
 
+def _format_time_left(expires_at: datetime | None) -> str:
+    if not expires_at:
+        return ""
+    if expires_at.tzinfo is None:
+        expires_at = expires_at.replace(tzinfo=timezone.utc)
+    remaining = expires_at - datetime.now(timezone.utc)
+    if remaining.total_seconds() <= 0:
+        return "expired"
+    days = remaining.days
+    hours = remaining.seconds // 3600
+    minutes = (remaining.seconds % 3600) // 60
+    if days:
+        return f"{days}d {hours}h"
+    if hours:
+        return f"{hours}h {minutes}m"
+    return f"{minutes}m"
+
+
 def fuzzy_match(input_str: str, options: list[str], threshold: float = 0.5) -> list[str]:
     """Find similar strings using multiple heuristics"""
     def similarity(a: str, b: str) -> float:
@@ -107,8 +126,32 @@ def me_cmd(
     client = HyperCLI()
     with spinner("Resolving auth context..."):
         auth_me = client.user.auth_me()
+        entitlement_summary = None
+        entitlement_error = None
+        try:
+            entitlement_summary = client.agent.subscription_summary()
+        except APIError as exc:
+            entitlement_error = f"{exc.status_code}: {exc.detail}"
+        except Exception as exc:
+            entitlement_error = str(exc)
     if fmt == "json":
-        output(auth_me, fmt)
+        payload = dict(getattr(auth_me, "__dict__", {}))
+        if entitlement_summary is not None:
+            payload["agents_entitlements"] = {
+                "effective_plan_id": entitlement_summary.effective_plan_id,
+                "current_subscription_id": entitlement_summary.current_subscription_id,
+                "current_entitlement_id": entitlement_summary.current_entitlement_id,
+                "active_subscription_count": entitlement_summary.active_subscription_count,
+                "active_entitlement_count": entitlement_summary.active_entitlement_count,
+                "pooled_tpm_limit": entitlement_summary.pooled_tpm_limit,
+                "pooled_rpm_limit": entitlement_summary.pooled_rpm_limit,
+                "pooled_tpd": entitlement_summary.pooled_tpd,
+                "billing_reset_at": entitlement_summary.billing_reset_at,
+                "entitlement_items": [item.__dict__ for item in entitlement_summary.entitlement_items],
+            }
+        elif entitlement_error:
+            payload["agents_entitlements_error"] = entitlement_error
+        output(payload, fmt)
         return
 
     table = Table(show_header=False, box=None)
@@ -127,6 +170,25 @@ def me_cmd(
     raw_capabilities = list(getattr(auth_me, "capabilities", []) or [])
     capabilities = "\n".join(raw_capabilities) if raw_capabilities else ""
     table.add_row("capabilities", capabilities)
+    if entitlement_summary is not None:
+        table.add_row("agents_effective_plan", entitlement_summary.effective_plan_id)
+        table.add_row("agents_current_entitlement", str(entitlement_summary.current_entitlement_id or ""))
+        table.add_row("agents_active_entitlements", str(entitlement_summary.active_entitlement_count))
+        active_items = [item for item in entitlement_summary.entitlement_items if str(item.status).upper() == "ACTIVE"]
+        expires_at = max((item.expires_at for item in active_items if item.expires_at), default=None)
+        if expires_at:
+            table.add_row("agents_expires_at", expires_at.isoformat())
+            table.add_row("agents_time_left", _format_time_left(expires_at))
+        table.add_row(
+            "agents_limits",
+            (
+                f"{entitlement_summary.pooled_tpm_limit:,} TPM / "
+                f"{entitlement_summary.pooled_rpm_limit:,} RPM / "
+                f"{entitlement_summary.pooled_tpd:,} TPD"
+            ),
+        )
+    elif entitlement_error:
+        table.add_row("agents_entitlements", f"unavailable ({entitlement_error})")
     console.print(table)
 
 

{hypercli_cli-2026.4.24 → hypercli_cli-2026.5.21}/hypercli_cli/voice.py

@@ -1,11 +1,13 @@
 """HyperClaw Voice API commands — TTS, clone, design"""
 import json
 import os
+from datetime import datetime, timezone
 from pathlib import Path
 
 import typer
 from rich.console import Console
 from hypercli import HyperCLI, APIError
+from hypercli.config import get_agent_api_key, get_api_key
 from .stt import transcribe as _stt_transcribe
 
 app = typer.Typer(help="Voice commands — text-to-speech, voice cloning, voice design, and local transcription")
@@ -17,22 +19,30 @@ DEFAULT_API_BASE = "https://api.hypercli.com"
 
 
 def _get_api_key(key: str | None) -> str:
-    """Resolve API key: --key > HYPER_API_KEY > HYPER_AGENTS_API_KEY > agent-key.json."""
+    """Resolve API key from canonical config before legacy agent-key storage."""
     if key:
         return key
-    env_key = os.environ.get("HYPER_API_KEY", "").strip()
-    if env_key:
-        return env_key
-    env_key = os.environ.get("HYPER_AGENTS_API_KEY", "").strip()
-    if env_key:
-        return env_key
+    configured = (get_api_key() or get_agent_api_key() or "").strip()
+    if configured:
+        return configured
     if AGENT_KEY_PATH.exists():
-        with open(AGENT_KEY_PATH) as f:
-            k = json.load(f).get("key", "")
-        if k:
-            return k
+        try:
+            with open(AGENT_KEY_PATH) as f:
+                saved = json.load(f)
+            expires_at = saved.get("expires_at")
+            if expires_at:
+                expires = datetime.fromisoformat(str(expires_at).replace("Z", "+00:00"))
+                if expires.tzinfo is None:
+                    expires = expires.replace(tzinfo=timezone.utc)
+                if expires <= datetime.now(timezone.utc):
+                    saved = {}
+            k = str(saved.get("key", "")).strip()
+            if k:
+                return k
+        except Exception:
+            pass
     console.print("[red]❌ No API key found.[/red]")
-    console.print("Pass [bold]--key sk-...[/bold], set [bold]HYPER_API_KEY[/bold] or [bold]HYPER_AGENTS_API_KEY[/bold], or run [bold]hyper agent subscribe[/bold]")
+    console.print("Pass [bold]--key[/bold], set [bold]HYPER_API_KEY[/bold], or run [bold]hyper configure[/bold].")
     raise typer.Exit(1)
 
 

{hypercli_cli-2026.4.24 → hypercli_cli-2026.5.21}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "hypercli-cli"
-version = "2026.4.24"
+version = "2026.5.21"
 description = "CLI for HyperCLI - GPU orchestration and LLM API"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -13,11 +13,10 @@ authors = [
     { name = "HyperCLI", email = "support@hypercli.com" }
 ]
 dependencies = [
-    "hypercli-sdk>=2026.4.24",
+    "hypercli-sdk>=2026.5.21",
     "openai>=2.8.1",
     "typer>=0.20.0",
     "rich>=14.2.0",
-    "websocket-client>=1.6.0",
     "mutagen>=1.47.0",
     "httpx>=0.27.0",
     "pyyaml>=6.0",
@@ -25,7 +24,7 @@ dependencies = [
 
 [project.optional-dependencies]
 comfyui = [
-    "hypercli-sdk[comfyui]>=2026.4.24",
+    "hypercli-sdk[comfyui]>=2026.5.21",
 ]
 wallet = [
     "x402[httpx,evm]>=2.0.0",
@@ -38,7 +37,7 @@ stt = [
     "faster-whisper>=1.1.0",
 ]
 all = [
-    "hypercli-sdk[comfyui]>=2026.4.24",
+    "hypercli-sdk[comfyui]>=2026.5.21",
     "x402[httpx,evm]>=2.0.0",
     "eth-account>=0.13.0",
     "web3>=7.0.0",

hypercli_cli-2026.5.21/tests/test_agent_env_resolution.py

@@ -0,0 +1,139 @@
+import importlib
+import json
+from pathlib import Path
+
+
+def test_agents_cli_prefers_agent_key_env(monkeypatch):
+    monkeypatch.setenv("HYPER_API_KEY", "sk-product")
+    monkeypatch.setenv("HYPER_AGENTS_API_KEY", "sk-agent")
+
+    import hypercli_cli.agents as agents
+
+    importlib.reload(agents)
+
+    assert agents._get_agent_api_key() == "sk-agent"
+
+
+def test_agents_cli_uses_config_without_legacy_agent_key(monkeypatch, tmp_path):
+    monkeypatch.delenv("HYPER_API_KEY", raising=False)
+    monkeypatch.delenv("HYPERCLI_API_KEY", raising=False)
+    monkeypatch.delenv("HYPER_AGENTS_API_KEY", raising=False)
+
+    config_path = tmp_path / "config"
+    config_path.write_text("HYPER_API_KEY=hyper_api_config\n")
+
+    import hypercli.config as config
+    import hypercli_cli.agents as agents
+
+    importlib.reload(config)
+    importlib.reload(agents)
+    monkeypatch.setattr(config, "CONFIG_FILE", config_path)
+    monkeypatch.setattr(agents, "AGENT_KEY_PATH", tmp_path / "missing-agent-key.json")
+
+    assert agents._get_agent_api_key() == "hyper_api_config"
+
+
+def test_agent_activate_uses_config_without_legacy_agent_key(monkeypatch, tmp_path):
+    monkeypatch.delenv("HYPER_API_KEY", raising=False)
+    monkeypatch.delenv("HYPERCLI_API_KEY", raising=False)
+    monkeypatch.delenv("HYPER_AGENTS_API_KEY", raising=False)
+
+    config_path = tmp_path / "config"
+    config_path.write_text("HYPER_API_KEY=hyper_api_config\n")
+
+    import hypercli.config as config
+    import hypercli_cli.agent as agent
+
+    importlib.reload(config)
+    importlib.reload(agent)
+    monkeypatch.setattr(config, "CONFIG_FILE", config_path)
+    monkeypatch.setattr(agent, "AGENT_KEY_PATH", tmp_path / "missing-agent-key.json")
+
+    assert agent._resolve_agent_query_key() == "hyper_api_config"
+
+
+def test_agents_cli_prefers_agent_base_env(monkeypatch):
+    monkeypatch.setenv("AGENTS_API_BASE_URL", "https://api.agents.dev.hypercli.com")
+    monkeypatch.setenv("AGENTS_WS_URL", "wss://api.agents.dev.hypercli.com/ws")
+    monkeypatch.setenv("HYPER_AGENTS_API_KEY", "sk-agent")
+
+    import hypercli_cli.agents as agents
+
+    importlib.reload(agents)
+
+    client = agents._get_deployments_client()
+    assert client._api_base == "https://api.dev.hypercli.com/agents"
+
+
+def test_voice_cli_prefers_product_envs(monkeypatch):
+    monkeypatch.setenv("HYPER_API_KEY", "sk-product")
+    monkeypatch.setenv("HYPER_AGENTS_API_KEY", "sk-agent")
+    monkeypatch.setenv("HYPER_API_BASE", "https://api.hypercli.com")
+    monkeypatch.setenv("HYPERCLI_API_URL", "https://api.dev.hypercli.com")
+
+    import hypercli_cli.voice as voice
+
+    importlib.reload(voice)
+
+    assert voice._get_api_key(None) == "sk-product"
+    assert voice._resolve_api_base(None) == "https://api.hypercli.com"
+
+
+def test_voice_cli_uses_config_before_expired_agent_key(monkeypatch, tmp_path):
+    monkeypatch.delenv("HYPER_API_KEY", raising=False)
+    monkeypatch.delenv("HYPERCLI_API_KEY", raising=False)
+    monkeypatch.delenv("HYPER_AGENTS_API_KEY", raising=False)
+
+    config_path = tmp_path / "config"
+    config_path.write_text("HYPER_API_KEY=hyper_api_config\n")
+    agent_key_path = tmp_path / "agent-key.json"
+    agent_key_path.write_text(
+        json.dumps(
+            {
+                "key": "hyper_api_expired",
+                "expires_at": "2026-01-01T00:00:00+00:00",
+            }
+        )
+    )
+
+    import hypercli.config as config
+    import hypercli_cli.voice as voice
+
+    importlib.reload(config)
+    importlib.reload(voice)
+    monkeypatch.setattr(config, "CONFIG_FILE", config_path)
+    monkeypatch.setattr(voice, "AGENT_KEY_PATH", agent_key_path)
+
+    assert voice._get_api_key(None) == "hyper_api_config"
+
+
+def test_voice_cli_posts_to_agents_voice_prefix(monkeypatch, tmp_path):
+    monkeypatch.setenv("HYPER_API_KEY", "sk-product")
+    monkeypatch.setenv("HYPER_API_BASE", "https://api.dev.hypercli.com")
+
+    import hypercli_cli.voice as voice
+
+    importlib.reload(voice)
+
+    called = {}
+
+    class _FakeVoice:
+        def tts(self, **kwargs):
+            called["kwargs"] = kwargs
+            return b"audio"
+
+    class _FakeHyperCLI:
+        def __init__(self, *, api_key, api_url):
+            called["api_key"] = api_key
+            called["api_url"] = api_url
+            self.voice = _FakeVoice()
+
+    monkeypatch.setattr(voice, "HyperCLI", _FakeHyperCLI)
+
+    out = tmp_path / "voice.wav"
+    voice._post_voice("tts", "sk-product", out, text="hello", voice="Chelsie")
+
+    assert called["api_url"] == "https://api.dev.hypercli.com"
+    assert called["api_key"] == "sk-product"
+    assert called["kwargs"] == {"text": "hello", "voice": "Chelsie"}
+    assert out.read_bytes() == b"audio"

{hypercli_cli-2026.4.24 → hypercli_cli-2026.5.21}/tests/test_agent_subscribe_command.py

@@ -108,3 +108,32 @@ def test_extract_plan_purchase_url_from_discovery_ignores_nonmatching_resources(
     }
 
     assert agent_mod._extract_plan_purchase_url_from_discovery(discovery, "basic") is None
+
+
+def test_agent_activate_code_redeems_via_sdk(monkeypatch):
+    class _FakeAgent:
+        def redeem_grant_code(self, code: str):
+            assert code == "promo-123"
+            return {
+                "grant": {"id": "grant-1", "type": "ACTIVATION_CODE", "code": "promo-123", "plan_id": "basic"},
+                "entitlement": {
+                    "id": "ent-1",
+                    "plan_id": "basic",
+                    "plan_name": "Basic",
+                    "starts_at": "2026-04-27T00:00:00Z",
+                    "expires_at": "2026-05-27T00:00:00Z",
+                    "tags": ["customer=acme"],
+                },
+            }
+
+    class _FakeClient:
+        agent = _FakeAgent()
+
+    monkeypatch.setattr(agent_mod, "_get_agent_query_client", lambda dev: _FakeClient())
+
+    result = runner.invoke(app, ["agent", "activate-code", "promo-123"])
+
+    assert result.exit_code == 0
+    assert "HyperClaw Code Activated" in result.output
+    assert "promo-123" in result.output
+    assert "Basic" in result.output

hypercli_cli-2026.5.21/tests/test_me_command.py

@@ -0,0 +1,91 @@
+from datetime import datetime, timezone
+from types import SimpleNamespace
+
+from typer.testing import CliRunner
+
+from hypercli_cli.cli import app
+
+
+runner = CliRunner()
+
+
+def test_me_command_outputs_capabilities(monkeypatch):
+    class FakeUserAPI:
+        def auth_me(self):
+            return SimpleNamespace(
+                user_id="user-123",
+                orchestra_user_id="orch-123",
+                team_id="team-123",
+                plan_id="pro",
+                email="user@example.com",
+                auth_type="orchestra_key",
+                capabilities=["models:*", "voice:*"],
+                key_id="key-123",
+                key_name="runtime-key",
+            )
+
+    class FakeClient:
+        user = FakeUserAPI()
+
+    monkeypatch.setattr("hypercli_cli.cli.HyperCLI", lambda: FakeClient())
+
+    result = runner.invoke(app, ["me"])
+
+    assert result.exit_code == 0
+    assert "models:*" in result.stdout
+    assert "voice:*" in result.stdout
+    assert "runtime-key" in result.stdout
+
+
+def test_me_command_outputs_agents_entitlement_summary(monkeypatch):
+    class FakeUserAPI:
+        def auth_me(self):
+            return SimpleNamespace(
+                user_id="user-123",
+                orchestra_user_id=None,
+                team_id="",
+                plan_id="",
+                email=None,
+                auth_type="api_key",
+                capabilities=["*:*"],
+                has_active_subscription=False,
+                key_id="key-123",
+                key_name="gpu-operator-prod",
+            )
+
+    class FakeAgentAPI:
+        def subscription_summary(self):
+            return SimpleNamespace(
+                effective_plan_id="pro",
+                current_subscription_id=None,
+                current_entitlement_id="ent-123",
+                active_subscription_count=0,
+                active_entitlement_count=1,
+                pooled_tpm_limit=17_361_100,
+                pooled_rpm_limit=1_736,
+                pooled_tpd=500_000_000,
+                billing_reset_at=None,
+                entitlement_items=[
+                    SimpleNamespace(
+                        plan_id="pro",
+                        status="ACTIVE",
+                        expires_at=datetime(2036, 5, 16, 11, 36, 49, tzinfo=timezone.utc),
+                    )
+                ],
+            )
+
+    class FakeClient:
+        user = FakeUserAPI()
+        agent = FakeAgentAPI()
+
+    monkeypatch.setattr("hypercli_cli.cli.HyperCLI", lambda: FakeClient())
+
+    result = runner.invoke(app, ["me"])
+
+    assert result.exit_code == 0
+    assert "has_active_subscription" in result.stdout
+    assert "no" in result.stdout
+    assert "agents_effective_plan" in result.stdout
+    assert "pro" in result.stdout
+    assert "agents_time_left" in result.stdout
+    assert "17,361,100 TPM / 1,736 RPM / 500,000,000 TPD" in result.stdout

hypercli_cli-2026.4.24/hypercli_cli/__init__.py

@@ -1 +0,0 @@
-__version__ = "2026.4.24"

hypercli_cli-2026.4.24/tests/test_agent_env_resolution.py

@@ -1,72 +0,0 @@
-import importlib
-from pathlib import Path
-
-
-def test_agents_cli_prefers_agent_key_env(monkeypatch):
-    monkeypatch.setenv("HYPER_API_KEY", "sk-product")
-    monkeypatch.setenv("HYPER_AGENTS_API_KEY", "sk-agent")
-
-    import hypercli_cli.agents as agents
-
-    importlib.reload(agents)
-
-    assert agents._get_agent_api_key() == "sk-agent"
-
-
-def test_agents_cli_prefers_agent_base_env(monkeypatch):
-    monkeypatch.setenv("AGENTS_API_BASE_URL", "https://api.agents.dev.hypercli.com")
-    monkeypatch.setenv("AGENTS_WS_URL", "wss://api.agents.dev.hypercli.com/ws")
-    monkeypatch.setenv("HYPER_AGENTS_API_KEY", "sk-agent")
-
-    import hypercli_cli.agents as agents
-
-    importlib.reload(agents)
-
-    client = agents._get_deployments_client()
-    assert client._api_base == "https://api.dev.hypercli.com/agents"
-
-
-def test_voice_cli_prefers_product_envs(monkeypatch):
-    monkeypatch.setenv("HYPER_API_KEY", "sk-product")
-    monkeypatch.setenv("HYPER_AGENTS_API_KEY", "sk-agent")
-    monkeypatch.setenv("HYPER_API_BASE", "https://api.hypercli.com")
-    monkeypatch.setenv("HYPERCLI_API_URL", "https://api.dev.hypercli.com")
-
-    import hypercli_cli.voice as voice
-
-    importlib.reload(voice)
-
-    assert voice._get_api_key(None) == "sk-product"
-    assert voice._resolve_api_base(None) == "https://api.hypercli.com"
-
-
-def test_voice_cli_posts_to_agents_voice_prefix(monkeypatch, tmp_path):
-    monkeypatch.setenv("HYPER_API_KEY", "sk-product")
-    monkeypatch.setenv("HYPER_API_BASE", "https://api.dev.hypercli.com")
-
-    import hypercli_cli.voice as voice
-
-    importlib.reload(voice)
-
-    called = {}
-
-    class _FakeVoice:
-        def tts(self, **kwargs):
-            called["kwargs"] = kwargs
-            return b"audio"
-
-    class _FakeHyperCLI:
-        def __init__(self, *, api_key, api_url):
-            called["api_key"] = api_key
-            called["api_url"] = api_url
-            self.voice = _FakeVoice()
-
-    monkeypatch.setattr(voice, "HyperCLI", _FakeHyperCLI)
-
-    out = tmp_path / "voice.wav"
-    voice._post_voice("tts", "sk-product", out, text="hello", voice="Chelsie")
-
-    assert called["api_url"] == "https://api.dev.hypercli.com"
-    assert called["api_key"] == "sk-product"
-    assert called["kwargs"] == {"text": "hello", "voice": "Chelsie"}
-    assert out.read_bytes() == b"audio"

hypercli_cli-2026.4.24/tests/test_me_command.py

@@ -1,36 +0,0 @@
-from types import SimpleNamespace
-
-from typer.testing import CliRunner
-
-from hypercli_cli.cli import app
-
-
-runner = CliRunner()
-
-
-def test_me_command_outputs_capabilities(monkeypatch):
-    class FakeUserAPI:
-        def auth_me(self):
-            return SimpleNamespace(
-                user_id="user-123",
-                orchestra_user_id="orch-123",
-                team_id="team-123",
-                plan_id="pro",
-                email="user@example.com",
-                auth_type="orchestra_key",
-                capabilities=["models:*", "voice:*"],
-                key_id="key-123",
-                key_name="runtime-key",
-            )
-
-    class FakeClient:
-        user = FakeUserAPI()
-
-    monkeypatch.setattr("hypercli_cli.cli.HyperCLI", lambda: FakeClient())
-
-    result = runner.invoke(app, ["me"])
-
-    assert result.exit_code == 0
-    assert "models:*" in result.stdout
-    assert "voice:*" in result.stdout
-    assert "runtime-key" in result.stdout