muapi-cli 0.2.5__py3-none-any.whl

muapi/__init__.py

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

muapi/client.py

@@ -0,0 +1,121 @@
+"""Async HTTP client wrapping the muapi submit → poll pattern."""
+import time
+from typing import Any, Optional
+
+import httpx
+
+from .config import BASE_URL, get_api_key
+
+_DEFAULT_TIMEOUT = 30.0
+_POLL_INTERVAL = 3        # seconds between polls
+_MAX_POLL_SECONDS = 600   # 10 minutes
+
+
+class MuapiError(Exception):
+    def __init__(self, message: str, status_code: int = 0):
+        super().__init__(message)
+        self.status_code = status_code
+
+    @property
+    def exit_code(self) -> int:
+        """Map HTTP status codes to semantic CLI exit codes."""
+        from .exitcodes import AUTH_ERROR, RATE_LIMITED, BILLING_ERROR, NOT_FOUND, ERROR
+        return {
+            401: AUTH_ERROR,
+            403: AUTH_ERROR,
+            404: NOT_FOUND,
+            429: RATE_LIMITED,
+            402: BILLING_ERROR,
+        }.get(self.status_code, ERROR)
+
+
+def _headers(api_key: str) -> dict:
+    return {"x-api-key": api_key, "Content-Type": "application/json"}
+
+
+def _get_key() -> str:
+    key = get_api_key()
+    if not key:
+        raise MuapiError(
+            "No API key configured. Run: muapi auth configure"
+        )
+    return key
+
+
+# ── Low-level calls ────────────────────────────────────────────────────────────
+
+def post(endpoint: str, payload: dict) -> dict:
+    """Submit a generation request; returns raw response dict."""
+    key = _get_key()
+    url = f"{BASE_URL}/{endpoint.lstrip('/')}"
+    with httpx.Client(timeout=_DEFAULT_TIMEOUT) as client:
+        resp = client.post(url, json=payload, headers=_headers(key))
+    if resp.status_code >= 400:
+        raise MuapiError(resp.text, resp.status_code)
+    return resp.json()
+
+
+def get_result(request_id: str) -> dict:
+    """Fetch a single prediction result (no polling)."""
+    key = _get_key()
+    url = f"{BASE_URL}/predictions/{request_id}/result"
+    with httpx.Client(timeout=_DEFAULT_TIMEOUT) as client:
+        resp = client.get(url, headers=_headers(key))
+    if resp.status_code >= 400:
+        raise MuapiError(resp.text, resp.status_code)
+    return resp.json()
+
+
+def upload_file(file_path: str) -> dict:
+    """Upload a local file, returns the upload response (url, etc.)."""
+    key = _get_key()
+    url = f"{BASE_URL}/upload_file"
+    with open(file_path, "rb") as f:
+        with httpx.Client(timeout=120.0) as client:
+            resp = client.post(
+                url,
+                files={"file": (file_path.split("/")[-1], f)},
+                headers={"x-api-key": key},
+            )
+    if resp.status_code >= 400:
+        raise MuapiError(resp.text, resp.status_code)
+    return resp.json()
+
+
+# ── Polling ────────────────────────────────────────────────────────────────────
+
+def wait_for_result(
+    request_id: str,
+    poll_interval: int = _POLL_INTERVAL,
+    max_seconds: int = _MAX_POLL_SECONDS,
+    progress_callback=None,
+) -> dict:
+    """Poll until status is 'completed' or 'failed'."""
+    deadline = time.time() + max_seconds
+    while time.time() < deadline:
+        result = get_result(request_id)
+        status = result.get("status", "")
+        if progress_callback:
+            progress_callback(status)
+        if status == "completed":
+            return result
+        if status == "failed":
+            raise MuapiError(f"Generation failed: {result.get('error', 'unknown error')}")
+        time.sleep(poll_interval)
+    raise MuapiError(f"Timed out waiting for result after {max_seconds}s")
+
+
+# ── Convenience: submit + optional wait ───────────────────────────────────────
+
+def generate(
+    endpoint: str,
+    payload: dict,
+    wait: bool = True,
+    poll_interval: int = _POLL_INTERVAL,
+    progress_callback=None,
+) -> dict:
+    result = post(endpoint, payload)
+    request_id = result.get("request_id") or result.get("id")
+    if not wait or not request_id:
+        return result
+    return wait_for_result(request_id, poll_interval, progress_callback=progress_callback)

muapi/commands/account.py

@@ -0,0 +1,89 @@
+"""muapi account — check balance and top up credits."""
+import json
+import webbrowser
+
+import httpx
+import typer
+
+from .. import exitcodes
+from ..config import BASE_URL, get_api_key
+from ..utils import console, error_exit, out
+
+app = typer.Typer(help="Manage your muapi.ai account balance and credits.")
+
+
+def _headers() -> dict:
+    key = get_api_key()
+    if not key:
+        error_exit("No API key configured. Run: muapi auth configure", exitcodes.AUTH_ERROR)
+    return {"x-api-key": key}
+
+
+@app.command("balance")
+def balance(
+    output_json: bool = typer.Option(False, "--output-json", "-j", help="Print raw JSON"),
+):
+    """Show your current account balance."""
+    try:
+        resp = httpx.get(f"{BASE_URL}/account/balance", headers=_headers(), timeout=30.0)
+    except httpx.RequestError as exc:
+        error_exit(f"Network error: {exc}", exitcodes.ERROR)
+
+    if resp.status_code == 401 or resp.status_code == 403:
+        error_exit("Authentication failed. Run: muapi auth configure", exitcodes.AUTH_ERROR)
+    if resp.status_code >= 400:
+        error_exit(f"Request failed: {resp.text}", exitcodes.ERROR)
+
+    data = resp.json()
+    if output_json:
+        out.print_json(json.dumps(data))
+    else:
+        bal = data.get("balance", 0.0)
+        currency = data.get("currency", "USD").upper()
+        email = data.get("email", "")
+        console.print(f"[bold]{email}[/bold]")
+        console.print(f"Balance: [green bold]${bal:.4f} {currency}[/green bold]")
+
+
+@app.command("topup")
+def topup(
+    amount: int = typer.Option(10, "--amount", "-a", help="Amount in USD to add (minimum $1)"),
+    currency: str = typer.Option("usd", "--currency", "-c", help="Currency (default: usd)"),
+    output_json: bool = typer.Option(False, "--output-json", "-j", help="Print checkout URL as JSON instead of opening browser"),
+    no_open: bool = typer.Option(False, "--no-open", help="Print URL without opening browser"),
+):
+    """Add credits to your account via Stripe checkout."""
+    if amount < 1:
+        error_exit("Minimum topup amount is $1.", exitcodes.VALIDATION)
+
+    try:
+        resp = httpx.post(
+            f"{BASE_URL}/account/topup",
+            json={"amount": amount, "currency": currency.lower()},
+            headers=_headers(),
+            timeout=30.0,
+        )
+    except httpx.RequestError as exc:
+        error_exit(f"Network error: {exc}", exitcodes.ERROR)
+
+    if resp.status_code == 401 or resp.status_code == 403:
+        error_exit("Authentication failed. Run: muapi auth configure", exitcodes.AUTH_ERROR)
+    if resp.status_code == 402:
+        error_exit("Billing error. Please contact support.", exitcodes.BILLING_ERROR)
+    if resp.status_code >= 400:
+        error_exit(f"Request failed: {resp.text}", exitcodes.ERROR)
+
+    data = resp.json()
+    checkout_url = data.get("checkout_url", "")
+
+    if output_json:
+        out.print_json(json.dumps(data))
+        return
+
+    console.print(f"Checkout URL: [bold blue]{checkout_url}[/bold blue]")
+
+    if not no_open:
+        console.print("Opening browser for payment…")
+        webbrowser.open(checkout_url)
+    else:
+        console.print("Open the URL above to complete payment.")

muapi/commands/audio.py

@@ -0,0 +1,139 @@
+"""muapi audio — music creation and audio generation."""
+from typing import Optional
+
+import typer
+
+from .. import client
+from ..utils import console, download_outputs, error_exit, print_result, spinner_status
+
+app = typer.Typer(help="Create and remix music and audio.")
+
+
+@app.command("create")
+def create(
+    prompt: str = typer.Argument(..., help="Music description / lyrics prompt"),
+    title: str = typer.Option("", "--title", "-t", help="Song title"),
+    tags: str = typer.Option("", "--tags", help="Genre/style tags (comma-separated)"),
+    instrumental: bool = typer.Option(False, "--instrumental", help="Generate without vocals"),
+    webhook: Optional[str] = typer.Option(None, "--webhook", help="Webhook URL for async notification"),
+    wait: bool = typer.Option(True, "--wait/--no-wait"),
+    download: Optional[str] = typer.Option(None, "--download", "-d"),
+    output_json: bool = typer.Option(False, "--output-json", "-j"),
+):
+    """Create original music with Suno."""
+    payload = {
+        "prompt": prompt,
+        "title": title,
+        "tags": tags,
+        "make_instrumental": instrumental,
+    }
+    if webhook:
+        payload["webhook_url"] = webhook
+    try:
+        with spinner_status("Creating music with Suno..."):
+            result = client.generate("suno-create-music", payload, wait=wait)
+    except client.MuapiError as e:
+        error_exit(str(e))
+
+    print_result(result, output_json, label="Music (Suno)")
+    if download and result.get("status") == "completed":
+        download_outputs(result, download)
+
+
+@app.command("remix")
+def remix(
+    song_id: str = typer.Argument(..., help="Suno song ID to remix"),
+    prompt: str = typer.Option("", "--prompt", "-p", help="New style/lyric prompt"),
+    title: str = typer.Option("", "--title", "-t"),
+    tags: str = typer.Option("", "--tags"),
+    webhook: Optional[str] = typer.Option(None, "--webhook", help="Webhook URL for async notification"),
+    wait: bool = typer.Option(True, "--wait/--no-wait"),
+    download: Optional[str] = typer.Option(None, "--download", "-d"),
+    output_json: bool = typer.Option(False, "--output-json", "-j"),
+):
+    """Remix an existing Suno song."""
+    payload = {"song_id": song_id, "prompt": prompt, "title": title, "tags": tags}
+    if webhook:
+        payload["webhook_url"] = webhook
+    try:
+        with spinner_status("Remixing with Suno..."):
+            result = client.generate("suno-remix-music", payload, wait=wait)
+    except client.MuapiError as e:
+        error_exit(str(e))
+
+    print_result(result, output_json, label="Remix (Suno)")
+    if download and result.get("status") == "completed":
+        download_outputs(result, download)
+
+
+@app.command("extend")
+def extend(
+    song_id: str = typer.Argument(..., help="Suno song ID to extend"),
+    prompt: str = typer.Option("", "--prompt", "-p"),
+    continue_at: float = typer.Option(0, "--continue-at", help="Time (seconds) to extend from"),
+    webhook: Optional[str] = typer.Option(None, "--webhook", help="Webhook URL for async notification"),
+    wait: bool = typer.Option(True, "--wait/--no-wait"),
+    download: Optional[str] = typer.Option(None, "--download", "-d"),
+    output_json: bool = typer.Option(False, "--output-json", "-j"),
+):
+    """Extend a Suno song."""
+    payload = {"song_id": song_id, "prompt": prompt, "continue_at": continue_at}
+    if webhook:
+        payload["webhook_url"] = webhook
+    try:
+        with spinner_status("Extending with Suno..."):
+            result = client.generate("suno-extend-music", payload, wait=wait)
+    except client.MuapiError as e:
+        error_exit(str(e))
+
+    print_result(result, output_json, label="Extended (Suno)")
+    if download and result.get("status") == "completed":
+        download_outputs(result, download)
+
+
+@app.command("from-text")
+def from_text(
+    prompt: str = typer.Argument(..., help="Describe the audio to generate"),
+    duration: float = typer.Option(10.0, "--duration", "-D", help="Duration in seconds"),
+    webhook: Optional[str] = typer.Option(None, "--webhook", help="Webhook URL for async notification"),
+    wait: bool = typer.Option(True, "--wait/--no-wait"),
+    download: Optional[str] = typer.Option(None, "--download", "-d"),
+    output_json: bool = typer.Option(False, "--output-json", "-j"),
+):
+    """Generate audio from text with MMAudio."""
+    payload = {"prompt": prompt, "duration": duration}
+    if webhook:
+        payload["webhook_url"] = webhook
+    try:
+        with spinner_status("Generating audio with MMAudio..."):
+            result = client.generate("mmaudio-v2/text-to-audio", payload, wait=wait)
+    except client.MuapiError as e:
+        error_exit(str(e))
+
+    print_result(result, output_json, label="Audio (MMAudio)")
+    if download and result.get("status") == "completed":
+        download_outputs(result, download)
+
+
+@app.command("from-video")
+def from_video(
+    video_url: str = typer.Argument(..., help="Source video URL"),
+    prompt: str = typer.Option("", "--prompt", "-p", help="Audio description prompt"),
+    webhook: Optional[str] = typer.Option(None, "--webhook", help="Webhook URL for async notification"),
+    wait: bool = typer.Option(True, "--wait/--no-wait"),
+    download: Optional[str] = typer.Option(None, "--download", "-d"),
+    output_json: bool = typer.Option(False, "--output-json", "-j"),
+):
+    """Add AI-generated audio to a video (MMAudio video-to-video)."""
+    payload = {"video_url": video_url, "prompt": prompt}
+    if webhook:
+        payload["webhook_url"] = webhook
+    try:
+        with spinner_status("Generating audio for video with MMAudio..."):
+            result = client.generate("mmaudio-v2/video-to-video", payload, wait=wait)
+    except client.MuapiError as e:
+        error_exit(str(e))
+
+    print_result(result, output_json, label="Video+Audio (MMAudio)")
+    if download and result.get("status") == "completed":
+        download_outputs(result, download)

muapi/commands/auth.py

@@ -0,0 +1,193 @@
+"""muapi auth — configure API key and inspect identity."""
+import typer
+import httpx
+from rich.prompt import Prompt
+
+from ..config import delete_api_key, get_api_key, save_api_key, BASE_URL
+from .. import exitcodes
+from ..utils import console, error_exit, out
+
+app = typer.Typer(help="Manage authentication and API key.")
+
+# Auth endpoints live at the root host, not under /api/v1
+_AUTH_BASE = BASE_URL.replace("/api/v1", "")
+
+
+@app.command("login")
+def login(
+    email: str = typer.Option(..., "--email", "-e", help="Your muapi.ai email address"),
+    password: str = typer.Option(None, "--password", "-p", help="Password (will prompt if omitted)"),
+):
+    """Log in with email + password and save an API key automatically."""
+    if not password:
+        password = Prompt.ask("[bold]Password[/bold]", password=True, console=console)
+    if not password:
+        error_exit("Password is required.", exitcodes.AUTH_ERROR)
+
+    try:
+        resp = httpx.post(
+            f"{_AUTH_BASE}/api/auth/cli/login",
+            json={"email": email, "password": password, "username": ""},
+            timeout=30.0,
+        )
+    except httpx.RequestError as exc:
+        error_exit(f"Network error: {exc}", exitcodes.ERROR)
+
+    if resp.status_code == 401:
+        error_exit("Invalid email or password.", exitcodes.AUTH_ERROR)
+    if resp.status_code == 403:
+        error_exit("Email not verified. Check your inbox.", exitcodes.AUTH_ERROR)
+    if resp.status_code >= 400:
+        error_exit(f"Login failed: {resp.text}", exitcodes.AUTH_ERROR)
+
+    data = resp.json()
+    api_key = data.get("api_key", "")
+    if not api_key:
+        error_exit("No API key in response. Please try again.", exitcodes.AUTH_ERROR)
+
+    location = save_api_key(api_key)
+    console.print(f"[green]Logged in as {data.get('email', email)}. API key saved to {location}.[/green]")
+
+
+@app.command("register")
+def register(
+    email: str = typer.Option(..., "--email", "-e", help="Email address to register"),
+    password: str = typer.Option(None, "--password", "-p", help="Password (will prompt if omitted)"),
+    username: str = typer.Option("", "--username", "-u", help="Display name (optional)"),
+):
+    """Create a new muapi.ai account and verify via email OTP."""
+    if not password:
+        password = Prompt.ask("[bold]Choose a password[/bold]", password=True, console=console)
+        confirm = Prompt.ask("[bold]Confirm password[/bold]", password=True, console=console)
+        if password != confirm:
+            error_exit("Passwords do not match.", exitcodes.VALIDATION)
+    if not password:
+        error_exit("Password is required.", exitcodes.VALIDATION)
+
+    try:
+        resp = httpx.post(
+            f"{_AUTH_BASE}/api/auth/register",
+            json={"email": email, "password": password, "username": username or email.split("@")[0]},
+            timeout=30.0,
+        )
+    except httpx.RequestError as exc:
+        error_exit(f"Network error: {exc}", exitcodes.ERROR)
+
+    if resp.status_code == 400:
+        error_exit(f"Registration failed: {resp.json().get('detail', resp.text)}", exitcodes.VALIDATION)
+    if resp.status_code >= 400:
+        error_exit(f"Registration failed: {resp.text}", exitcodes.ERROR)
+
+    detail = resp.json().get("detail", "OTP sent to your email.")
+    console.print(f"[green]{detail}[/green]")
+    console.print("Check your inbox, then run: [bold]muapi auth verify --email {email} --otp <OTP>[/bold]")
+
+
+@app.command("verify")
+def verify(
+    email: str = typer.Option(..., "--email", "-e", help="Email address used during registration"),
+    otp: str = typer.Option(..., "--otp", "-o", help="OTP code from your email"),
+):
+    """Verify your email OTP after registration, then save an API key."""
+    try:
+        resp = httpx.post(
+            f"{_AUTH_BASE}/api/auth/verify-otp",
+            json={"email": email, "otp": otp},
+            timeout=30.0,
+        )
+    except httpx.RequestError as exc:
+        error_exit(f"Network error: {exc}", exitcodes.ERROR)
+
+    if resp.status_code == 401:
+        error_exit("Invalid or expired OTP.", exitcodes.AUTH_ERROR)
+    if resp.status_code >= 400:
+        error_exit(f"Verification failed: {resp.text}", exitcodes.AUTH_ERROR)
+
+    console.print("[green]Email verified! You can now log in.[/green]")
+    console.print(f"Run: [bold]muapi auth login --email {email}[/bold]")
+
+
+@app.command("forgot-password")
+def forgot_password(
+    email: str = typer.Option(..., "--email", "-e", help="Email address on your account"),
+):
+    """Send a password reset OTP to your email."""
+    try:
+        resp = httpx.post(
+            f"{_AUTH_BASE}/api/auth/forgot-password",
+            json={"email": email},
+            timeout=30.0,
+        )
+    except httpx.RequestError as exc:
+        error_exit(f"Network error: {exc}", exitcodes.ERROR)
+
+    if resp.status_code == 404:
+        error_exit("No account found for that email.", exitcodes.NOT_FOUND)
+    if resp.status_code >= 400:
+        error_exit(f"Request failed: {resp.text}", exitcodes.ERROR)
+
+    console.print(f"[green]{resp.json().get('detail', 'OTP sent to your email.')}[/green]")
+    console.print(f"Then run: [bold]muapi auth reset-password --email {email} --otp <OTP> --password <new>[/bold]")
+
+
+@app.command("reset-password")
+def reset_password(
+    email: str = typer.Option(..., "--email", "-e", help="Your email address"),
+    otp: str = typer.Option(..., "--otp", "-o", help="OTP from the reset email"),
+    password: str = typer.Option(None, "--password", "-p", help="New password (will prompt if omitted)"),
+):
+    """Reset your password using an OTP sent to your email."""
+    if not password:
+        password = Prompt.ask("[bold]New password[/bold]", password=True, console=console)
+        confirm = Prompt.ask("[bold]Confirm new password[/bold]", password=True, console=console)
+        if password != confirm:
+            error_exit("Passwords do not match.", exitcodes.VALIDATION)
+    if not password:
+        error_exit("Password is required.", exitcodes.VALIDATION)
+
+    try:
+        resp = httpx.post(
+            f"{_AUTH_BASE}/api/auth/reset-password",
+            json={"email": email, "otp": otp, "password": password},
+            timeout=30.0,
+        )
+    except httpx.RequestError as exc:
+        error_exit(f"Network error: {exc}", exitcodes.ERROR)
+
+    if resp.status_code == 401:
+        error_exit("Invalid or expired OTP.", exitcodes.AUTH_ERROR)
+    if resp.status_code >= 400:
+        error_exit(f"Request failed: {resp.text}", exitcodes.ERROR)
+
+    console.print(f"[green]{resp.json().get('detail', 'Password reset successfully.')}[/green]")
+    console.print(f"Run: [bold]muapi auth login --email {email}[/bold]")
+
+
+@app.command("configure")
+def configure(
+    api_key: str = typer.Option(None, "--api-key", "-k", help="API key (will prompt if omitted)"),
+):
+    """Save your muapi API key to the OS keychain (or config file)."""
+    if not api_key:
+        api_key = Prompt.ask("[bold]Enter your muapi API key[/bold]", password=True, console=console)
+    if not api_key:
+        error_exit("No API key provided.")
+    location = save_api_key(api_key.strip())
+    console.print(f"[green]API key saved to {location}.[/green]")
+
+
+@app.command("whoami")
+def whoami():
+    """Show the currently configured API key (masked)."""
+    key = get_api_key()
+    if not key:
+        error_exit("No API key configured. Run: muapi auth configure", exitcodes.AUTH_ERROR)
+    masked = key[:8] + "..." + key[-4:]
+    out.print(f"API key: [bold]{masked}[/bold]")
+
+
+@app.command("logout")
+def logout():
+    """Remove the stored API key."""
+    delete_api_key()
+    console.print("[green]API key removed.[/green]")

muapi/commands/config_cmd.py

@@ -0,0 +1,80 @@
+"""muapi config — get and set persistent CLI settings."""
+import json
+
+import typer
+
+from ..config import get_all_settings, get_setting, set_setting, _CONFIG_FILE
+from ..utils import console, out
+
+app = typer.Typer(help="Manage CLI configuration (default model, output format, etc.).")
+
+_KNOWN_KEYS = {
+    "output":        "Default output format: 'human' or 'json'",
+    "model.image":   "Default image generation model (e.g. flux-dev)",
+    "model.video":   "Default video generation model (e.g. kling-master)",
+    "model.audio":   "Default audio model (e.g. suno-create-music)",
+    "no_color":      "Disable colored output: 'true' or 'false'",
+    "poll_interval": "Seconds between result polls (default 3)",
+    "timeout":       "Max seconds to wait for results (default 600)",
+}
+
+
+@app.command("set")
+def config_set(
+    key: str = typer.Argument(..., help="Setting key (e.g. output, model.image)"),
+    value: str = typer.Argument(..., help="Value to assign"),
+):
+    """Set a persistent CLI configuration value.
+
+    Examples:
+
+    \\b
+    muapi config set output json
+    muapi config set model.image flux-schnell
+    muapi config set no_color true
+    """
+    set_setting(key, value)
+    console.print(f"[green]Set [bold]{key}[/bold] = {value}[/green]")
+
+
+@app.command("get")
+def config_get(
+    key: str = typer.Argument(..., help="Setting key to read"),
+    output_json: bool = typer.Option(False, "--output-json", "-j"),
+):
+    """Get the current value of a configuration key."""
+    value = get_setting(key)
+    if value is None:
+        console.print(f"[dim]{key} is not set[/dim]")
+        raise typer.Exit(0)
+    if output_json:
+        out.print_json(json.dumps({key: value}))
+    else:
+        console.print(f"[bold]{key}[/bold] = {value}")
+
+
+@app.command("list")
+def config_list(
+    output_json: bool = typer.Option(False, "--output-json", "-j"),
+):
+    """Show all configured settings."""
+    settings = get_all_settings()
+    if output_json:
+        out.print_json(json.dumps(settings))
+        return
+
+    if not settings:
+        console.print(f"[dim]No settings configured. Config file: {_CONFIG_FILE}[/dim]")
+        console.print("\nAvailable keys:")
+        for k, desc in _KNOWN_KEYS.items():
+            console.print(f"  [bold]{k}[/bold]  — {desc}")
+        return
+
+    from rich.table import Table
+    table = Table(show_header=True, header_style="bold")
+    table.add_column("Key")
+    table.add_column("Value")
+    for k, v in settings.items():
+        table.add_row(k, str(v))
+    console.print(table)
+    console.print(f"\n[dim]Config file: {_CONFIG_FILE}[/dim]")