hypercli-cli 2026.4.13__tar.gz → 2026.4.17__tar.gz

{hypercli_cli-2026.4.13 → hypercli_cli-2026.4.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypercli-cli
-Version: 2026.4.13
+Version: 2026.4.17
 Summary: CLI for HyperCLI - GPU orchestration and LLM API
 Project-URL: Homepage, https://hypercli.com
 Project-URL: Documentation, https://docs.hypercli.com
@@ -9,7 +9,7 @@ Author-email: HyperCLI <support@hypercli.com>
 License: MIT
 Requires-Python: >=3.10
 Requires-Dist: httpx>=0.27.0
-Requires-Dist: hypercli-sdk>=2026.4.13
+Requires-Dist: hypercli-sdk>=2026.4.17
 Requires-Dist: mutagen>=1.47.0
 Requires-Dist: openai>=2.8.1
 Requires-Dist: pyyaml>=6.0
@@ -20,11 +20,11 @@ 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.13; extra == 'all'
+Requires-Dist: hypercli-sdk[comfyui]>=2026.4.17; 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.13; extra == 'comfyui'
+Requires-Dist: hypercli-sdk[comfyui]>=2026.4.17; extra == 'comfyui'
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0.0; extra == 'dev'
 Requires-Dist: ruff>=0.3.0; extra == 'dev'

hypercli_cli-2026.4.17/hypercli_cli/__init__.py

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

{hypercli_cli-2026.4.13 → hypercli_cli-2026.4.17}/hypercli_cli/agent.py

@@ -6,11 +6,13 @@ import shutil
 import subprocess
 from pathlib import Path
 from datetime import datetime, timedelta
+from urllib.parse import urlsplit
 import typer
 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 .onboard import onboard as _onboard_fn
 from .voice import app as voice_app
@@ -79,7 +81,11 @@ def _get_agent_query_client(dev: bool) -> HyperCLI:
 def subscribe(
     plan_id: str = typer.Argument("1aiu", help="Plan ID: 1aiu, 2aiu, 5aiu, 10aiu (default: 1aiu)"),
     amount: str = typer.Argument(None, help="USDC amount to pay (e.g., '25' for $25). Duration scales proportionally."),
-    dev: bool = typer.Option(False, "--dev", help="Use dev API (api.dev.hypercli.com)")
+    passphrase: str = typer.Option(
+        None,
+        "--passphrase",
+        help="Current keystore passphrase. Skips interactive prompt.",
+    ),
 ):
     """Subscribe to a HyperClaw plan via x402 payment.
     
@@ -97,8 +103,9 @@ def subscribe(
     
     # Import wallet helper
     from .wallet import load_wallet
+    from hypercli.config import get_api_url
     
-    api_base = DEV_API_BASE if dev else PROD_API_BASE
+    api_base = get_api_url().rstrip("/")
     
     console.print(f"\n[bold]Subscribing to HyperClaw plan: {plan_id}[/bold]\n")
     console.print(f"API: {api_base}")
@@ -106,7 +113,7 @@ def subscribe(
         console.print(f"Custom amount: [bold]${amount} USDC[/bold]")
     
     # Load wallet
-    account = load_wallet()
+    account = load_wallet(passphrase=passphrase)
     console.print(f"[green]✓[/green] Loaded wallet: {account.address}\n")
     
     # Run async subscribe
@@ -180,11 +187,11 @@ async def _subscribe_async(account, plan_id: str, api_base: str, amount: str = N
     register_exact_evm_client(client, EthAccountSigner(account))
     http_client = x402HTTPClient(client)
     
-    url = f"{api_base}/api/x402/{plan_id}"
-    console.print(f"\n[bold]→ Requesting:[/bold] POST {url}\n")
-    
     async with httpx.AsyncClient() as http:
         try:
+            url = await _resolve_plan_purchase_url(http, api_base, plan_id)
+            console.print(f"\n[bold]→ Requesting:[/bold] POST {url}\n")
+
             # Step 1: Make initial request to get 402 response with payment requirements
             response = await http.post(url)
             
@@ -254,7 +261,7 @@ async def _subscribe_async(account, plan_id: str, api_base: str, amount: str = N
                 console.print(f"\n[red]❌ Payment failed: {retry_response.status_code}[/red]")
                 console.print(retry_response.text)
                 raise typer.Exit(1)
-                
+
         except typer.Exit:
             raise
         except Exception as e:
@@ -264,6 +271,48 @@ async def _subscribe_async(account, plan_id: str, api_base: str, amount: str = N
             raise typer.Exit(1)
 
 
+def _extract_plan_purchase_url_from_discovery(discovery: object, plan_id: str) -> str | None:
+    if not isinstance(discovery, dict):
+        return None
+    resources = discovery.get("resources")
+    if not isinstance(resources, list):
+        return None
+    suffix = f"/x402/{plan_id}"
+    for resource in resources:
+        if not isinstance(resource, str):
+            continue
+        parsed = urlsplit(resource)
+        if parsed.path.endswith(suffix):
+            return resource
+    return None
+
+
+async def _resolve_plan_purchase_url(http: "httpx.AsyncClient", api_base: str, plan_id: str) -> str:
+    normalized_api_base = api_base.rstrip("/")
+    agents_base = get_agents_api_base_url_from_product_base(normalized_api_base).rstrip("/")
+    discovery_candidates = [
+        f"{agents_base}/.well-known/x402",
+        f"{normalized_api_base}/api/.well-known/x402",
+    ]
+
+    for discovery_url in discovery_candidates:
+        try:
+            response = await http.get(discovery_url)
+        except Exception:
+            continue
+        if response.status_code >= 400:
+            continue
+        try:
+            payload = response.json()
+        except Exception:
+            continue
+        resource_url = _extract_plan_purchase_url_from_discovery(payload, plan_id)
+        if resource_url:
+            return resource_url
+
+    return f"{agents_base}/x402/{plan_id}"
+
+
 @app.command("status")
 def status():
     """Show current HyperClaw key status"""

{hypercli_cli-2026.4.13 → hypercli_cli-2026.4.17}/hypercli_cli/keys.py

@@ -26,10 +26,14 @@ def _get_client():
 def create_key(
     name: str = typer.Option("default", help="Key name"),
     tag: list[str] = typer.Option(None, "--tag", help="Repeat as --tag team=dev"),
+    all_access: bool = typer.Option(False, "--all", help="Grant full access with *:*"),
 ):
     """Create a new API key"""
+    if all_access and tag:
+        raise typer.BadParameter("Use either --all or --tag, not both")
+
     client = _get_client()
-    key = client.keys.create(name=name, tags=tag or None)
+    key = client.keys.create(name=name, tags=(["*:*"] if all_access else (tag or None)))
     console.print(f"\n[bold green]API key created![/bold green]\n")
     console.print(f"  Key ID:  {key.key_id}")
     console.print(f"  Name:    {key.name}")

{hypercli_cli-2026.4.13 → hypercli_cli-2026.4.17}/hypercli_cli/voice.py

@@ -112,6 +112,7 @@ def tts(
     language: str = typer.Option("auto", "--language", "-l", help="Language: auto, english, chinese, etc."),
     format: str = typer.Option("mp3", "--format", "-f", help="Output format: wav, mp3, opus, ogg, flac"),
     output: Path = typer.Option(None, "--output", "-o", help="Output audio file (default: output.<format>)"),
+    timeout: float | None = typer.Option(None, "--timeout", help="Voice request timeout in seconds"),
     key: str = typer.Option(None, "--key", "-k", help="API key (sk-...)"),
     base_url: str = typer.Option(None, "--base-url", "-b", help="API base URL (default: api.hypercli.com)"),
 ):
@@ -133,6 +134,7 @@ def tts(
         voice=voice,
         language=language,
         response_format=format,
+        timeout=timeout,
     )
 
 
@@ -144,6 +146,7 @@ def clone(
     x_vector_only: bool = typer.Option(True, "--x-vector-only/--full-clone", help="Use x_vector_only mode (recommended)"),
     format: str = typer.Option("mp3", "--format", "-f", help="Output format: wav, mp3, opus, ogg, flac"),
     output: Path = typer.Option(None, "--output", "-o", help="Output audio file (default: output.<format>)"),
+    timeout: float | None = typer.Option(None, "--timeout", help="Voice request timeout in seconds"),
     key: str = typer.Option(None, "--key", "-k", help="API key (sk-...)"),
     base_url: str = typer.Option(None, "--base-url", "-b", help="API base URL (default: api.hypercli.com)"),
 ):
@@ -172,6 +175,7 @@ def clone(
         language=language,
         x_vector_only=x_vector_only,
         response_format=format,
+        timeout=timeout,
     )
 
 
@@ -182,6 +186,7 @@ def design(
     language: str = typer.Option("auto", "--language", "-l", help="Language: auto, english, chinese, etc."),
     format: str = typer.Option("mp3", "--format", "-f", help="Output format: wav, mp3, opus, ogg, flac"),
     output: Path = typer.Option(None, "--output", "-o", help="Output audio file (default: output.<format>)"),
+    timeout: float | None = typer.Option(None, "--timeout", help="Voice request timeout in seconds"),
     key: str = typer.Option(None, "--key", "-k", help="API key (sk-...)"),
     base_url: str = typer.Option(None, "--base-url", "-b", help="API base URL (default: api.hypercli.com)"),
 ):
@@ -203,4 +208,5 @@ def design(
         description=description,
         language=language,
         response_format=format,
+        timeout=timeout,
     )

{hypercli_cli-2026.4.13 → hypercli_cli-2026.4.17}/hypercli_cli/wallet.py

@@ -132,13 +132,13 @@ def _account_from_wallet_data(data: dict, passphrase: str | None = None):
     raise typer.Exit(1)
 
 
-def get_wallet_auth_token(api_url: str | None = None) -> str:
+def get_wallet_auth_token(api_url: str | None = None, *, passphrase: str | None = None) -> str:
     """Authenticate the local wallet and return a short-lived JWT bearer token."""
     from eth_account.messages import encode_defunct
     import httpx
     from hypercli.config import get_api_url
 
-    account = load_wallet()
+    account = load_wallet(passphrase=passphrase)
     base_url = (api_url or get_api_url()).rstrip("/")
 
     with httpx.Client(timeout=15) as client:
@@ -375,11 +375,17 @@ def qr(
 
 
 @app.command("balance")
-def balance():
+def balance(
+    passphrase: str = typer.Option(
+        None,
+        "--passphrase",
+        help="Current keystore passphrase. Skips interactive prompt.",
+    ),
+):
     """Check USDC balance on Base"""
     require_wallet_deps()
 
-    account = load_wallet()
+    account = load_wallet(passphrase=passphrase)
 
     console.print(f"\n[bold]Checking USDC balance on Base...[/bold]\n")
     
@@ -416,6 +422,11 @@ def balance():
 def topup(
     amount: str = typer.Argument(help="Amount in USDC to top up (max 6 decimals)"),
     api_url: str = typer.Option(None, help="API URL override"),
+    passphrase: str = typer.Option(
+        None,
+        "--passphrase",
+        help="Current keystore passphrase. Skips interactive prompt.",
+    ),
 ):
     """Top up account balance via Orchestra x402 endpoint.
 
@@ -460,7 +471,7 @@ def topup(
     amount_atomic = int(amount_dec * Decimal("1000000"))
 
     # Step 1: Load wallet
-    account = load_wallet()
+    account = load_wallet(passphrase=passphrase)
     console.print(f"[green]✓[/green] Wallet: {account.address}")
 
     # Step 2: Check USDC balance
@@ -585,6 +596,11 @@ def topup(
 def wallet_login(
     name: str = typer.Option("cli", help="Name for the generated API key"),
     api_url: str = typer.Option(None, help="API URL override"),
+    passphrase: str = typer.Option(
+        None,
+        "--passphrase",
+        help="Current keystore passphrase. Skips interactive prompt.",
+    ),
 ):
     """Login with wallet signature, create an API key, and save it.
     
@@ -592,16 +608,17 @@ def wallet_login(
     1. hyper wallet create
     2. hyper wallet login
     """
+    import httpx
     require_wallet_deps()
     from hypercli.config import get_api_url, configure
 
     base_url = (api_url or get_api_url()).rstrip("/")
 
     # Step 1: Load wallet
-    account = load_wallet()
+    account = load_wallet(passphrase=passphrase)
     console.print(f"[green]✓[/green] Wallet: {account.address}\n")
     console.print("[bold]Requesting login challenge...[/bold]")
-    jwt_token = get_wallet_auth_token(api_url=base_url)
+    jwt_token = get_wallet_auth_token(api_url=base_url, passphrase=passphrase)
     console.print("[green]✓[/green] Authenticated\n")
 
     # Step 5: Create API key using JWT
@@ -629,9 +646,9 @@ def wallet_login(
     console.print(f"\n[green]You're all set! Try:[/green] hyper keys list\n")
 
 
-def load_wallet():
+def load_wallet(*, passphrase: str | None = None):
     """Load and decrypt wallet (helper function for other commands)"""
     require_wallet_deps()
 
     wallet_data = _read_wallet_data()
-    return _account_from_wallet_data(wallet_data)
+    return _account_from_wallet_data(wallet_data, passphrase=passphrase)

{hypercli_cli-2026.4.13 → hypercli_cli-2026.4.17}/pyproject.toml

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

hypercli_cli-2026.4.17/tests/test_agent_subscribe_command.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+import json
+from types import SimpleNamespace
+
+from typer.testing import CliRunner
+
+from hypercli_cli.cli import app
+import hypercli_cli.agent as agent_mod
+
+
+runner = CliRunner()
+
+
+def test_agent_subscribe_passes_explicit_passphrase(monkeypatch, tmp_path):
+    hypercli_dir = tmp_path / ".hypercli"
+    monkeypatch.setattr(agent_mod, "HYPERCLI_DIR", hypercli_dir)
+    monkeypatch.setattr(agent_mod, "AGENT_KEY_PATH", hypercli_dir / "agent-key.json")
+    monkeypatch.setattr(agent_mod, "X402_AVAILABLE", True)
+
+    load_calls: list[str | None] = []
+
+    def _fake_load_wallet(*, passphrase=None):
+        load_calls.append(passphrase)
+        return SimpleNamespace(address="0xabc")
+
+    def _fake_subscribe_async(account, plan_id: str, api_base: str, amount: str | None = None):
+        assert account.address == "0xabc"
+        assert plan_id == "1aiu"
+        assert amount == "0.01"
+        return {
+            "key": "hyper_api_test",
+            "plan_id": "1aiu",
+            "amount_paid": "0.010000",
+            "duration_days": 0.5,
+            "expires_at": "2026-04-14T00:00:00Z",
+            "tpm_limit": 1000,
+            "rpm_limit": 10,
+        }
+
+    monkeypatch.setattr("hypercli_cli.wallet.load_wallet", _fake_load_wallet)
+    monkeypatch.setattr(agent_mod.asyncio, "run", lambda coro: coro)
+    monkeypatch.setattr(agent_mod, "_subscribe_async", _fake_subscribe_async)
+
+    result = runner.invoke(app, ["agent", "subscribe", "1aiu", "0.01", "--passphrase", "secret"])
+
+    assert result.exit_code == 0
+    assert load_calls == ["secret"]
+    saved = json.loads((hypercli_dir / "agent-key.json").read_text())
+    assert saved["key"] == "hyper_api_test"
+
+
+def test_agent_subscribe_uses_product_api_base_env(monkeypatch, tmp_path):
+    hypercli_dir = tmp_path / ".hypercli"
+    monkeypatch.setattr(agent_mod, "HYPERCLI_DIR", hypercli_dir)
+    monkeypatch.setattr(agent_mod, "AGENT_KEY_PATH", hypercli_dir / "agent-key.json")
+    monkeypatch.setattr(agent_mod, "X402_AVAILABLE", True)
+    monkeypatch.setenv("HYPER_API_BASE", "https://api.dev.hypercli.com")
+
+    def _fake_load_wallet(*, passphrase=None):
+        assert passphrase is None
+        return SimpleNamespace(address="0xabc")
+
+    def _fake_subscribe_async(account, plan_id: str, api_base: str, amount: str | None = None):
+        assert account.address == "0xabc"
+        assert plan_id == "1aiu"
+        assert amount == "0.01"
+        assert api_base == "https://api.dev.hypercli.com"
+        return {
+            "key": "hyper_api_test",
+            "plan_id": "1aiu",
+            "amount_paid": "0.010000",
+            "duration_days": 0.5,
+            "expires_at": "2026-04-14T00:00:00Z",
+            "tpm_limit": 1000,
+            "rpm_limit": 10,
+        }
+
+    monkeypatch.setattr("hypercli_cli.wallet.load_wallet", _fake_load_wallet)
+    monkeypatch.setattr(agent_mod.asyncio, "run", lambda coro: coro)
+    monkeypatch.setattr(agent_mod, "_subscribe_async", _fake_subscribe_async)
+
+    result = runner.invoke(app, ["agent", "subscribe", "1aiu", "0.01"])
+
+    assert result.exit_code == 0
+
+
+def test_extract_plan_purchase_url_from_agent_discovery():
+    discovery = {
+        "resources": [
+            "https://api.dev.hypercli.com/agents/x402/1aiu",
+            "https://api.dev.hypercli.com/agents/x402/2aiu",
+        ]
+    }
+
+    assert (
+        agent_mod._extract_plan_purchase_url_from_discovery(discovery, "1aiu")
+        == "https://api.dev.hypercli.com/agents/x402/1aiu"
+    )
+
+
+def test_extract_plan_purchase_url_from_discovery_ignores_nonmatching_resources():
+    discovery = {
+        "resources": [
+            "https://api.dev.hypercli.com/api/x402/top_up",
+            "https://api.dev.hypercli.com/api/x402/job",
+        ]
+    }
+
+    assert agent_mod._extract_plan_purchase_url_from_discovery(discovery, "1aiu") is None

hypercli_cli-2026.4.17/tests/test_keys_command.py

@@ -0,0 +1,42 @@
+from typer.testing import CliRunner
+
+from hypercli_cli.cli import app
+
+
+runner = CliRunner()
+
+
+class _FakeKey:
+    key_id = "key-123"
+    name = "demo"
+    api_key = "hyper_api_test"
+    tags = ["*:*"]
+
+
+def test_keys_create_all_expands_to_global_scope(monkeypatch):
+    import hypercli_cli.keys as keys
+
+    captured = {}
+
+    class _FakeKeys:
+        def create(self, *, name, tags=None):
+            captured["name"] = name
+            captured["tags"] = tags
+            return _FakeKey()
+
+    class _FakeClient:
+        keys = _FakeKeys()
+
+    monkeypatch.setattr(keys, "_get_client", lambda: _FakeClient())
+
+    result = runner.invoke(app, ["keys", "create", "--name", "demo", "--all"])
+
+    assert result.exit_code == 0, result.stdout
+    assert captured == {"name": "demo", "tags": ["*:*"]}
+
+
+def test_keys_create_rejects_all_and_tag_together():
+    result = runner.invoke(app, ["keys", "create", "--all", "--tag", "team=dev"])
+
+    assert result.exit_code != 0
+    assert "Use either --all or --tag, not both" in result.stdout

{hypercli_cli-2026.4.13 → hypercli_cli-2026.4.17}/tests/test_voice_command.py

@@ -70,3 +70,39 @@ def test_agent_transcribe_command_is_removed():
 
     assert result.exit_code != 0
     assert "No such command 'transcribe'" in result.stdout
+
+
+def test_voice_tts_forwards_timeout(monkeypatch, tmp_path):
+    import hypercli_cli.voice as voice
+
+    monkeypatch.setenv("HYPER_API_KEY", "hyper_api_test")
+    captured = {}
+
+    def _fake_post_voice(endpoint, api_key, output, base_url=None, **kwargs):
+        captured["endpoint"] = endpoint
+        captured["api_key"] = api_key
+        captured["output"] = output
+        captured["base_url"] = base_url
+        captured["kwargs"] = kwargs
+
+    monkeypatch.setattr(voice, "_post_voice", _fake_post_voice)
+
+    output = tmp_path / "tts.wav"
+    result = runner.invoke(
+        app,
+        [
+            "voice",
+            "tts",
+            "hello",
+            "--format",
+            "wav",
+            "--output",
+            str(output),
+            "--timeout",
+            "720",
+        ],
+    )
+
+    assert result.exit_code == 0, result.stdout
+    assert captured["endpoint"] == "tts"
+    assert captured["kwargs"]["timeout"] == 720.0

hypercli_cli-2026.4.17/tests/test_wallet_command.py

@@ -0,0 +1,343 @@
+import json
+import sys
+from types import SimpleNamespace
+
+from typer.testing import CliRunner
+
+from hypercli_cli.cli import app
+import hypercli_cli.wallet as wallet_mod
+
+
+runner = CliRunner()
+
+
+class FakeLocalAccount:
+    def __init__(self, private_key_hex: str):
+        raw = private_key_hex.removeprefix("0x").lower()
+        self._private_key_hex = raw
+        self.key = bytes.fromhex(raw)
+        self.address = f"0x{raw[-40:]}"
+
+    def encrypt(self, passphrase: str):
+        return {
+            "address": self.address[2:].lower(),
+            "crypto": {
+                "ciphertext": self._private_key_hex[::-1],
+                "passphrase": passphrase,
+            },
+        }
+
+    def sign_message(self, _message):
+        return SimpleNamespace(signature=b"\x12\x34")
+
+
+class FakeAccountAPI:
+    CREATED_PRIVATE_KEY = "11" * 32
+
+    @staticmethod
+    def create():
+        return FakeLocalAccount(FakeAccountAPI.CREATED_PRIVATE_KEY)
+
+    @staticmethod
+    def decrypt(data, passphrase):
+        crypto = data.get("crypto") or data.get("Crypto") or {}
+        if crypto.get("passphrase") != passphrase:
+            raise ValueError("bad passphrase")
+        return bytes.fromhex(str(crypto["ciphertext"])[::-1])
+
+    @staticmethod
+    def from_key(private_key):
+        if isinstance(private_key, bytes):
+            raw = private_key.hex()
+        else:
+            raw = str(private_key).removeprefix("0x")
+        return FakeLocalAccount(raw)
+
+
+def _set_temp_wallet_paths(monkeypatch, tmp_path):
+    wallet_dir = tmp_path / ".hypercli"
+    wallet_path = wallet_dir / "wallet.json"
+    passphrase_path = wallet_dir / "wallet.passphrase"
+    monkeypatch.setattr(wallet_mod, "WALLET_AVAILABLE", True)
+    monkeypatch.setattr(wallet_mod, "Account", FakeAccountAPI)
+    monkeypatch.setattr(wallet_mod, "WALLET_DIR", wallet_dir)
+    monkeypatch.setattr(wallet_mod, "WALLET_PATH", wallet_path)
+    monkeypatch.setattr(wallet_mod, "WALLET_PASSPHRASE_PATH", passphrase_path)
+    return wallet_path
+
+
+def test_wallet_create_unencrypted_wallet(monkeypatch, tmp_path):
+    wallet_path = _set_temp_wallet_paths(monkeypatch, tmp_path)
+
+    result = runner.invoke(app, ["wallet", "create", "--no-passphrase"])
+    assert result.exit_code == 0
+
+    plain_data = json.loads(wallet_path.read_text())
+    assert plain_data["type"] == "plaintext_private_key"
+    assert plain_data["private_key"] == f"0x{FakeAccountAPI.CREATED_PRIVATE_KEY}"
+    assert plain_data["address"] == f"0x{FakeAccountAPI.CREATED_PRIVATE_KEY[-40:]}"
+
+
+def test_old_unencrypted_wallet_import(monkeypatch, tmp_path):
+    known_private_key = "22" * 32
+    wallet_path = _set_temp_wallet_paths(monkeypatch, tmp_path)
+    wallet_path.parent.mkdir(parents=True, exist_ok=True)
+    wallet_path.write_text(
+        json.dumps(
+            {
+                "type": "plaintext_private_key",
+                "address": f"0x{known_private_key[-40:]}",
+                "private_key": f"0x{known_private_key}",
+            }
+        )
+    )
+
+    result = runner.invoke(app, ["wallet", "address"])
+    assert result.exit_code == 0
+    assert f"0x{known_private_key[-40:]}" in result.stdout
+
+
+def test_old_encrypted_wallet_import(monkeypatch, tmp_path):
+    known_private_key = "44" * 32
+    wallet_path = _set_temp_wallet_paths(monkeypatch, tmp_path)
+    wallet_path.parent.mkdir(parents=True, exist_ok=True)
+    legacy_account = FakeLocalAccount(known_private_key)
+    wallet_path.write_text(json.dumps(legacy_account.encrypt("legacy-pass")))
+
+    result = runner.invoke(app, ["wallet", "decrypt", "--passphrase", "legacy-pass"])
+
+    assert result.exit_code == 0
+    decrypted_data = json.loads(wallet_path.read_text())
+    assert decrypted_data["type"] == "plaintext_private_key"
+    assert decrypted_data["private_key"] == f"0x{known_private_key}"
+    assert decrypted_data["address"] == legacy_account.address
+
+
+def test_encrypt_created_plaintext_wallet(monkeypatch, tmp_path):
+    wallet_path = _set_temp_wallet_paths(monkeypatch, tmp_path)
+
+    create_result = runner.invoke(app, ["wallet", "create", "--no-passphrase"])
+    assert create_result.exit_code == 0
+
+    result = runner.invoke(app, ["wallet", "encrypt", "--passphrase", "secret"])
+    assert result.exit_code == 0
+
+    encrypted_data = json.loads(wallet_path.read_text())
+    assert "crypto" in encrypted_data
+    assert "private_key" not in encrypted_data
+    assert encrypted_data["address"] == FakeAccountAPI.CREATED_PRIVATE_KEY[-40:]
+
+
+def test_decrypt_encrypted_wallet(monkeypatch, tmp_path):
+    wallet_path = _set_temp_wallet_paths(monkeypatch, tmp_path)
+
+    create_result = runner.invoke(app, ["wallet", "create", "--no-passphrase"])
+    assert create_result.exit_code == 0
+    encrypt_result = runner.invoke(app, ["wallet", "encrypt", "--passphrase", "secret"])
+    assert encrypt_result.exit_code == 0
+
+    result = runner.invoke(app, ["wallet", "decrypt", "--passphrase", "secret"])
+    assert result.exit_code == 0
+
+    decrypted_data = json.loads(wallet_path.read_text())
+    assert decrypted_data["type"] == "plaintext_private_key"
+    assert decrypted_data["private_key"] == f"0x{FakeAccountAPI.CREATED_PRIVATE_KEY}"
+    assert decrypted_data["address"] == f"0x{FakeAccountAPI.CREATED_PRIVATE_KEY[-40:]}"
+
+
+def test_load_wallet_uses_explicit_passphrase(monkeypatch, tmp_path):
+    known_private_key = "55" * 32
+    wallet_path = _set_temp_wallet_paths(monkeypatch, tmp_path)
+    wallet_path.parent.mkdir(parents=True, exist_ok=True)
+    wallet_path.write_text(json.dumps(FakeLocalAccount(known_private_key).encrypt("secret")))
+
+    account = wallet_mod.load_wallet(passphrase="secret")
+
+    assert account.address == f"0x{known_private_key[-40:]}"
+
+
+def test_wallet_balance_passes_explicit_passphrase(monkeypatch, tmp_path):
+    _set_temp_wallet_paths(monkeypatch, tmp_path)
+    seen: list[str | None] = []
+
+    class _FakeCall:
+        def call(self):
+            return 1234567
+
+    class _FakeContractFunctions:
+        def balanceOf(self, _address):
+            return _FakeCall()
+
+    class _FakeContract:
+        functions = _FakeContractFunctions()
+
+    class _FakeEth:
+        def contract(self, address=None, abi=None):
+            return _FakeContract()
+
+    class _FakeWeb3:
+        HTTPProvider = staticmethod(lambda url: url)
+
+        def __init__(self, _provider):
+            self.eth = _FakeEth()
+
+    def _fake_load_wallet(*, passphrase=None):
+        seen.append(passphrase)
+        return SimpleNamespace(address="0xabc")
+
+    monkeypatch.setattr(wallet_mod, "load_wallet", _fake_load_wallet)
+    monkeypatch.setattr(wallet_mod, "Web3", _FakeWeb3)
+
+    result = runner.invoke(app, ["wallet", "balance", "--passphrase", "secret"])
+
+    assert result.exit_code == 0
+    assert seen == ["secret"]
+    assert "1.234567" in result.stdout
+
+
+def test_wallet_login_passes_explicit_passphrase(monkeypatch, tmp_path):
+    _set_temp_wallet_paths(monkeypatch, tmp_path)
+    load_calls: list[str | None] = []
+    auth_calls: list[str | None] = []
+
+    def _fake_load_wallet(*, passphrase=None):
+        load_calls.append(passphrase)
+        return SimpleNamespace(address="0xabc")
+
+    def _fake_get_wallet_auth_token(api_url=None, *, passphrase=None):
+        auth_calls.append(passphrase)
+        return "jwt-token"
+
+    class _FakeHttpxClient:
+        def __init__(self, timeout=None):
+            self.timeout = timeout
+
+        def __enter__(self):
+            return self
+
+        def __exit__(self, exc_type, exc, tb):
+            return False
+
+        def post(self, url, json=None, headers=None):
+            return SimpleNamespace(
+                status_code=200,
+                json=lambda: {"api_key": "hyper_api_test", "name": json["name"]},
+                text="ok",
+            )
+
+    monkeypatch.setattr(wallet_mod, "load_wallet", _fake_load_wallet)
+    monkeypatch.setattr(wallet_mod, "get_wallet_auth_token", _fake_get_wallet_auth_token)
+    monkeypatch.setitem(sys.modules, "httpx", SimpleNamespace(Client=_FakeHttpxClient))
+    monkeypatch.setattr(
+        sys.modules["hypercli.config"],
+        "configure",
+        lambda api_key, api_url: None,
+    )
+    monkeypatch.setattr(
+        sys.modules["hypercli.config"],
+        "get_api_url",
+        lambda: "https://api.example.com",
+    )
+
+    result = runner.invoke(app, ["wallet", "login", "--passphrase", "secret"])
+
+    assert result.exit_code == 0
+    assert load_calls == ["secret"]
+    assert auth_calls == ["secret"]
+
+
+def test_wallet_topup_passes_explicit_passphrase(monkeypatch, tmp_path):
+    _set_temp_wallet_paths(monkeypatch, tmp_path)
+    load_calls: list[str | None] = []
+
+    class _FakeCall:
+        def call(self):
+            return 2_000_000
+
+    class _FakeContractFunctions:
+        def balanceOf(self, _address):
+            return _FakeCall()
+
+    class _FakeContract:
+        functions = _FakeContractFunctions()
+
+    class _FakeEth:
+        def contract(self, address=None, abi=None):
+            return _FakeContract()
+
+    class _FakeWeb3:
+        HTTPProvider = staticmethod(lambda url: url)
+
+        def __init__(self, _provider):
+            self.eth = _FakeEth()
+
+    class _FakeX402ClientSync:
+        def register(self, *_args, **_kwargs):
+            return None
+
+    class _FakeX402HTTPClientSync:
+        def __init__(self, _client):
+            pass
+
+        def handle_402_response(self, headers, content):
+            return ({"X-Payment": "sig"}, None)
+
+        def get_payment_settle_response(self, getter):
+            return SimpleNamespace(transaction=None, network=None, error_reason=None)
+
+    class _FakeEthAccountSigner:
+        def __init__(self, account):
+            self.account = account
+
+    class _FakeHttpxClient:
+        def __init__(self, timeout=None):
+            self.timeout = timeout
+            self.posts = 0
+
+        def __enter__(self):
+            return self
+
+        def __exit__(self, exc_type, exc, tb):
+            return False
+
+        def get(self, url, headers=None):
+            return SimpleNamespace(status_code=200, json=lambda: {"user_id": "user-1"}, text="ok")
+
+        def post(self, url, headers=None, json=None):
+            self.posts += 1
+            if self.posts == 1:
+                return SimpleNamespace(status_code=402, headers={}, content=b"", text="payment required")
+            return SimpleNamespace(
+                status_code=200,
+                json=lambda: {
+                    "user_id": "user-1",
+                    "amount": 1.0,
+                    "wallet": "0xabc",
+                    "transaction_id": "tx-1",
+                    "message": "Top-up successful",
+                },
+                headers={},
+                text="ok",
+            )
+
+    def _fake_load_wallet(*, passphrase=None):
+        load_calls.append(passphrase)
+        return SimpleNamespace(address="0xabc")
+
+    monkeypatch.setattr(wallet_mod, "load_wallet", _fake_load_wallet)
+    monkeypatch.setattr(wallet_mod, "Web3", _FakeWeb3)
+    monkeypatch.setitem(sys.modules, "httpx", SimpleNamespace(Client=_FakeHttpxClient))
+    monkeypatch.setattr(sys.modules["hypercli.config"], "get_api_key", lambda: "hyper_api_test")
+    monkeypatch.setattr(sys.modules["hypercli.config"], "get_api_url", lambda: "https://api.example.com")
+
+    sys.modules["x402"] = SimpleNamespace(x402ClientSync=_FakeX402ClientSync)
+    sys.modules["x402.http"] = SimpleNamespace(x402HTTPClientSync=_FakeX402HTTPClientSync)
+    sys.modules["x402.mechanisms.evm"] = SimpleNamespace(EthAccountSigner=_FakeEthAccountSigner)
+    sys.modules["x402.mechanisms.evm.exact.register"] = SimpleNamespace(
+        register_exact_evm_client=lambda *_args, **_kwargs: None
+    )
+
+    result = runner.invoke(app, ["wallet", "topup", "1.0", "--passphrase", "secret"])
+
+    assert result.exit_code == 0
+    assert load_calls == ["secret"]

hypercli_cli-2026.4.13/hypercli_cli/__init__.py

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

hypercli_cli-2026.4.13/tests/test_wallet_command.py

@@ -1,144 +0,0 @@
-import json
-from types import SimpleNamespace
-
-from typer.testing import CliRunner
-
-from hypercli_cli.cli import app
-import hypercli_cli.wallet as wallet_mod
-
-
-runner = CliRunner()
-
-
-class FakeLocalAccount:
-    def __init__(self, private_key_hex: str):
-        raw = private_key_hex.removeprefix("0x").lower()
-        self._private_key_hex = raw
-        self.key = bytes.fromhex(raw)
-        self.address = f"0x{raw[-40:]}"
-
-    def encrypt(self, passphrase: str):
-        return {
-            "address": self.address[2:].lower(),
-            "crypto": {
-                "ciphertext": self._private_key_hex[::-1],
-                "passphrase": passphrase,
-            },
-        }
-
-    def sign_message(self, _message):
-        return SimpleNamespace(signature=b"\x12\x34")
-
-
-class FakeAccountAPI:
-    CREATED_PRIVATE_KEY = "11" * 32
-
-    @staticmethod
-    def create():
-        return FakeLocalAccount(FakeAccountAPI.CREATED_PRIVATE_KEY)
-
-    @staticmethod
-    def decrypt(data, passphrase):
-        crypto = data.get("crypto") or data.get("Crypto") or {}
-        if crypto.get("passphrase") != passphrase:
-            raise ValueError("bad passphrase")
-        return bytes.fromhex(str(crypto["ciphertext"])[::-1])
-
-    @staticmethod
-    def from_key(private_key):
-        if isinstance(private_key, bytes):
-            raw = private_key.hex()
-        else:
-            raw = str(private_key).removeprefix("0x")
-        return FakeLocalAccount(raw)
-
-
-def _set_temp_wallet_paths(monkeypatch, tmp_path):
-    wallet_dir = tmp_path / ".hypercli"
-    wallet_path = wallet_dir / "wallet.json"
-    passphrase_path = wallet_dir / "wallet.passphrase"
-    monkeypatch.setattr(wallet_mod, "WALLET_AVAILABLE", True)
-    monkeypatch.setattr(wallet_mod, "Account", FakeAccountAPI)
-    monkeypatch.setattr(wallet_mod, "WALLET_DIR", wallet_dir)
-    monkeypatch.setattr(wallet_mod, "WALLET_PATH", wallet_path)
-    monkeypatch.setattr(wallet_mod, "WALLET_PASSPHRASE_PATH", passphrase_path)
-    return wallet_path
-
-
-def test_wallet_create_unencrypted_wallet(monkeypatch, tmp_path):
-    wallet_path = _set_temp_wallet_paths(monkeypatch, tmp_path)
-
-    result = runner.invoke(app, ["wallet", "create", "--no-passphrase"])
-    assert result.exit_code == 0
-
-    plain_data = json.loads(wallet_path.read_text())
-    assert plain_data["type"] == "plaintext_private_key"
-    assert plain_data["private_key"] == f"0x{FakeAccountAPI.CREATED_PRIVATE_KEY}"
-    assert plain_data["address"] == f"0x{FakeAccountAPI.CREATED_PRIVATE_KEY[-40:]}"
-
-
-def test_old_unencrypted_wallet_import(monkeypatch, tmp_path):
-    known_private_key = "22" * 32
-    wallet_path = _set_temp_wallet_paths(monkeypatch, tmp_path)
-    wallet_path.parent.mkdir(parents=True, exist_ok=True)
-    wallet_path.write_text(
-        json.dumps(
-            {
-                "type": "plaintext_private_key",
-                "address": f"0x{known_private_key[-40:]}",
-                "private_key": f"0x{known_private_key}",
-            }
-        )
-    )
-
-    result = runner.invoke(app, ["wallet", "address"])
-    assert result.exit_code == 0
-    assert f"0x{known_private_key[-40:]}" in result.stdout
-
-
-def test_old_encrypted_wallet_import(monkeypatch, tmp_path):
-    known_private_key = "44" * 32
-    wallet_path = _set_temp_wallet_paths(monkeypatch, tmp_path)
-    wallet_path.parent.mkdir(parents=True, exist_ok=True)
-    legacy_account = FakeLocalAccount(known_private_key)
-    wallet_path.write_text(json.dumps(legacy_account.encrypt("legacy-pass")))
-
-    result = runner.invoke(app, ["wallet", "decrypt", "--passphrase", "legacy-pass"])
-
-    assert result.exit_code == 0
-    decrypted_data = json.loads(wallet_path.read_text())
-    assert decrypted_data["type"] == "plaintext_private_key"
-    assert decrypted_data["private_key"] == f"0x{known_private_key}"
-    assert decrypted_data["address"] == legacy_account.address
-
-
-def test_encrypt_created_plaintext_wallet(monkeypatch, tmp_path):
-    wallet_path = _set_temp_wallet_paths(monkeypatch, tmp_path)
-
-    create_result = runner.invoke(app, ["wallet", "create", "--no-passphrase"])
-    assert create_result.exit_code == 0
-
-    result = runner.invoke(app, ["wallet", "encrypt", "--passphrase", "secret"])
-    assert result.exit_code == 0
-
-    encrypted_data = json.loads(wallet_path.read_text())
-    assert "crypto" in encrypted_data
-    assert "private_key" not in encrypted_data
-    assert encrypted_data["address"] == FakeAccountAPI.CREATED_PRIVATE_KEY[-40:]
-
-
-def test_decrypt_encrypted_wallet(monkeypatch, tmp_path):
-    wallet_path = _set_temp_wallet_paths(monkeypatch, tmp_path)
-
-    create_result = runner.invoke(app, ["wallet", "create", "--no-passphrase"])
-    assert create_result.exit_code == 0
-    encrypt_result = runner.invoke(app, ["wallet", "encrypt", "--passphrase", "secret"])
-    assert encrypt_result.exit_code == 0
-
-    result = runner.invoke(app, ["wallet", "decrypt", "--passphrase", "secret"])
-    assert result.exit_code == 0
-
-    decrypted_data = json.loads(wallet_path.read_text())
-    assert decrypted_data["type"] == "plaintext_private_key"
-    assert decrypted_data["private_key"] == f"0x{FakeAccountAPI.CREATED_PRIVATE_KEY}"
-    assert decrypted_data["address"] == f"0x{FakeAccountAPI.CREATED_PRIVATE_KEY[-40:]}"