muapi-cli 0.2.5__tar.gz → 0.2.7__tar.gz

{muapi_cli-0.2.5 → muapi_cli-0.2.7}/.github/workflows/release.yml

@@ -153,6 +153,8 @@ jobs:
     name: Publish to PyPI
     needs: build
     runs-on: ubuntu-latest
+    permissions:
+      id-token: write
     steps:
       - uses: actions/checkout@v4
 

{muapi_cli-0.2.5 → muapi_cli-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: muapi-cli
-Version: 0.2.5
+Version: 0.2.7
 Summary: Official CLI for muapi.ai — generative media at your fingertips
 License: MIT
 Requires-Python: >=3.9
@@ -22,6 +22,11 @@ Official command-line interface for [muapi.ai](https://muapi.ai) — generate im
 
 **Agent-first design** — every command works for both humans (colored output, tables) and AI agents (`--output-json`, `--jq` filtering, semantic exit codes, MCP server mode).
 
+## Related Projects
+
+- [Open-Generative-AI](https://github.com/Anil-matcha/Open-Generative-AI) — Browser-based GUI for the same models — no CLI required
+- [Awesome-GPT-Image-2-API-Prompts](https://github.com/Anil-matcha/Awesome-GPT-Image-2-API-Prompts) — Curated prompt library to run via this CLI
+
 ## Install
 
 ```bash

{muapi_cli-0.2.5 → muapi_cli-0.2.7}/README.md

@@ -4,6 +4,11 @@ Official command-line interface for [muapi.ai](https://muapi.ai) — generate im
 
 **Agent-first design** — every command works for both humans (colored output, tables) and AI agents (`--output-json`, `--jq` filtering, semantic exit codes, MCP server mode).
 
+## Related Projects
+
+- [Open-Generative-AI](https://github.com/Anil-matcha/Open-Generative-AI) — Browser-based GUI for the same models — no CLI required
+- [Awesome-GPT-Image-2-API-Prompts](https://github.com/Anil-matcha/Awesome-GPT-Image-2-API-Prompts) — Curated prompt library to run via this CLI
+
 ## Install
 
 ```bash

muapi_cli-0.2.7/integrations/langchain/examples/creative-agent/AGENTS.md

@@ -0,0 +1,37 @@
+# MuAPI Creative Agent
+
+You are a creative-media AI agent powered by [muapi.ai](https://muapi.ai) — a unified API for 390+ generative media models. You can create images, videos, audio, 3D assets, and apply effects, enhancements, and transformations.
+
+## Your Capabilities
+
+| Kind | What you can do |
+|------|----------------|
+| **Image** | Generate from text (Flux, HiDream, Midjourney, GPT-4o, DALL-E, Ideogram…) |
+| **Image edit** | Edit, inpaint, style transfer, background removal, upscale, colorize |
+| **Video** | Text-to-video (Veo 3, Kling, Sora, Seedance, Runway, Pika…) |
+| **Image-to-video** | Animate a still image |
+| **Video edit** | Effects, lipsync, face swap, dance, dress change |
+| **Audio** | Music generation (Suno), sound effects (MMAudio) |
+| **3D** | Image or text to 3D model (Tripo3D, Meshy) |
+
+## Tool Usage Guidelines
+
+Always follow this decision tree:
+
+1. **Don't know which model/skill fits?** → `muapi_select` first (free, instant)
+2. **Single asset, clear prompt?** → `muapi_generate` directly
+3. **Matches a named multi-step recipe?** → delegate to `creative-specialist` → `muapi_run_skill`
+4. **Open-ended multi-asset brief?** → delegate to `creative-specialist` → `muapi_creative_agent`
+
+## Quality Rules
+
+- Always call `muapi_select` before generating if the user hasn't specified a model — it surfaces the best fit for cost and quality
+- For edits and enhancements, pass `input_asset_url` to `muapi_generate`
+- The `tier` parameter controls quality vs. speed: `"best"` for hero assets, `"balanced"` for iterating, `"fast"` for previews
+- Report asset URLs to the user in every response — they're the deliverable
+
+## What to Avoid
+
+- Don't guess model names — use `muapi_select` to discover them
+- Don't call `muapi_creative_agent` without `interrupt_on` approval — it can spend many credits
+- Don't chain multiple `muapi_generate` calls when a skill covers the use case better

muapi_cli-0.2.7/integrations/langchain/examples/creative-agent/README.md

@@ -0,0 +1,81 @@
+# MuAPI Creative Agent
+
+A generative-media Deep Agent powered by [muapi.ai](https://muapi.ai) — 390+ models for images, video, audio, 3D, and more, exposed as LangChain tools and wired into a Deep Agent with a planner/specialist split.
+
+**This example demonstrates how to build a media-generation agent through three filesystem primitives:**
+- **Memory** (`AGENTS.md`) — persistent context: available models, decision tree, quality rules
+- **Skills** (`skills/*/SKILL.md`) — loaded-on-demand workflows for generation and named recipes
+- **Subagents** (`subagents.yaml`) — a `creative-specialist` for heavy multi-step work
+
+## Quick Start
+
+```bash
+# Set API keys
+export MUAPI_API_KEY="..."          # Get one at muapi.ai
+export ANTHROPIC_API_KEY="..."
+
+# Run (uv installs dependencies automatically)
+cd examples/creative-agent
+uv run python creative_agent.py "Generate a cinematic product photo of sneakers"
+
+# With a budget cap
+uv run python creative_agent.py --budget 200 "Animate my product image into a 5s video"
+
+# Multi-step recipe
+uv run python creative_agent.py "Make a 3-shot Instagram carousel for SunFizz mango water"
+```
+
+## How It Works
+
+```
+User brief
+  │
+  ├─ AGENTS.md          Loaded at startup — tells the agent what muapi can do
+  ├─ skills/            Loaded on demand — step-by-step tool usage guides
+  │
+  ▼
+Planner (Claude Sonnet)
+  ├─ muapi_select       Discover best model/skill for the brief (free)
+  ├─ muapi_generate     Single-shot generation: image / video / audio / 3D
+  │
+  └─ task ──────────────► creative-specialist subagent
+                              ├─ muapi_run_skill     Named multi-step recipe
+                              └─ muapi_creative_agent  Open-ended brief (HITL-gated)
+```
+
+`MuapiCostCallback` tracks credit spend in real time and aborts the run if the budget cap is hit.
+
+## Tool Capability Gradient
+
+| Tool | Tier | What it does | Credits |
+|------|------|-------------|---------|
+| `muapi_select` | Planner | Rank models + skills for an intent | Free |
+| `muapi_generate` | Planner | Generate one asset (any modality) | Per call |
+| `muapi_run_skill` | Specialist | Run a named multi-step recipe | Per recipe |
+| `muapi_creative_agent` | Specialist | Hand a full brief to muapi's planner (HITL-gated) | Variable |
+
+## File Structure
+
+```
+creative-agent/
+├── AGENTS.md                     # Persistent agent context
+├── creative_agent.py             # Main entry point
+├── subagents.yaml                # creative-specialist definition
+├── pyproject.toml
+└── skills/
+    ├── generate-asset/SKILL.md   # Single-asset generation workflow
+    └── run-skill/SKILL.md        # Named recipe delegation workflow
+```
+
+## Environment Variables
+
+| Variable | Required | Notes |
+|----------|----------|-------|
+| `MUAPI_API_KEY` | Yes | Get at [muapi.ai](https://muapi.ai) or run `muapi auth configure` |
+| `ANTHROPIC_API_KEY` | Yes | Powers the planner (Claude Sonnet) |
+
+## Related
+
+- [muapi-langchain on PyPI](https://pypi.org/project/muapi-langchain/)
+- [muapi.ai](https://muapi.ai) — API docs and model catalog
+- [muapi CLI](https://github.com/SamurAIGPT/muapi-cli) — same auth, same client

muapi_cli-0.2.7/integrations/langchain/examples/creative-agent/creative_agent.py

@@ -0,0 +1,203 @@
+#!/usr/bin/env python3
+"""
+MuAPI Creative Agent
+
+A generative-media Deep Agent configured through filesystem primitives:
+  - AGENTS.md          — persistent context: capabilities, decision tree, quality rules
+  - skills/            — loaded-on-demand workflows (generate-asset, run-skill)
+  - subagents.yaml     — creative-specialist subagent for heavy multi-step work
+  - MuapiCostCallback  — real-time credit tracking with optional budget cap
+
+Usage:
+    export MUAPI_API_KEY="..."             # or: muapi auth configure
+    export ANTHROPIC_API_KEY="..."
+    uv run python creative_agent.py "Generate a cinematic product photo of a sneaker"
+    uv run python creative_agent.py "Make a 3-shot Instagram carousel for SunFizz mango water"
+    uv run python creative_agent.py --budget 200 "Animate my logo"
+"""
+from __future__ import annotations
+
+import asyncio
+import sys
+from pathlib import Path
+from typing import Any
+
+import yaml
+from langchain_anthropic import ChatAnthropic
+from langchain_core.messages import AIMessage, HumanMessage, ToolMessage
+from rich.console import Console
+from rich.live import Live
+from rich.markdown import Markdown
+from rich.panel import Panel
+from rich.spinner import Spinner
+
+from deepagents import create_deep_agent
+from muapi_langchain import (
+    PLANNER_TOOLS,
+    SPECIALIST_TOOLS,
+    MuapiCostCallback,
+)
+
+EXAMPLE_DIR = Path(__file__).parent
+console = Console()
+
+
+def load_subagents(config_path: Path) -> list[dict]:
+    """Load subagent definitions from YAML and wire up muapi specialist tools."""
+    tool_map = {t.name: t for t in SPECIALIST_TOOLS}
+
+    with open(config_path) as f:
+        config = yaml.safe_load(f)
+
+    subagents = []
+    for name, spec in config.items():
+        subagent: dict[str, Any] = {
+            "name": name,
+            "description": spec["description"],
+            "system_prompt": spec["system_prompt"],
+        }
+        if "model" in spec:
+            subagent["model"] = spec["model"]
+        if "tools" in spec:
+            subagent["tools"] = [tool_map[t] for t in spec["tools"] if t in tool_map]
+        subagents.append(subagent)
+    return subagents
+
+
+def create_creative_agent(budget_credits: int = 500):
+    cost_cb = MuapiCostCallback(
+        budget_credits=budget_credits,
+        on_event=lambda evt, payload: console.print(
+            f"  [dim][{evt}] credits: {payload.get('credits', 0)} "
+            f"(total: {payload.get('running_total', 0)})[/]"
+        ),
+    )
+    agent = create_deep_agent(
+        model=ChatAnthropic(model="claude-sonnet-4-6"),
+        memory=[str(EXAMPLE_DIR / "AGENTS.md")],
+        skills=[str(EXAMPLE_DIR / "skills/")],
+        tools=PLANNER_TOOLS,
+        subagents=load_subagents(EXAMPLE_DIR / "subagents.yaml"),
+        interrupt_on={
+            "muapi_creative_agent": {"allowed_decisions": ["approve", "edit", "reject"]},
+        },
+    )
+    return agent, cost_cb
+
+
+class AgentDisplay:
+    def __init__(self):
+        self.printed_count = 0
+        self._spinner = Spinner("dots", text="Thinking…")
+
+    def spinner(self, text: str = "Thinking…") -> Spinner:
+        self._spinner = Spinner("dots", text=text)
+        return self._spinner
+
+    def render(self, msg: Any) -> None:
+        if isinstance(msg, HumanMessage):
+            console.print(Panel(str(msg.content), title="You", border_style="blue"))
+
+        elif isinstance(msg, AIMessage):
+            content = msg.content
+            if isinstance(content, list):
+                content = "\n".join(
+                    p.get("text", "") for p in content
+                    if isinstance(p, dict) and p.get("type") == "text"
+                )
+            if content and content.strip():
+                console.print(Panel(Markdown(content), title="Agent", border_style="green"))
+
+            for tc in (msg.tool_calls or []):
+                name = tc.get("name", "")
+                args = tc.get("args", {})
+                if name == "muapi_select":
+                    console.print(f"  [bold cyan]→ Discovering models for:[/] {args.get('intent', '')[:60]}")
+                    self.spinner("Discovering models…")
+                elif name == "muapi_generate":
+                    console.print(f"  [bold magenta]→ Generating {args.get('kind', 'asset')}:[/] {args.get('prompt', '')[:60]}")
+                    self.spinner("Generating…")
+                elif name == "task":
+                    desc = args.get("description", "")
+                    console.print(f"  [bold yellow]→ Delegating:[/] {desc[:70]}")
+                    self.spinner("Delegating to specialist…")
+
+        elif isinstance(msg, ToolMessage):
+            name = getattr(msg, "name", "")
+            content = str(msg.content)
+            if name == "muapi_generate":
+                if '"ok": true' in content or '"url":' in content:
+                    import json
+                    try:
+                        data = json.loads(content)
+                        url = data.get("url", "")
+                        console.print(f"  [green]✓ Generated:[/] {url}")
+                    except Exception:
+                        console.print(f"  [green]✓ Generated[/]")
+                else:
+                    console.print(f"  [red]✗ Generation failed[/]")
+            elif name == "muapi_select":
+                console.print(f"  [green]✓ Models discovered[/]")
+            elif name == "task":
+                console.print(f"  [green]✓ Specialist done[/]")
+
+
+async def run(brief: str, budget_credits: int = 500) -> None:
+    agent, cost_cb = create_creative_agent(budget_credits)
+    display = AgentDisplay()
+
+    console.print()
+    console.print("[bold blue]MuAPI Creative Agent[/]")
+    console.print(f"[dim]Brief: {brief}[/]")
+    console.print(f"[dim]Budget: {budget_credits} credits[/]")
+    console.print()
+
+    config = {"configurable": {"thread_id": "creative-agent-demo"}, "callbacks": [cost_cb]}
+
+    with Live(display.spinner(), console=console, refresh_per_second=10, transient=True) as live:
+        async for chunk in agent.astream(
+            {"messages": [("user", brief)]},
+            config=config,
+            stream_mode="values",
+        ):
+            if "messages" not in chunk:
+                continue
+            messages = chunk["messages"]
+            if len(messages) <= display.printed_count:
+                continue
+            live.stop()
+            for msg in messages[display.printed_count:]:
+                display.render(msg)
+            display.printed_count = len(messages)
+            live.start()
+            live.update(display.spinner())
+
+    summary = cost_cb.summary()
+    console.print()
+    console.print(
+        f"[bold green]✓ Done[/] — "
+        f"[dim]{summary['total_credits']} credits across {summary['calls']} calls[/]"
+    )
+
+
+def main() -> None:
+    import argparse
+
+    parser = argparse.ArgumentParser(description="MuAPI Creative Agent")
+    parser.add_argument("brief", nargs="*", help="Creative brief (or omit for demo)")
+    parser.add_argument("--budget", type=int, default=500, help="Credit budget cap (default 500)")
+    args = parser.parse_args()
+
+    brief = " ".join(args.brief) if args.brief else (
+        "Generate a cinematic product photo of a pair of minimalist white sneakers "
+        "on a wet cobblestone street at night, neon reflections"
+    )
+
+    try:
+        asyncio.run(run(brief, budget_credits=args.budget))
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Interrupted[/]")
+
+
+if __name__ == "__main__":
+    main()

muapi_cli-0.2.7/integrations/langchain/examples/creative-agent/pyproject.toml

@@ -0,0 +1,15 @@
+[project]
+name = "muapi-creative-agent"
+version = "0.1.0"
+description = "A generative-media Deep Agent powered by muapi.ai"
+requires-python = ">=3.11"
+dependencies = [
+    "deepagents>=0.3.5",
+    "muapi-langchain>=0.1.0",
+    "langchain-anthropic>=0.3.0",
+    "pyyaml>=6.0.0",
+    "rich>=13.0.0",
+]
+
+[dependency-groups]
+dev = []

muapi_cli-0.2.7/integrations/langchain/examples/creative-agent/skills/generate-asset/SKILL.md

@@ -0,0 +1,37 @@
+---
+name: generate-asset
+description: Generate a single media asset — image, video, audio, or 3D. Use when the user wants one output from a clear prompt. Calls muapi_select to pick the best model, then muapi_generate.
+---
+
+# Generate Asset
+
+Use this skill for single-asset generation tasks.
+
+## Step 1 — Discover
+
+Call `muapi_select` with the user's intent and kind:
+
+```
+muapi_select(intent="<user's prompt>", kind="<image|video|audio|3d>", tier="<best|balanced|fast>", limit=3)
+```
+
+Pick the top-ranked model from the result.
+
+## Step 2 — Generate
+
+Call `muapi_generate` with the chosen model:
+
+```
+muapi_generate(
+    prompt="<refined prompt>",
+    kind="<kind>",
+    model="<name from muapi_select>",
+    tier="<best|balanced|fast>",
+)
+```
+
+For edits, enhancements, image-to-video, or lipsync — pass `input_asset_url` too.
+
+## Step 3 — Return
+
+Report the asset URL to the user. Include: model used, kind, and any relevant parameters.

muapi_cli-0.2.7/integrations/langchain/examples/creative-agent/skills/run-skill/SKILL.md

@@ -0,0 +1,30 @@
+---
+name: run-skill
+description: Run a named muapi multi-step recipe (UGC ad, storyboard, brand kit, product video, social carousel…). Use when the brief matches a known workflow. Delegates to the creative-specialist subagent.
+---
+
+# Run Named Skill
+
+Use this skill when the user's brief matches a known multi-step recipe.
+
+## Step 1 — Discover skills
+
+Call `muapi_select` with the user's intent. The result includes a `skills` list — check if any skill name matches the brief:
+
+```
+muapi_select(intent="<user's brief>", limit=5)
+```
+
+If a skill name matches (e.g., "ugc-ads-workflow", "storyboard", "brand-kit"), use it.
+
+## Step 2 — Delegate to creative-specialist
+
+Delegate to the `creative-specialist` subagent with:
+- The matching skill name
+- The user's inputs (from the skill's declared `inputs` schema)
+
+The specialist will call `muapi_run_skill(skill_name=..., inputs={...})`.
+
+## Step 3 — Return
+
+Collect all asset URLs from the specialist and return them with a brief summary of what was created.

muapi_cli-0.2.7/integrations/langchain/examples/creative-agent/subagents.yaml

@@ -0,0 +1,28 @@
+# Subagent definitions for the muapi creative agent
+
+creative-specialist:
+  description: >
+    Handles heavy muapi workflows: named multi-step skills (UGC ads, storyboards,
+    product videos, brand kits, social carousels) and open-ended multi-asset briefs.
+    Delegate here when the brief needs more than one generation call or matches a
+    named recipe discovered via muapi_select.
+  system_prompt: |
+    You are a muapi creative specialist with access to muapi_run_skill and muapi_creative_agent.
+
+    ## Decision rule
+    - If the brief matches a named skill from muapi_select → use muapi_run_skill
+    - If it's an open-ended multi-asset brief with no matching skill → use muapi_creative_agent
+
+    ## muapi_run_skill usage
+    muapi_run_skill(skill_name="<name>", inputs={"key": "value", ...})
+    Inputs must match the skill's declared schema (get it from muapi_select).
+
+    ## muapi_creative_agent usage
+    muapi_creative_agent(brief="<full description>", budget_credits=<int>)
+    Use only when explicitly approved by the user (this can spend significant credits).
+
+    ## Output
+    Always return all asset URLs with a one-line description of each.
+  tools:
+    - muapi_run_skill
+    - muapi_creative_agent

muapi_cli-0.2.7/muapi/__init__.py

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

{muapi_cli-0.2.5 → muapi_cli-0.2.7}/muapi/commands/auth.py

@@ -1,16 +1,121 @@
 """muapi auth — configure API key and inspect identity."""
-import typer
+import os
+import re
+import subprocess
+import sys
+import webbrowser
+
 import httpx
-from rich.prompt import Prompt
+import typer
+from rich.prompt import Confirm, Prompt
 
-from ..config import delete_api_key, get_api_key, save_api_key, BASE_URL
+from ..config import BASE_URL, _CONFIG_FILE, delete_api_key, get_api_key, get_key_info, save_api_key
 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", "")
+_ACCESS_KEYS_URL = "https://muapi.ai/access-keys"
+
+LINKS = {
+    "dashboard":   "https://muapi.ai/dashboard",
+    "access-keys": _ACCESS_KEYS_URL,
+    "models":      "https://muapi.ai/models",
+    "docs":        "https://muapi.ai/docs",
+    "pricing":     "https://muapi.ai/pricing",
+}
+
+
+def _mask(key: str) -> str:
+    if len(key) < 12:
+        return "••••"
+    return key[:8] + "…" + key[-4:]
+
+
+def _looks_like_key(s: str) -> bool:
+    s = s.strip()
+    return bool(re.match(r'^[A-Za-z0-9_\-]{20,}$', s) and '\n' not in s)
+
+
+def _read_clipboard() -> str | None:
+    try:
+        if sys.platform == "darwin":
+            r = subprocess.run(["pbpaste"], capture_output=True, text=True, timeout=2)
+            return r.stdout.strip() or None
+        if sys.platform.startswith("linux"):
+            for cmd in (["xclip", "-o"], ["xsel", "--clipboard", "--output"]):
+                try:
+                    r = subprocess.run(cmd, capture_output=True, text=True, timeout=2)
+                    if r.returncode == 0:
+                        return r.stdout.strip() or None
+                except FileNotFoundError:
+                    continue
+        if sys.platform == "win32":
+            r = subprocess.run(
+                ["powershell", "-command", "Get-Clipboard"],
+                capture_output=True, text=True, timeout=2,
+            )
+            return r.stdout.strip() or None
+    except Exception:
+        pass
+    return None
+
+
+def _validate_key(api_key: str) -> tuple[bool, str]:
+    """Validate key against the live API. Returns (ok, error_msg)."""
+    try:
+        resp = httpx.get(
+            f"{BASE_URL}/account/balance",
+            headers={"x-api-key": api_key},
+            timeout=15.0,
+        )
+        if resp.status_code in (401, 403):
+            return False, "API rejected the key (401/403)."
+        if resp.status_code >= 400:
+            return False, f"API returned {resp.status_code}."
+        return True, ""
+    except httpx.RequestError as e:
+        return False, f"Could not reach {BASE_URL}: {e}"
+
+
+def _find_project_config() -> str | None:
+    """Walk up from CWD looking for muapi.json."""
+    from pathlib import Path
+    d = Path.cwd()
+    while True:
+        candidate = d / "muapi.json"
+        if candidate.exists():
+            return str(candidate)
+        parent = d.parent
+        if parent == d:
+            return None
+        d = parent
+
+
+def _do_save(api_key: str) -> None:
+    with console.status("[dim]Validating with api.muapi.ai…[/dim]"):
+        ok, reason = _validate_key(api_key)
+
+    if not ok:
+        console.print(f"[bold red]✖[/bold red] {reason}")
+        console.print()
+        console.print(f"[dim]  Double-check at [/dim][cyan]{_ACCESS_KEYS_URL}[/cyan]")
+        console.print("[dim]  Or set [/dim][cyan]MUAPI_API_KEY[/cyan][dim] in your shell and skip this step.[/dim]\n")
+        raise typer.Exit(exitcodes.AUTH_ERROR)
+
+    location = save_api_key(api_key)
+    location_display = "OS keychain" if location == "keychain" else str(_CONFIG_FILE)
+    console.print("[bold green]✔[/bold green] Signed in.")
+    console.print()
+    console.print(f"  [dim]Key:    [/dim][green]{_mask(api_key)}[/green]")
+    console.print(f"  [dim]Stored: [/dim][cyan]{location_display}[/cyan]")
+    console.print()
+    console.print("[bold]Try it:[/bold]")
+    console.print("  [cyan]muapi account balance[/cyan]")
+    console.print("  [cyan]muapi image generate -p \"a cyberpunk skyline at golden hour\"[/cyan]")
+    console.print("  [cyan]muapi video generate -p \"drone shot over snowy peaks\" --model kling-master[/cyan]")
+    console.print()
 
 
 @app.command("login")
@@ -165,25 +270,85 @@ def reset_password(
 
 @app.command("configure")
 def configure(
-    api_key: str = typer.Option(None, "--api-key", "-k", help="API key (will prompt if omitted)"),
+    api_key: str = typer.Option(None, "--api-key", "-k", help="API key (skips all prompts)"),
+    no_browser: bool = typer.Option(False, "--no-browser", help="Skip opening the access-keys page"),
 ):
-    """Save your muapi API key to the OS keychain (or config file)."""
+    """Save your muapi API key — opens browser, detects clipboard, validates before saving."""
+    if api_key:
+        _do_save(api_key.strip())
+        return
+
+    console.print()
+    console.print("[bold magenta]  Welcome to muapi.[/bold magenta]")
+    console.print("[dim]  Sign in once and you're set on this machine.[/dim]\n")
+
+    if not no_browser:
+        console.print(f"[bold]  1.[/bold] Opening [cyan]{_ACCESS_KEYS_URL}[/cyan]")
+        try:
+            webbrowser.open(_ACCESS_KEYS_URL)
+        except Exception:
+            console.print("[dim]     (browser launch failed — open the link manually)[/dim]")
+        console.print("[bold]  2.[/bold] Copy your API key")
+        console.print("[bold]  3.[/bold] Paste below — we'll validate it automatically\n")
+
+    # Clipboard detection
+    detected: str | None = None
+    clip = _read_clipboard()
+    if clip and _looks_like_key(clip):
+        detected = clip
+
+    if detected:
+        use_it = Confirm.ask(
+            f"  Detected a key on your clipboard ({_mask(detected)}). Use it?",
+            default=True,
+            console=console,
+        )
+        if use_it:
+            api_key = detected
+
     if not api_key:
-        api_key = Prompt.ask("[bold]Enter your muapi API key[/bold]", password=True, console=console)
+        api_key = Prompt.ask("[bold]  Paste your API key[/bold]", password=True, console=console)
+        api_key = api_key.strip()
+
     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]")
+        error_exit("No API key provided.", exitcodes.AUTH_ERROR)
+
+    _do_save(api_key)
+
+
+@app.command("status")
+def status():
+    """Show the active API key, config location, base URL, and quick links."""
+    key, source = get_key_info()
+
+    console.print()
+    console.print("[bold]muapi CLI status[/bold]")
+    if key:
+        console.print(f"  [dim]API key:  [/dim][green]{_mask(key)}[/green]")
+    else:
+        console.print(f"  [dim]API key:  [/dim][red]not set — run [bold]muapi auth configure[/bold][/red]")
+    console.print(f"  [dim]Source:   [/dim][cyan]{source}[/cyan]")
+    console.print(f"  [dim]Base URL: [/dim][cyan]{BASE_URL}[/cyan]")
+    console.print(f"  [dim]Config:   [/dim][cyan]{_CONFIG_FILE}[/cyan]")
+
+    project_file = _find_project_config()
+    if project_file:
+        console.print(f"  [dim]Project:  [/dim][cyan]{project_file}[/cyan] [dim](muapi.json detected)[/dim]")
+
+    console.print()
+    console.print("[bold]Useful links[/bold]")
+    width = max(len(k) for k in LINKS)
+    for name, url in LINKS.items():
+        console.print(f"  [dim]{name.ljust(width)}[/dim]  [cyan]{url}[/cyan]")
+    console.print()
+    console.print("[dim]Jump in your browser: [/dim][cyan]muapi open <target>[/cyan]")
+    console.print()
 
 
 @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]")
+    """Alias for [bold]muapi auth status[/bold]."""
+    status()
 
 
 @app.command("logout")

muapi_cli-0.2.7/muapi/commands/init_cmd.py

@@ -0,0 +1,62 @@
+"""muapi init — create a muapi.json project config in the current directory."""
+import json
+from pathlib import Path
+
+import typer
+
+from ..utils import console, error_exit
+
+_PROJECT_FILE = "muapi.json"
+_SCHEMA_URL = "https://muapi.ai/schema/cli.json"
+
+_DEFAULT_CONFIG = {
+    "$schema": _SCHEMA_URL,
+    "defaultModel": "flux-dev-image",
+    "outputDir": "muapi-output",
+    "aliases": {},
+}
+
+
+def init(
+    yes: bool = typer.Option(False, "-y", "--yes", help="Skip prompts and write defaults"),
+    force: bool = typer.Option(False, "-f", "--force", help="Overwrite an existing muapi.json"),
+):
+    """Create a muapi.json project config with a defaultModel and alias stubs.
+
+    \b
+    Examples:
+      muapi init            # interactive
+      muapi init -y         # write defaults silently
+      muapi init -y -f      # overwrite existing
+    """
+    target = Path.cwd() / _PROJECT_FILE
+
+    if target.exists() and not force:
+        error_exit(
+            f"{_PROJECT_FILE} already exists. Use --force to overwrite.",
+        )
+
+    config = dict(_DEFAULT_CONFIG)
+
+    if not yes:
+        from rich.prompt import Prompt
+        default_model = Prompt.ask(
+            "Default model",
+            default=config["defaultModel"],
+            console=console,
+        )
+        output_dir = Prompt.ask(
+            "Output directory",
+            default=config["outputDir"],
+            console=console,
+        )
+        config["defaultModel"] = default_model
+        config["outputDir"] = output_dir
+
+    target.write_text(json.dumps(config, indent=2) + "\n")
+    console.print(f"[green]Wrote {_PROJECT_FILE}[/green]")
+    console.print()
+    console.print("Now try:")
+    console.print(f"  [cyan]muapi run -p \"a serene mountain lake at sunrise\"[/cyan]")
+    console.print(f"  Add aliases by editing [bold]{_PROJECT_FILE}[/bold]")
+    console.print()

{muapi_cli-0.2.5 → muapi_cli-0.2.7}/muapi/commands/mcp_server.py

@@ -15,7 +15,7 @@ from typing import Any
 
 import typer
 
-from .. import client as api_client
+from .. import __version__, client as api_client
 from ..config import get_api_key
 
 app = typer.Typer(help="Run muapi as an MCP server for AI agent integration.")
@@ -360,15 +360,20 @@ TOOLS = [
         "annotations": {"readOnlyHint": True, "idempotentHint": True},
         "inputSchema": {"type": "object", "properties": {}},
         "outputSchema": {
-            "type": "array",
-            "items": {
-                "type": "object",
-                "properties": {
-                    "id":           {"type": "integer"},
-                    "name":         {"type": "string"},
-                    "is_active":    {"type": "boolean"},
-                    "created_at":   {"type": "string"},
-                    "last_used_at": {"type": "string"},
+            "type": "object",
+            "properties": {
+                "keys": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "id":           {"type": "integer"},
+                            "name":         {"type": "string"},
+                            "is_active":    {"type": "boolean"},
+                            "created_at":   {"type": "string"},
+                            "last_used_at": {"type": "string"},
+                        },
+                    },
                 },
             },
         },
@@ -418,7 +423,12 @@ TOOLS = [
         "endpoint": None,
         "annotations": {"readOnlyHint": True, "idempotentHint": True},
         "inputSchema": {"type": "object", "properties": {}},
-        "outputSchema": {"type": "array"},
+        "outputSchema": {
+            "type": "object",
+            "properties": {
+                "workflows": {"type": "array"},
+            },
+        },
     },
     {
         "name": "muapi_workflow_create",
@@ -658,7 +668,7 @@ def _dispatch(tool_name: str, args: dict) -> dict:
         resp = _httpx.get(f"{wf_base}/get-workflow-defs", headers={"x-api-key": key}, timeout=30.0)
         if resp.status_code >= 400:
             raise api_client.MuapiError(resp.text, resp.status_code)
-        return resp.json()
+        return {"workflows": resp.json()}
 
     if tool_name == "muapi_workflow_create":
         from ..config import BASE_URL, get_api_key
@@ -732,7 +742,7 @@ def _dispatch(tool_name: str, args: dict) -> dict:
         resp = _httpx.get(f"{BASE_URL}/keys", headers={"x-api-key": key}, timeout=30.0)
         if resp.status_code >= 400:
             raise api_client.MuapiError(resp.text, resp.status_code)
-        return resp.json()
+        return {"keys": resp.json()}
 
     if tool_name == "muapi_keys_create":
         from ..config import BASE_URL, get_api_key
@@ -821,7 +831,7 @@ def _handle_request(request: dict) -> str:
         return _mcp_response(req_id, {
             "protocolVersion": "2025-06-18",
             "capabilities": {"tools": {"listChanged": False}},
-            "serverInfo": {"name": "muapi", "version": "0.1.0"},
+            "serverInfo": {"name": "muapi", "version": __version__},
         })
 
     if method == "tools/list":
@@ -884,7 +894,7 @@ def serve(
         )
         sys.exit(3)
 
-    sys.stderr.write(json.dumps({"status": "muapi MCP server ready", "tools": len(TOOLS), "version": "0.1.0"}) + "\n")
+    sys.stderr.write(json.dumps({"status": "muapi MCP server ready", "tools": len(TOOLS), "version": __version__}) + "\n")
     sys.stderr.flush()
 
     for line in sys.stdin:

muapi_cli-0.2.7/muapi/commands/open_cmd.py

@@ -0,0 +1,47 @@
+"""muapi open — open muapi.ai pages in your browser."""
+import webbrowser
+from typing import Optional
+
+import typer
+
+from ..utils import console, error_exit
+
+_TARGETS: dict[str, str] = {
+    "dashboard":   "https://muapi.ai/dashboard",
+    "access-keys": "https://muapi.ai/access-keys",
+    "models":      "https://muapi.ai/models",
+    "docs":        "https://muapi.ai/docs",
+    "pricing":     "https://muapi.ai/pricing",
+    "api":         "https://api.muapi.ai/docs",
+    "discord":     "https://discord.gg/muapi",
+}
+
+
+def open_page(
+    target: Optional[str] = typer.Argument(
+        None,
+        help="Page to open: " + ", ".join(_TARGETS.keys()),
+    ),
+):
+    """Open a muapi.ai page in your browser.
+
+    \b
+    Examples:
+      muapi open               # opens dashboard
+      muapi open access-keys   # key management
+      muapi open models        # model catalog
+      muapi open docs          # API docs
+    """
+    if not target:
+        target = "dashboard"
+
+    url = _TARGETS.get(target.lower())
+    if not url:
+        valid = ", ".join(_TARGETS.keys())
+        error_exit(f"Unknown target '{target}'. Valid: {valid}")
+
+    console.print(f"Opening [cyan]{url}[/cyan]")
+    try:
+        webbrowser.open(url)
+    except Exception as e:
+        error_exit(f"Could not open browser: {e}")

{muapi_cli-0.2.5 → muapi_cli-0.2.7}/muapi/config.py

@@ -96,6 +96,23 @@ def get_all_settings() -> dict:
     return {}
 
 
+def get_key_info() -> tuple[Optional[str], str]:
+    """Return (api_key, source_description) for display in status/whoami."""
+    if key := os.environ.get("MUAPI_API_KEY"):
+        return key, "env:MUAPI_API_KEY"
+    ok, val = _try_keyring()
+    if ok and val:
+        return val, "keychain"
+    if _CONFIG_FILE.exists():
+        try:
+            data = json.loads(_CONFIG_FILE.read_text())
+            if key := data.get("api_key"):
+                return key, f"file:{_CONFIG_FILE}"
+        except Exception:
+            pass
+    return None, "not set"
+
+
 def delete_api_key() -> None:
     ok, _ = _try_keyring()
     if ok:

{muapi_cli-0.2.5 → muapi_cli-0.2.7}/muapi/main.py

@@ -5,7 +5,7 @@ import typer
 from rich import print as rprint
 
 from . import __version__
-from .commands import auth, account, audio, config_cmd, docs, edit, enhance, image, keys, models, predict, run, upload, video, workflow
+from .commands import auth, account, audio, config_cmd, docs, edit, enhance, image, init_cmd, keys, models, open_cmd, predict, run, upload, video, workflow
 from .commands import mcp_server
 from .dynamic_help import maybe_handle_run_help
 
@@ -44,6 +44,18 @@ app.add_typer(config_cmd.app,  name="config",  help="Get and set persistent CLI
 app.add_typer(docs.app,        name="docs",    help="Access the muapi.ai API documentation.")
 app.add_typer(mcp_server.app,  name="mcp",     help="Run as an MCP server for AI agent integration.")
 
+app.command(
+    "init",
+    help="Create a muapi.json project config with defaultModel and alias stubs.",
+    context_settings={"help_option_names": ["-h", "--help"]},
+)(init_cmd.init)
+
+app.command(
+    "open",
+    help="Open a muapi.ai page in your browser (dashboard, models, docs, access-keys…).",
+    context_settings={"help_option_names": ["-h", "--help"]},
+)(open_cmd.open_page)
+
 
 @app.command("version")
 def version(

{muapi_cli-0.2.5 → muapi_cli-0.2.7}/npm/package.json

@@ -1,6 +1,6 @@
 {
   "name": "muapi-cli",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "description": "Official CLI for muapi.ai \u2014 generate images, videos, and audio from your terminal",
   "keywords": [
     "muapi",

{muapi_cli-0.2.5 → muapi_cli-0.2.7}/npm/scripts/install.js

@@ -22,7 +22,8 @@ const NAME_MAP = {
 };
 
 const key     = `${process.platform}-${process.arch}`;
-const binName = NAME_MAP[key];
+// On Apple Silicon, Node may report x64 when running under Rosetta — fall back to arm64.
+const binName = NAME_MAP[key] || (process.platform === "darwin" ? NAME_MAP["darwin-arm64"] : undefined);
 
 if (!binName) {
   console.warn(`[muapi] Unsupported platform: ${key}. Install via pip: pip install muapi-cli`);

{muapi_cli-0.2.5 → muapi_cli-0.2.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "muapi-cli"
-version = "0.2.5"
+version = "0.2.7"
 description = "Official CLI for muapi.ai — generative media at your fingertips"
 readme = "README.md"
 requires-python = ">=3.9"

muapi_cli-0.2.5/.claude/settings.local.json

@@ -1,24 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(gh issue *)",
-      "Bash(curl -sI \"https://github.com/Anil-matcha/muapiapp/releases/download/v0.2.3/muapi-linux-x86_64\")",
-      "Bash(curl -sI \"https://github.com/SamurAIGPT/muapi-cli/releases/download/v0.2.3/muapi-linux-x86_64\")",
-      "Bash(gh release *)",
-      "Bash(npm view *)",
-      "Bash(git -C /Users/anilchandranaidumatcha/Downloads/mu_workflow/muapi-cli status)",
-      "Bash(git -C /Users/anilchandranaidumatcha/Downloads/mu_workflow/muapi-cli remote -v)",
-      "Bash(gh auth *)",
-      "Bash(npm whoami *)",
-      "Bash(git *)",
-      "Bash(tar -xzf muapi-cli-0.2.5.tgz)",
-      "Bash(tar -xzf muapi-cli-0.2.3.tgz)",
-      "Bash(tar -xzf muapi-cli-0.2.4.tgz)",
-      "Bash(rm -rf /tmp/muapi-022-check)",
-      "Bash(mkdir /tmp/muapi-022-check)",
-      "Read(//tmp/**)",
-      "Bash(npm pack *)",
-      "Bash(tar -xzf muapi-cli-0.2.2.tgz)"
-    ]
-  }
-}

muapi_cli-0.2.5/muapi/__init__.py

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