ondaru 0.1.0__py3-none-any.whl

ondaru/__init__.py

@@ -0,0 +1,3 @@
+"""Ondaru — agent-ordered 3D product mockups, served as an A2MCP service."""
+
+__version__ = "0.1.0"

ondaru/cli/__init__.py

@@ -0,0 +1 @@
+"""The human-facing command line."""

ondaru/cli/main.py

@@ -0,0 +1,593 @@
+"""The human-facing command line.
+
+Two jobs: install Ondaru into someone else's agent, and exercise a live
+service from a terminal. The install commands are the distribution mechanism —
+an ASP nobody's agent knows to call is an ASP nobody calls.
+
+Every install is idempotent. A second run must not duplicate a server entry or
+half-overwrite a skill.
+"""
+
+from __future__ import annotations
+
+import json
+import shutil
+from pathlib import Path
+from typing import Annotated, Any
+
+import httpx
+import questionary
+import typer
+from rich.console import Console
+from rich.table import Table
+
+app = typer.Typer(
+    name="ondaru",
+    help="3D product mockups your agent can order.",
+    invoke_without_command=True,
+    add_completion=False,
+)
+console = Console()
+
+# Shown when someone runs `ondaru` with nothing after it. A person who typed the
+# name and pressed enter is asking what this is, not reading a flag list.
+#
+# ANSI Shadow at 52 columns, plus a wireframe cube for the thing being sold.
+# Together they need 68, which fits the 80-column terminal that still decides
+# what "fits" means. Narrower than that and the wordmark wraps into noise, so
+# there is a plain fallback.
+WORDMARK = (
+    " ██████╗ ███╗   ██╗██████╗  █████╗ ██████╗ ██╗   ██╗",
+    "██╔═══██╗████╗  ██║██╔══██╗██╔══██╗██╔══██╗██║   ██║",
+    "██║   ██║██╔██╗ ██║██║  ██║███████║██████╔╝██║   ██║",
+    "██║   ██║██║╚██╗██║██║  ██║██╔══██║██╔══██╗██║   ██║",
+    "╚██████╔╝██║ ╚████║██████╔╝██║  ██║██║  ██║╚██████╔╝",
+    " ╚═════╝ ╚═╝  ╚═══╝╚═════╝ ╚═╝  ╚═╝╚═╝  ╚═╝ ╚═════╝ ",
+)
+
+CUBE = (
+    "    ┌──────┐",
+    "   ╱│     ╱│",
+    "  ┌──────┐ │",
+    "  │ │    │ │",
+    "  │ └────│─┘",
+    "  │╱     │╱ ",
+    "  └──────┘  ",
+)
+
+# Teal through indigo, two rows each. A per-character gradient reads as a
+# gimmick; per-row reads as depth.
+GRADIENT = ("#5eead4", "#5eead4", "#38bdf8", "#38bdf8", "#818cf8", "#818cf8")
+
+BANNER_WIDTH = 68
+
+DEFAULT_URL = "https://ondaru.dev/mcp"
+
+# The surfaces the service accepts. Kept here so the prompt cannot offer one
+# the server would reject.
+SURFACES = (
+    "mug",
+    "hoodie",
+    "tshirt",
+    "phone_case",
+    "tote",
+    "sticker",
+    "figurine",
+    "packaging",
+)
+
+SERVER_KEY = "ondaru"
+SKILL_NAME = "ondaru"
+_ASSETS = Path(__file__).resolve().parent.parent / "skill_assets"
+
+# Where each host agent keeps its MCP server list and its skills.
+HOSTS: dict[str, tuple[Path, Path]] = {
+    "Claude Code": (Path.home() / ".claude.json", Path.home() / ".claude" / "skills"),
+    "Cursor": (Path.home() / ".cursor" / "mcp.json", Path.home() / ".cursor" / "skills"),
+    "OpenClaw": (Path.home() / ".openclaw" / "mcp.json", Path.home() / ".agents" / "skills"),
+    "Shared agents directory": (
+        Path.home() / ".agents" / "mcp.json",
+        Path.home() / ".agents" / "skills",
+    ),
+}
+
+
+def _banner() -> None:
+    """Print the wordmark, or a plain line when there is no room for it."""
+    console.print()
+    if console.width < BANNER_WIDTH:
+        console.print("  [bold #38bdf8]ONDARU[/]")
+    else:
+        for row, line in enumerate(WORDMARK):
+            console.print(f"  [{GRADIENT[row]}]{line}[/]  [dim]{CUBE[row]}[/]")
+        console.print(f"  [dim]{' ' * len(WORDMARK[0])}  {CUBE[-1]}[/]")
+    console.print()
+    console.print("  [bold]A textured glb and a turntable render[/bold] — ordered by an agent,")
+    console.print("  paid for inside its own workflow.")
+    # Highlighting off: rich colours bare numbers by default, and a price
+    # lighting up inside a dim line looks like a warning rather than a fact.
+    console.print(
+        "\n  [dim]x402 on X Layer · 0.02 to plan · 0.90 an asset · no account, no card[/dim]\n",
+        highlight=False,
+    )
+
+
+@app.callback()
+def main(context: typer.Context) -> None:
+    """Ondaru — 3D product mockups your agent can order."""
+    if context.invoked_subcommand is not None:
+        return
+    _banner()
+
+    choice = questionary.select(
+        "What would you like to do?",
+        choices=[
+            "Install Ondaru into my agent",
+            "Order one mockup from a live service",
+            "Check what a live service charges",
+            "Show my generation credits",
+            "Quit",
+        ],
+    ).ask()
+
+    if choice == "Install Ondaru into my agent":
+        host = _ask_host("Which agent should be able to order mockups?")
+        url = questionary.text("Endpoint:", default=DEFAULT_URL).ask() or DEFAULT_URL
+        setup_mcp(url=url, host=host)
+        skills(action="install", host=host)
+        console.print("\n  Ask your agent for a 3D mockup of something. It knows the rest.")
+    elif choice == "Order one mockup from a live service":
+        url = questionary.text("Endpoint:", default=DEFAULT_URL).ask() or DEFAULT_URL
+        try_order(url=url, subject=None, surface=None, into=Path("out"), yes=False)
+    elif choice == "Check what a live service charges":
+        url = questionary.text("Endpoint:", default=DEFAULT_URL).ask() or DEFAULT_URL
+        check(url=url, subject="an enamel mug", surface="mug")
+    elif choice == "Show my generation credits":
+        credits(keys=None)
+
+
+@app.command("setup-mcp")
+def setup_mcp(
+    url: Annotated[str, typer.Option(help="The Ondaru MCP endpoint.")] = "https://ondaru.dev/mcp",
+    host: Annotated[str | None, typer.Option(help="Skip the prompt and name the host.")] = None,
+) -> None:
+    """Register the Ondaru MCP server with a host agent."""
+    chosen = host or _ask_host("Which agent should be able to order mockups?")
+    config_path, _ = HOSTS[chosen]
+
+    config = _read_json(config_path)
+    servers = config.setdefault("mcpServers", {})
+    already = SERVER_KEY in servers
+    servers[SERVER_KEY] = {"type": "http", "url": url}
+
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+    config_path.write_text(json.dumps(config, indent=2) + "\n", encoding="utf-8")
+
+    verb = "Updated" if already else "Added"
+    console.print(f"[green]{verb}[/green] the [bold]{SERVER_KEY}[/bold] server in {config_path}")
+    console.print(f"  endpoint  {url}")
+    console.print("\nRestart the agent, then ask it to plan a product mockup.")
+
+
+@app.command("skills")
+def skills(
+    action: Annotated[str, typer.Argument(help="install")] = "install",
+    host: Annotated[str | None, typer.Option(help="Skip the prompt and name the host.")] = None,
+) -> None:
+    """Install the skill that teaches an agent when to call Ondaru."""
+    if action != "install":
+        raise typer.BadParameter("the only supported action is 'install'")
+
+    chosen = host or _ask_host("Which agent should learn when to use Ondaru?")
+    _, skills_root = HOSTS[chosen]
+    target = skills_root / SKILL_NAME
+
+    if target.exists():
+        shutil.rmtree(target)
+    target.mkdir(parents=True, exist_ok=True)
+    shutil.copy2(_ASSETS / "ondaru.md", target / "SKILL.md")
+    references = _ASSETS / "references"
+    if references.is_dir():
+        shutil.copytree(references, target / "references")
+
+    installed = sorted(path.name for path in target.rglob("*.md"))
+    console.print(f"[green]Installed[/green] the [bold]{SKILL_NAME}[/bold] skill in {target}")
+    for name in installed:
+        console.print(f"  {name}")
+
+
+@app.command("generate")
+def generate(
+    subject: Annotated[str, typer.Argument(help="What to make a mockup of.")],
+    surface: Annotated[str, typer.Option(help="Which product surface.")] = "mug",
+    vendor: Annotated[str, typer.Option(help="tripo or meshy.")] = "tripo",
+    api_key: Annotated[str | None, typer.Option(envvar="ONDARU_GENERATION_API_KEY")] = None,
+    base_url: Annotated[str | None, typer.Option(help="Override the vendor base URL.")] = None,
+    out: Annotated[Path, typer.Option(help="Where to write the model.")] = Path("out"),
+) -> None:
+    """Run one real generation against a live vendor and save what comes back.
+
+    Bypasses the marketplace and the payment layer on purpose — this answers
+    only whether the adapter genuinely drives the vendor end to end.
+    """
+    import asyncio
+
+    from ondaru.config import GenerationConfig
+    from ondaru.contracts import GenerationState, MockupRequest, Surface
+    from ondaru.generation.factory import open_backend
+
+    if not api_key:
+        console.print("[red]No API key.[/red] Pass --api-key or set ONDARU_GENERATION_API_KEY.")
+        console.print("Tripo grants free credits at https://platform.tripo3d.ai (no card).")
+        raise typer.Exit(code=1)
+
+    defaults = {"tripo": "https://api.tripo3d.ai", "meshy": "https://api.meshy.ai"}
+    config = GenerationConfig(
+        vendor=vendor,
+        base_url=base_url or defaults.get(vendor, ""),
+        api_keys=(api_key,),
+        submit_timeout_seconds=60,
+        poll_interval_seconds=5,
+        poll_deadline_seconds=900,
+    )
+
+    async def run() -> None:
+        backend = open_backend(config)
+        try:
+            request = MockupRequest(subject=subject, surface=Surface(surface))
+            console.print(f"Submitting to [bold]{vendor}[/bold]…")
+            handle = await backend.submit(request)
+            console.print(f"  task {handle.reference}")
+
+            elapsed = 0
+            while True:
+                status = await backend.poll(handle)
+                console.print(f"  {status.state} {status.progress}%  ({elapsed}s)")
+                if status.state is GenerationState.SUCCEEDED:
+                    break
+                if status.state is GenerationState.FAILED:
+                    console.print(f"[red]Failed:[/red] {status.failure_message}")
+                    raise typer.Exit(code=1)
+                await asyncio.sleep(5)
+                elapsed += 5
+
+            handle = await backend.refine(handle)
+            while True:
+                status = await backend.poll(handle)
+                if status.state is GenerationState.SUCCEEDED:
+                    break
+                if status.state is GenerationState.FAILED:
+                    console.print(f"[red]Refine failed:[/red] {status.failure_message}")
+                    raise typer.Exit(code=1)
+                await asyncio.sleep(5)
+
+            result = await backend.fetch_result(handle)
+            out.mkdir(parents=True, exist_ok=True)
+            target = out / f"{subject.replace(' ', '-')}.glb"
+            async with httpx.AsyncClient(timeout=120, follow_redirects=True) as http:
+                downloaded = await http.get(result.model_url)
+                downloaded.raise_for_status()
+                target.write_bytes(downloaded.content)
+
+            console.print(f"\n[green]Saved[/green] {target} ({target.stat().st_size:,} bytes)")
+            if result.thumbnail_url:
+                console.print(f"  preview {result.thumbnail_url}")
+        finally:
+            await backend.aclose()
+
+    asyncio.run(run())
+
+
+@app.command("check")
+def check(
+    url: Annotated[str, typer.Option(help="The Ondaru MCP endpoint.")] = "https://ondaru.dev/mcp",
+    subject: Annotated[str, typer.Option(help="What to plan a mockup for.")] = "an enamel mug",
+    surface: Annotated[str, typer.Option(help="Which product surface.")] = "mug",
+) -> None:
+    """Exercise a live service: plan a mockup and print what it costs."""
+    body = _rpc(
+        url,
+        "tools/call",
+        {
+            "name": "plan_product_mockup",
+            "arguments": {"subject": subject, "surface": surface},
+        },
+    )
+    content = (body.get("result") or {}).get("structuredContent")
+    if not content:
+        console.print("[red]The service did not return a specification.[/red]")
+        console.print(json.dumps(body, indent=2)[:600])
+        raise typer.Exit(code=1)
+
+    table = Table(title=f"{subject} on a {surface}", show_header=False)
+    dimensions = content.get("dimensions_mm", {})
+    table.add_row("Feasible", str(content.get("feasible")))
+    table.add_row(
+        "Size",
+        f"{dimensions.get('width')} × {dimensions.get('height')} × {dimensions.get('depth')} mm",
+    )
+    table.add_row("Material", str(content.get("material")))
+    table.add_row("Polygons", f"{content.get('polygon_budget'):,}")
+    tier = content.get("asset_tier", {})
+    table.add_row("Asset price", f"{tier.get('price')} {tier.get('currency')}")
+    console.print(table)
+
+
+@app.command("try")
+def try_order(
+    url: Annotated[str, typer.Option(help="The Ondaru MCP endpoint.")] = DEFAULT_URL,
+    subject: Annotated[str | None, typer.Option(help="What to build.")] = None,
+    surface: Annotated[str | None, typer.Option(help="Which product surface.")] = None,
+    into: Annotated[Path, typer.Option(help="Where to save the result.")] = Path("out"),
+    yes: Annotated[bool, typer.Option("--yes", help="Do not ask before paying.")] = False,
+) -> None:
+    """Order one mockup end to end and save it here.
+
+    Payment goes through your own Agentic Wallet via the `onchainos` client.
+    This command never sees a private key, and it should not: a terminal tool
+    holding the money is a terminal tool worth stealing.
+    """
+    if shutil.which("onchainos") is None:
+        console.print("[red]The onchainos client is not installed.[/red]")
+        console.print("It holds the wallet that pays. Install it, then run this again.")
+        raise typer.Exit(code=1)
+
+    subject = (
+        subject
+        or questionary.text(
+            "What should it be?", default="an enamel camping mug with an embossed wave crest"
+        ).ask()
+    )
+    surface = surface or questionary.select("On what?", choices=list(SURFACES)).ask()
+    if not subject or not surface:
+        raise typer.Exit(code=1)
+
+    console.print(f"\n  Planning [bold]{subject}[/bold] on a {surface}…")
+    plan = _pay_for(url, "plan_product_mockup", {"subject": subject, "surface": surface})
+    tier = plan.get("asset_tier", {})
+    price = tier.get("price")
+    console.print(
+        f"  {plan.get('material')}, {plan.get('polygon_budget'):,} polygons, "
+        f"[bold]{price} {tier.get('currency')}[/bold] for the model."
+    )
+
+    if not yes and not questionary.confirm(f"Order it for {price}?", default=True).ask():
+        console.print("  Nothing ordered, nothing charged.")
+        return
+
+    ordered = _pay_for(url, "order_product_mockup", {"subject": subject, "surface": surface})
+    job_id = ordered.get("job_id")
+    if not job_id:
+        console.print("[red]The service did not return a job id.[/red]")
+        raise typer.Exit(code=1)
+    console.print(f"  Ordered: [dim]{job_id}[/dim]")
+
+    view = _await_ready(url, str(job_id))
+    if view.get("state") != "ready":
+        failure = view.get("failure") or {}
+        console.print(f"\n  [red]{failure.get('message') or 'The job did not finish.'}[/red]")
+        raise typer.Exit(code=1)
+
+    into.mkdir(parents=True, exist_ok=True)
+    asset = view.get("asset") or {}
+    saved = [
+        _download(str(asset[field]), into / f"{job_id}{suffix}")
+        for field, suffix in (("model_url", ".glb"), ("turntable_url", "-turntable.webp"))
+        if asset.get(field)
+    ]
+    console.print("\n  [green]Ready.[/green]")
+    for path, size in saved:
+        console.print(f"    {path}  [dim]{size:,} bytes[/dim]")
+
+
+def _pay_for(url: str, tool: str, arguments: dict[str, Any]) -> dict[str, Any]:
+    """Call a priced tool, letting the wallet handle the 402.
+
+    Two steps because that is what the client exposes: quote turns the
+    challenge into a payment id, pay signs it and replays the call.
+    """
+
+    quote = ["onchainos", "payment", "quote", url, "--tool", tool]
+    for name, value in arguments.items():
+        quote += ["--param", f"{name}={value}"]
+    payment_id = _last_json(_run(quote)).get("data", {}).get("paymentId")
+    if not payment_id:
+        console.print(f"[red]The wallet could not quote {tool}.[/red]")
+        raise typer.Exit(code=1)
+
+    paid = _last_json(_run(["onchainos", "payment", "pay", "--payment-id", payment_id, "--yes"]))
+    if not paid.get("ok"):
+        console.print(f"[red]Payment failed:[/red] {paid.get('error') or paid}")
+        raise typer.Exit(code=1)
+    result = (paid.get("data") or {}).get("result") or {}
+    content = result.get("structuredContent")
+    if not isinstance(content, dict):
+        console.print(f"[red]{tool} returned nothing usable.[/red]")
+        raise typer.Exit(code=1)
+    return content
+
+
+def _run(command: list[str]) -> str:
+    import subprocess
+
+    finished = subprocess.run(command, capture_output=True, text=True, timeout=180)
+    if finished.returncode != 0 and not finished.stdout.strip():
+        console.print(f"[red]{' '.join(command[:3])} failed:[/red] {finished.stderr.strip()[:200]}")
+        raise typer.Exit(code=1)
+    return finished.stdout
+
+
+def _last_json(output: str) -> dict[str, Any]:
+    for line in reversed(output.strip().splitlines()):
+        try:
+            parsed = json.loads(line)
+        except ValueError:
+            continue
+        if isinstance(parsed, dict):
+            return parsed
+    return {}
+
+
+def _await_ready(url: str, job_id: str, *, ceiling_seconds: int = 600) -> dict[str, Any]:
+    """Poll until the job settles. Polling is free, so the wait costs nothing."""
+    import time
+
+    from rich.progress import Progress, SpinnerColumn, TextColumn
+
+    deadline = time.monotonic() + ceiling_seconds
+    view: dict[str, Any] = {}
+    # Silent when the output is not a terminal: a spinner redrawing into a log
+    # file writes thousands of lines of escape codes over one useful one.
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("{task.description}"),
+        console=console,
+        transient=True,
+        disable=not console.is_terminal,
+    ) as progress:
+        task = progress.add_task("  queued — waiting for payment to settle on-chain")
+        while time.monotonic() < deadline:
+            body = _rpc(
+                url, "tools/call", {"name": "check_product_mockup", "arguments": {"job_id": job_id}}
+            )
+            view = (body.get("result") or {}).get("structuredContent") or {}
+            state = view.get("state", "unknown")
+            if state in {"ready", "failed"}:
+                progress.update(task, description=f"  {state}")
+                return view
+            progress.update(task, description=f"  {state}")
+            time.sleep(max(1, int(view.get("retry_after_seconds") or 5)))
+    return view
+
+
+def _download(url: str, destination: Path) -> tuple[Path, int]:
+    with httpx.stream("GET", url, timeout=120, follow_redirects=True) as response:
+        response.raise_for_status()
+        with destination.open("wb") as sink:
+            for chunk in response.iter_bytes():
+                sink.write(chunk)
+    return destination, destination.stat().st_size
+
+
+@app.command("credits")
+def credits(
+    keys: Annotated[
+        str | None,
+        typer.Option(help="Comma-separated keys. Defaults to ONDARU_GENERATION_API_KEYS."),
+    ] = None,
+) -> None:
+    """Show what each generation account has left, and how many assets that buys.
+
+    Worth running before a demo. One account holds 600 credits, which is 30
+    assets, and discovering that mid-order means a paying caller waits for a
+    job that cannot start.
+    """
+    import asyncio
+    import os
+
+    from ondaru.config import GenerationConfig
+    from ondaru.generation.tripo import (
+        CREDITS_PER_ASSET,
+        DEFAULT_BASE_URL,
+        TripoGenerationBackend,
+    )
+
+    listed = keys or os.environ.get("ONDARU_GENERATION_API_KEYS", "")
+    resolved = tuple(k.strip() for k in listed.split(",") if k.strip()) or (
+        os.environ.get("ONDARU_GENERATION_API_KEY", ""),
+    )
+    if not any(resolved):
+        console.print("[red]No keys.[/red] Set ONDARU_GENERATION_API_KEYS or pass --keys.")
+        raise typer.Exit(code=1)
+
+    config = GenerationConfig(
+        vendor="tripo",
+        base_url=os.environ.get("ONDARU_GENERATION_BASE_URL") or DEFAULT_BASE_URL,
+        api_keys=resolved,
+        submit_timeout_seconds=20,
+        poll_interval_seconds=5,
+        poll_deadline_seconds=900,
+    )
+
+    async def read() -> list[tuple[str, int]]:
+        backend = TripoGenerationBackend.open(config)
+        try:
+            return await backend.balances()
+        finally:
+            await backend.aclose()
+
+    readings = asyncio.run(read())
+    table = Table(title="Generation accounts", box=None)
+    table.add_column("Key")
+    table.add_column("Credits", justify="right")
+    table.add_column("Assets", justify="right")
+    total = 0
+    for masked, balance in readings:
+        if balance < 0:
+            table.add_row(masked, "[yellow]unreadable[/yellow]", "—")
+            continue
+        total += balance
+        style = "" if balance >= CREDITS_PER_ASSET else "[dim]"
+        table.add_row(
+            f"{style}{masked}", f"{style}{balance:,}", f"{style}{balance // CREDITS_PER_ASSET}"
+        )
+    console.print(table)
+    console.print(
+        f"\n  {total:,} credits · [bold]{total // CREDITS_PER_ASSET} assets[/bold] "
+        f"· roughly ${total * 0.01:,.2f} of generation"
+    )
+
+
+def _ask_host(question: str) -> str:
+    answer = questionary.select(question, choices=list(HOSTS)).ask()
+    if answer is None:
+        raise typer.Abort()
+    return str(answer)
+
+
+def _read_json(path: Path) -> dict[str, Any]:
+    if not path.exists():
+        return {}
+    try:
+        loaded = json.loads(path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError as exc:
+        raise typer.BadParameter(f"{path} is not valid JSON: {exc}") from exc
+    return dict(loaded) if isinstance(loaded, dict) else {}
+
+
+def _rpc(url: str, method: str, params: dict[str, Any]) -> dict[str, Any]:
+    headers = {"Content-Type": "application/json", "Accept": "application/json, text/event-stream"}
+    with httpx.Client(timeout=60, follow_redirects=True) as client:
+        client.post(
+            url,
+            headers=headers,
+            json={
+                "jsonrpc": "2.0",
+                "id": 1,
+                "method": "initialize",
+                "params": {
+                    "protocolVersion": "2025-06-18",
+                    "capabilities": {},
+                    "clientInfo": {"name": "ondaru-cli", "version": "0.1.0"},
+                },
+            },
+        )
+        response = client.post(
+            url,
+            headers=headers,
+            json={"jsonrpc": "2.0", "id": 2, "method": method, "params": params},
+        )
+    text = response.text
+    if "data:" in text:
+        for line in text.splitlines():
+            if line.startswith("data:"):
+                text = line[5:].strip()
+                break
+    try:
+        return dict(json.loads(text))
+    except json.JSONDecodeError:
+        return {"raw": text[:600], "status": response.status_code}
+
+
+if __name__ == "__main__":
+    app()