zkai-cli 0.5.0__py3-none-any.whl

zkai_cli/__main__.py

@@ -0,0 +1,4 @@
+from zkai_cli.main import app
+
+if __name__ == "__main__":
+    app()

zkai_cli/docker.py

@@ -0,0 +1,271 @@
+"""Docker Compose operations: start, stop, restart, logs, status."""
+
+import subprocess
+import tarfile
+import time
+import urllib.request
+from pathlib import Path
+
+import requests
+import typer
+from rich.console import Console
+from rich.table import Table
+from rich import box
+
+from zkai_cli.util import (
+    compose_dir, deploy_dir, console, err_console, find_repo_root, ensure_repo,
+    require_docker, run, stream,
+)
+
+SERVICES = ("enclave", "bridge")
+
+GITHUB_REPO = "Eshan276/zkai"
+COMPILED_ASSET = "compiled.tar.gz"
+
+
+def _compose(repo: Path, *args: str, stream_output: bool = True) -> subprocess.CompletedProcess:
+    cmd = ["docker", "compose", *args]
+    cwd = compose_dir(repo)
+    if stream_output:
+        stream(cmd, cwd=cwd)
+        return None  # type: ignore
+    return run(cmd, cwd=cwd, capture=True, check=False)
+
+
+# ── start ─────────────────────────────────────────────────────────────────────
+
+def start(repo_dir: str | None, build: bool = False, follow: bool = False):
+    require_docker()
+    repo = ensure_repo(repo_dir)
+    cwd = compose_dir(repo)
+
+    _ensure_compiled_artifacts(repo)
+
+    if build:
+        console.print("[bold]Building enclave image...[/bold]")
+        stream(["docker", "compose", "build", "enclave"], cwd=cwd)
+
+    console.print("[bold]Starting ZKai containers...[/bold]")
+    stream(["docker", "compose", "up", "-d"], cwd=cwd)
+    console.print()
+    console.print("[green]Containers started.[/green] Bridge wallet sync takes 2-5 minutes on first boot.")
+    console.print("Run [bold]zkai status[/bold] to check progress.")
+    console.print("Run [bold]zkai logs[/bold] to watch logs.")
+
+    if follow:
+        logs(repo_dir, service=None, lines=30, follow=True)
+
+
+# ── stop ──────────────────────────────────────────────────────────────────────
+
+def stop(repo_dir: str | None):
+    require_docker()
+    repo = find_repo_root(repo_dir)
+    console.print("[bold]Stopping ZKai containers...[/bold]")
+    _compose(repo, "down")
+    console.print("[green]Stopped.[/green]")
+
+
+# ── restart ───────────────────────────────────────────────────────────────────
+
+def restart(repo_dir: str | None, service: str | None):
+    require_docker()
+    repo = find_repo_root(repo_dir)
+    targets = _resolve_service(service)
+    console.print(f"[bold]Restarting {', '.join(targets)}...[/bold]")
+    _compose(repo, "restart", *targets)
+    console.print("[green]Done.[/green]")
+
+
+# ── logs ──────────────────────────────────────────────────────────────────────
+
+def logs(repo_dir: str | None, service: str | None, lines: int = 50, follow: bool = False):
+    require_docker()
+    repo = find_repo_root(repo_dir)
+    targets = _resolve_service(service)
+    cmd = ["docker", "compose", "logs", f"--tail={lines}"]
+    if follow:
+        cmd.append("-f")
+    cmd.extend(targets)
+    stream(cmd, cwd=compose_dir(repo))
+
+
+# ── status ────────────────────────────────────────────────────────────────────
+
+def status(repo_dir: str | None):
+    require_docker()
+    repo = find_repo_root(repo_dir)
+
+    # Container states
+    r = _compose(repo, "ps", "--format", "json", stream_output=False)
+    containers = _parse_ps(r.stdout if r else "")
+
+    table = Table(title="ZKai Node Status", box=box.ROUNDED, show_lines=True)
+    table.add_column("Container", style="bold")
+    table.add_column("State")
+    table.add_column("Health")
+    table.add_column("Ports")
+
+    for c in containers:
+        state_color = "green" if c["state"] == "running" else "red"
+        health_color = {
+            "healthy": "green",
+            "starting": "yellow",
+            "unhealthy": "red",
+        }.get(c["health"], "dim")
+        table.add_row(
+            c["name"],
+            f"[{state_color}]{c['state']}[/{state_color}]",
+            f"[{health_color}]{c['health'] or '—'}[/{health_color}]",
+            c["ports"] or "—",
+        )
+
+    console.print(table)
+
+    # Bridge health
+    _print_bridge_health()
+
+    # Enclave health
+    _print_enclave_health()
+
+    # Dashboard link
+    _print_dashboard_link(repo)
+
+
+def _print_bridge_health():
+    try:
+        r = requests.get("http://127.0.0.1:7300/health", timeout=3)
+        data = r.json()
+        synced = data.get("synced", False)
+        addr = data.get("address", "unknown")
+        if synced:
+            console.print(f"[green]Bridge:[/green] synced  |  address: {addr}")
+        else:
+            console.print("[yellow]Bridge:[/yellow] syncing (wallet not yet synced — wait 2-5 min)")
+    except Exception:
+        console.print("[dim]Bridge:[/dim] not reachable on port 7300 (container may still be starting)")
+
+
+def _print_enclave_health():
+    try:
+        r = requests.get("http://127.0.0.1:8080/health", timeout=3)
+        data = r.json()
+        mode = data.get("enclave_mode", "unknown")
+        console.print(f"[green]Enclave:[/green] ok  |  mode: {mode}")
+    except Exception:
+        console.print("[dim]Enclave:[/dim] not reachable on port 8080 (container may still be starting)")
+
+
+def _print_dashboard_link(repo: Path):
+    import json as _json
+    pid_file = compose_dir(repo) / ".provider_id"
+    if not pid_file.exists():
+        return
+    try:
+        data = _json.loads(pid_file.read_text())
+        provider_id = data.get("provider_id", "")
+        if provider_id:
+            url = f"https://zkai-ether-og.vercel.app/provider_dashboard?id={provider_id}"
+            console.print(f"\n[bold]Provider Dashboard:[/bold] [link={url}][violet]{url}[/violet][/link]")
+    except Exception:
+        pass
+
+
+def _parse_ps(raw: str) -> list[dict]:
+    """Parse `docker compose ps --format json` output (one JSON object per line)."""
+    import json
+    results = []
+    for line in raw.strip().splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            obj = json.loads(line)
+            results.append({
+                "name": obj.get("Name", obj.get("Service", "?")),
+                "state": obj.get("State", "?").lower(),
+                "health": obj.get("Health", "").lower() or None,
+                "ports": _fmt_ports(obj.get("Publishers") or obj.get("Ports") or []),
+            })
+        except Exception:
+            continue
+    return results
+
+
+def _fmt_ports(ports) -> str:
+    if isinstance(ports, str):
+        return ports
+    if isinstance(ports, list):
+        out = []
+        for p in ports:
+            if isinstance(p, dict):
+                pub = p.get("PublishedPort", "")
+                tgt = p.get("TargetPort", "")
+                if pub and tgt:
+                    out.append(f"{pub}→{tgt}")
+        return ", ".join(out) if out else ""
+    return ""
+
+
+def _resolve_service(service: str | None) -> list[str]:
+    if service is None:
+        return list(SERVICES)
+    s = service.lower()
+    if s not in SERVICES:
+        err_console.print(f"[red]Unknown service '{service}'.[/red] Choose: {', '.join(SERVICES)}")
+        raise typer.Exit(1)
+    return [s]
+
+
+# ── compiled artifact bootstrap ───────────────────────────────────────────────
+
+def _ensure_compiled_artifacts(repo: Path):
+    """Download and extract compiled.tar.gz from the latest release if deploy/compiled/ is missing."""
+    compiled = deploy_dir(repo) / "compiled"
+    marker = compiled / "ProviderRegistry" / "contract" / "index.js"
+    if marker.exists():
+        return  # already present
+
+    console.print("[bold]Compiled contract artifacts not found — downloading from release...[/bold]")
+
+    url = _get_compiled_download_url()
+    if not url:
+        err_console.print(
+            "[red]Could not find compiled.tar.gz in the latest release.[/red]\n"
+            "Check https://github.com/Eshan276/zkai/releases or run the deploy script manually."
+        )
+        raise typer.Exit(1)
+
+    console.print(f"  Downloading {url} ...")
+    tmp = repo / ".build-tmp" / COMPILED_ASSET
+    tmp.parent.mkdir(parents=True, exist_ok=True)
+
+    try:
+        urllib.request.urlretrieve(url, tmp)
+    except Exception as e:
+        err_console.print(f"[red]Download failed:[/red] {e}")
+        raise typer.Exit(1)
+
+    console.print("  Extracting...")
+    compiled.mkdir(parents=True, exist_ok=True)
+    with tarfile.open(tmp, "r:gz") as tf:
+        # Archive is: compiled/<contract>/... — extract one level into deploy/
+        tf.extractall(deploy_dir(repo))
+
+    tmp.unlink(missing_ok=True)
+    console.print("[green]Compiled artifacts ready.[/green]")
+
+
+def _get_compiled_download_url() -> str | None:
+    """Fetch the compiled.tar.gz download URL from the latest GitHub release."""
+    import json
+    api_url = f"https://api.github.com/repos/{GITHUB_REPO}/releases/latest"
+    try:
+        with urllib.request.urlopen(api_url, timeout=10) as resp:
+            data = json.loads(resp.read())
+        for asset in data.get("assets", []):
+            if asset["name"] == COMPILED_ASSET:
+                return asset["browser_download_url"]
+    except Exception:
+        pass
+    return None

zkai_cli/keys.py

@@ -0,0 +1,25 @@
+"""
+zkai keys — API key management.
+
+API keys are now managed centrally via the ZKai dashboard.
+Consumers connect their EVM wallet (MetaMask) and generate keys there.
+Enclaves verify keys against the central auth server (ZKAI_AUTH_URL).
+"""
+
+import typer
+from rich.panel import Panel
+
+from zkai_cli.util import console
+
+
+def run(action: str, key_value: str | None, repo_dir: str | None, count: int):
+    console.print(Panel(
+        "[bold]API keys are managed via the ZKai dashboard.[/bold]\n\n"
+        "Consumers connect their EVM wallet (MetaMask) at the dashboard URL\n"
+        "and generate API keys from there.\n\n"
+        "Your enclave verifies keys automatically via [cyan]ZKAI_AUTH_URL[/cyan].\n\n"
+        "To update the auth server URL: [bold cyan]zkai init[/bold cyan]",
+        title="[yellow]zkai keys[/yellow]",
+        border_style="yellow",
+    ))
+    raise typer.Exit(0)

zkai_cli/main.py

@@ -0,0 +1,138 @@
+"""
+zkai CLI — provider node management tool.
+
+Commands:
+  zkai init          Guided first-time setup (EVM key, .env, relay config)
+  zkai start         Start enclave + bridge (docker compose up -d)
+  zkai stop          Stop all containers
+  zkai restart       Restart containers
+  zkai logs          Tail logs (enclave, bridge, or both)
+  zkai status        Show container + wallet health
+  zkai register      Register provider on-chain (one-time)
+  zkai deregister    Remove provider from on-chain registry
+  zkai keys          Show how API keys work (managed via dashboard)
+  zkai info          Print provider ID, endpoint, address
+"""
+
+import typer
+from rich.console import Console
+
+from zkai_cli import setup as _setup
+from zkai_cli import docker as _docker
+from zkai_cli import register as _register
+from zkai_cli import keys as _keys
+
+app = typer.Typer(
+    name="zkai",
+    help="ZKai provider node — setup, manage, and register your AI inference node.",
+    no_args_is_help=True,
+    add_completion=False,
+)
+console = Console()
+
+
+# ── Init / setup ──────────────────────────────────────────────────────────────
+
+@app.command()
+def init(
+    repo_dir: str = typer.Option(
+        None, "--dir", "-d",
+        help="Path to the zkai repo root (auto-detected if omitted)",
+    ),
+):
+    """Guided first-time setup: EVM private key, relay config, provider/.env."""
+    _setup.run_init(repo_dir)
+
+
+# ── Lifecycle ─────────────────────────────────────────────────────────────────
+
+@app.command()
+def start(
+    repo_dir: str = typer.Option(None, "--dir", "-d", help="zkai repo root"),
+    build: bool = typer.Option(False, "--build", help="Rebuild enclave image before starting"),
+    follow: bool = typer.Option(False, "--logs", "-l", help="Tail logs after starting"),
+):
+    """Start enclave + bridge containers."""
+    _docker.start(repo_dir, build=build, follow=follow)
+
+
+@app.command()
+def stop(
+    repo_dir: str = typer.Option(None, "--dir", "-d", help="zkai repo root"),
+):
+    """Stop all ZKai containers."""
+    _docker.stop(repo_dir)
+
+
+@app.command()
+def restart(
+    repo_dir: str = typer.Option(None, "--dir", "-d", help="zkai repo root"),
+    service: str = typer.Argument(None, help="Service to restart: enclave, bridge, or both (default)"),
+):
+    """Restart containers (or a specific service)."""
+    _docker.restart(repo_dir, service)
+
+
+@app.command()
+def logs(
+    repo_dir: str = typer.Option(None, "--dir", "-d", help="zkai repo root"),
+    service: str = typer.Argument(None, help="Service: enclave, bridge (default: both)"),
+    lines: int = typer.Option(50, "--lines", "-n", help="Number of recent lines to show"),
+    follow: bool = typer.Option(False, "--follow", "-f", help="Follow (tail -f) mode"),
+):
+    """Show or tail container logs."""
+    _docker.logs(repo_dir, service, lines=lines, follow=follow)
+
+
+@app.command()
+def status(
+    repo_dir: str = typer.Option(None, "--dir", "-d", help="zkai repo root"),
+):
+    """Show container status, wallet sync state, and enclave health."""
+    _docker.status(repo_dir)
+
+
+# ── On-chain registration ──────────────────────────────────────────────────────
+
+@app.command()
+def register(
+    repo_dir: str = typer.Option(None, "--dir", "-d", help="zkai repo root"),
+    endpoint: str = typer.Option(None, "--endpoint", "-e", help="Public endpoint URL (e.g. http://1.2.3.4:8080)"),
+    model: str = typer.Option("qwen2.5-1.5b", "--model", "-m", help="Model name to advertise"),
+    price: int = typer.Option(100, "--price", "-p", help="Price per request in A0GI units (wei)"),
+):
+    """Register this provider on the 0G chain (run once after first start)."""
+    _register.register(repo_dir, endpoint=endpoint, model=model, price=price)
+
+
+@app.command()
+def deregister(
+    repo_dir: str = typer.Option(None, "--dir", "-d", help="zkai repo root"),
+):
+    """Remove this provider from the on-chain registry."""
+    _register.deregister(repo_dir)
+
+
+@app.command()
+def info(
+    repo_dir: str = typer.Option(None, "--dir", "-d", help="zkai repo root"),
+):
+    """Print provider ID, TEE pubkey, and endpoint."""
+    _register.info(repo_dir)
+
+
+# ── API key management ────────────────────────────────────────────────────────
+
+@app.command()
+def keys(
+    action: str = typer.Argument(..., help="add | list | remove | rotate"),
+    key_value: str = typer.Argument(None, help="Key to remove (for 'remove' action)"),
+    repo_dir: str = typer.Option(None, "--dir", "-d", help="zkai repo root"),
+    count: int = typer.Option(1, "--count", "-n", help="Number of keys to add/rotate"),
+):
+    """Show how API key management works (now centralized via dashboard)."""
+    _keys.run(action, key_value, repo_dir=repo_dir, count=count)
+
+
+if __name__ == "__main__":
+    app()

zkai_cli/register.py

@@ -0,0 +1,259 @@
+"""
+zkai register   — register provider on 0G chain
+zkai deregister — remove provider from registry
+zkai info       — print provider ID, endpoint
+"""
+
+import hashlib
+import json
+import time
+from pathlib import Path
+
+import requests
+import typer
+from rich.panel import Panel
+from rich.prompt import Prompt, Confirm
+
+from zkai_cli.util import (
+    console, err_console,
+    compose_dir, find_repo_root,
+    require_docker, read_env_file,
+)
+
+_PROVIDER_ID_FILE = ".provider_id"
+_ENCLAVE_URL = "http://127.0.0.1:8080"
+_BRIDGE_URL = "http://127.0.0.1:7300"
+
+import os as _os
+_AUTH_URL = _os.environ.get("ZKAI_AUTH_URL", "").rstrip("/")
+_RELAY_URL = _os.environ.get("ZKAI_RELAY_URL", "").rstrip("/")
+
+
+# ── register ──────────────────────────────────────────────────────────────────
+
+def register(
+    repo_dir: str | None,
+    endpoint: str | None,
+    model: str,
+    price: int,
+):
+    require_docker()
+    repo = find_repo_root(repo_dir)
+
+    relay_url = _RELAY_URL
+    if not relay_url:
+        env = read_env_file(repo)
+        relay_url = env.get("ZKAI_RELAY_URL", "").rstrip("/")
+    auth_url = _AUTH_URL or read_env_file(repo).get("ZKAI_AUTH_URL", "").rstrip("/")
+
+    # Check bridge is up
+    _wait_for_bridge()
+
+    # Get bridge's EVM address (this IS the provider ID on 0G chain)
+    console.print("[bold]Fetching provider address from bridge...[/bold]")
+    provider_id = _get_bridge_address()
+    console.print(f"  provider address (0G): {provider_id}")
+
+    # Get TEE pubkey from enclave (for info purposes)
+    pubkey = ""
+    try:
+        pubkey = _get_enclave_pubkey()
+        console.print(f"  TEE pubkey: {pubkey[:16]}...{pubkey[-8:]}")
+    except Exception:
+        console.print("  [dim]Enclave not reachable — skipping pubkey check[/dim]")
+
+    # Endpoint
+    if not endpoint:
+        if relay_url:
+            endpoint = f"{relay_url}/relay/{provider_id}"
+            console.print(f"  [dim]Using relay endpoint: {endpoint}[/dim]")
+        else:
+            endpoint = Prompt.ask(
+                "\nPublic endpoint URL (consumers will connect here)",
+                default="http://localhost:8080",
+            )
+
+    console.print(f"\n[bold]Registering...[/bold]")
+    console.print(f"  endpoint: {endpoint}")
+    console.print(f"  model:    {model}")
+    console.print(f"  price:    {price} A0GI/req")
+
+    # Fetch hardware info
+    hardware = None
+    try:
+        hw_resp = requests.get(f"{_ENCLAVE_URL}/health", timeout=5)
+        if hw_resp.ok:
+            hardware = hw_resp.json().get("hardware")
+    except Exception:
+        pass
+
+    # Register in central gateway DB
+    tx_id = "pending"
+    if auth_url:
+        try:
+            r = requests.post(
+                f"{auth_url}/api/providers/register",
+                json={"provider_id": provider_id, "endpoint": endpoint, "model": model, "price": price, "hardware": hardware},
+                timeout=15,
+            )
+            if r.ok:
+                console.print("  [green]Registered in central gateway DB[/green]")
+            else:
+                console.print(f"  [yellow]Warning: gateway DB registration failed: {r.text[:80]}[/yellow]")
+        except Exception as e:
+            console.print(f"  [yellow]Warning: could not reach gateway ({e})[/yellow]")
+
+    # Submit on-chain tx via bridge
+    console.print("  Submitting on-chain tx...")
+    try:
+        resp = requests.post(
+            f"{_BRIDGE_URL}/registry/register-provider",
+            json={
+                "endpoint": endpoint,
+                "model": model,
+                "price": str(price),
+            },
+            timeout=120,
+        )
+        if resp.ok:
+            result = resp.json()
+            tx_id = result.get("tx_id", "submitted")
+            provider_id = result.get("provider_id", provider_id)
+            console.print(f"  [green]On-chain tx: {tx_id[:20]}...[/green]")
+        else:
+            console.print(f"  [yellow]On-chain tx failed (gateway registration still active): {resp.text[:80]}[/yellow]")
+    except Exception as e:
+        console.print(f"  [yellow]On-chain tx error: {e}[/yellow]")
+
+    # Save provider info locally
+    pid_file = compose_dir(repo) / _PROVIDER_ID_FILE
+    pid_file.write_text(json.dumps({
+        "provider_id": provider_id,
+        "pubkey": pubkey,
+        "endpoint": endpoint,
+        "model": model,
+        "price": price,
+    }))
+
+    console.print(Panel(
+        f"[green bold]Provider registered![/green bold]\n\n"
+        f"  TX:          {tx_id}\n"
+        f"  Provider ID: {provider_id}\n"
+        f"  Endpoint:    {endpoint}\n\n"
+        f"Saved to [dim]{pid_file}[/dim]\n"
+        f"Your node is now discoverable by consumers on the 0G registry.",
+        border_style="green",
+    ))
+
+
+# ── deregister ────────────────────────────────────────────────────────────────
+
+def deregister(repo_dir: str | None):
+    require_docker()
+    repo = find_repo_root(repo_dir)
+
+    pid_file = compose_dir(repo) / _PROVIDER_ID_FILE
+    provider_id = _load_provider_id(pid_file)
+
+    console.print(f"[bold]Deregistering provider:[/bold] {provider_id}")
+    if not Confirm.ask("Are you sure? This removes you from the on-chain registry.", default=False):
+        console.print("Aborted.")
+        raise typer.Exit(0)
+
+    resp = requests.post(
+        f"{_BRIDGE_URL}/registry/deregister-provider",
+        json={"provider_id": provider_id},
+        timeout=60,
+    )
+
+    if not resp.ok:
+        data = resp.json() if resp.headers.get("content-type", "").startswith("application/json") else {}
+        err_console.print(f"[red]Deregistration failed:[/red] {data.get('error', resp.text)}")
+        raise typer.Exit(1)
+
+    env = read_env_file(repo)
+    auth_url = _AUTH_URL or env.get("ZKAI_AUTH_URL", "").rstrip("/")
+    if auth_url:
+        try:
+            requests.post(
+                f"{auth_url}/api/providers/deregister",
+                json={"provider_id": provider_id},
+                timeout=10,
+            )
+        except Exception:
+            pass
+
+    console.print("[green]Provider deregistered.[/green]")
+    pid_file.unlink(missing_ok=True)
+
+
+# ── info ──────────────────────────────────────────────────────────────────────
+
+def info(repo_dir: str | None):
+    repo = find_repo_root(repo_dir)
+    pid_file = compose_dir(repo) / _PROVIDER_ID_FILE
+
+    if not pid_file.exists():
+        console.print("[yellow]Provider not registered yet.[/yellow] Run [bold]zkai register[/bold] first.")
+        return
+
+    data = json.loads(pid_file.read_text())
+    console.print()
+    console.print(f"  [bold]Provider ID (0G):[/bold] {data.get('provider_id', '?')}")
+    console.print(f"  [bold]TEE Pubkey:[/bold]      {data.get('pubkey', '?')}")
+    console.print(f"  [bold]Endpoint:[/bold]        {data.get('endpoint', '?')}")
+    console.print(f"  [bold]Model:[/bold]           {data.get('model', '?')}")
+    console.print(f"  [bold]Price:[/bold]           {data.get('price', '?')} A0GI/req")
+    console.print()
+
+
+# ── helpers ───────────────────────────────────────────────────────────────────
+
+def _get_bridge_address() -> str:
+    try:
+        r = requests.get(f"{_BRIDGE_URL}/health", timeout=10)
+        r.raise_for_status()
+        addr = r.json().get("address")
+        if not addr:
+            raise ValueError("No address in bridge health response")
+        return addr
+    except Exception as e:
+        err_console.print(f"[red]Cannot reach bridge at {_BRIDGE_URL}/health:[/red] {e}")
+        err_console.print("Make sure the bridge is running: [bold]zkai start[/bold]")
+        raise typer.Exit(1)
+
+
+def _get_enclave_pubkey() -> str:
+    r = requests.get(f"{_ENCLAVE_URL}/pubkey", timeout=10)
+    r.raise_for_status()
+    return r.json()["pubkey"]
+
+
+def _wait_for_bridge(timeout: int = 30):
+    console.print("[bold]Checking bridge...[/bold]", end=" ")
+    deadline = time.time() + timeout
+    while time.time() < deadline:
+        try:
+            r = requests.get(f"{_BRIDGE_URL}/health", timeout=3)
+            data = r.json()
+            if data.get("synced"):
+                console.print("[green]ready[/green]")
+                return
+        except Exception:
+            pass
+        time.sleep(2)
+        console.print(".", end="", flush=True)
+
+    err_console.print(f"\n[red]Bridge not reachable after {timeout}s.[/red]")
+    err_console.print("Run [bold]zkai logs bridge[/bold] to diagnose.")
+    raise typer.Exit(1)
+
+
+def _load_provider_id(pid_file: Path) -> str:
+    if not pid_file.exists():
+        err_console.print(
+            "[red]No provider_id found.[/red] "
+            "Run [bold]zkai register[/bold] first."
+        )
+        raise typer.Exit(1)
+    return json.loads(pid_file.read_text())["provider_id"]

zkai_cli/setup.py

@@ -0,0 +1,130 @@
+"""
+zkai init  — guided first-time setup wizard
+"""
+
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+import requests
+import typer
+from rich.panel import Panel
+from rich.prompt import Confirm, Prompt
+
+from zkai_cli.util import (
+    console, err_console,
+    deploy_dir, compose_dir, env_file, ensure_repo,
+)
+
+GATEWAY_URL = "https://zkai-ether-og.vercel.app"
+
+
+# ── init wizard ───────────────────────────────────────────────────────────────
+
+def run_init(repo_dir: str | None):
+    console.print(Panel.fit(
+        "[bold violet]ZKai Provider Setup[/bold violet]\n"
+        "Gets your node configured and ready to earn A0GI.",
+        border_style="violet",
+    ))
+
+    repo = ensure_repo(repo_dir)
+
+    # 1. Fetch relay config from gateway
+    relay_config = _fetch_relay_config()
+
+    # 2. EVM private key
+    private_key = _step_private_key(repo)
+
+    # 3. Write all config files
+    _write_all_config(repo, relay_config, private_key)
+
+    # 4. Print next steps
+    _print_next_steps(repo, private_key)
+
+
+def _fetch_relay_config() -> dict:
+    console.print("[dim]Fetching relay config from gateway...[/dim]", end=" ")
+    try:
+        r = requests.get(f"{GATEWAY_URL}/api/relay-config", timeout=10)
+        r.raise_for_status()
+        data = r.json()
+        console.print("[green]ok[/green]")
+        return data
+    except Exception as e:
+        console.print("[red]failed[/red]")
+        err_console.print(f"[red]Could not reach {GATEWAY_URL}/api/relay-config: {e}[/red]")
+        err_console.print("Check your internet connection and try again.")
+        raise typer.Exit(1)
+
+
+def _step_private_key(repo: Path) -> str:
+    console.rule("[bold]EVM Wallet (0G Chain)[/bold]")
+    ef = env_file(repo)
+
+    # Check if key already exists in .env
+    if ef.exists():
+        existing_env = {}
+        for line in ef.read_text().splitlines():
+            if "=" in line and not line.startswith("#"):
+                k, _, v = line.partition("=")
+                existing_env[k.strip()] = v.strip()
+        existing_key = existing_env.get("ZKAI_PRIVATE_KEY", "")
+        if existing_key:
+            console.print(f"[green]Private key already configured[/green] ({existing_key[:6]}...)")
+            if not Confirm.ask("Replace with a new key?", default=False):
+                return existing_key
+
+    console.print(
+        "\nYou need an EVM private key to pay gas on the 0G Galileo testnet.\n"
+        "[dim]Generate one in MetaMask: Account → Export Private Key[/dim]\n"
+        "[dim]Or use: cast wallet new (from Foundry)[/dim]\n"
+    )
+    key = Prompt.ask("Paste your EVM private key (hex, with or without 0x prefix)").strip()
+    key = key if key.startswith("0x") else "0x" + key
+
+    if not re.fullmatch(r"0x[0-9a-fA-F]{64}", key):
+        err_console.print("[red]Invalid private key — must be 64 hex chars.[/red]")
+        raise typer.Exit(1)
+
+    return key
+
+
+def _write_all_config(repo: Path, relay_config: dict, private_key: str):
+    console.rule("[bold]Writing config files[/bold]")
+
+    ef = env_file(repo)
+    ef.parent.mkdir(parents=True, exist_ok=True)
+    env_content = (
+        f"ZKAI_PRIVATE_KEY={private_key}\n"
+        f"OG_RPC_URL={relay_config.get('og_rpc_url', 'https://evmrpc-testnet.0g.ai')}\n"
+        f"ZKAI_AUTH_URL={relay_config.get('auth_url', GATEWAY_URL)}\n"
+        f"ZKAI_RELAY_URL={relay_config.get('relay_url', 'https://zkai-relay.fly.dev')}\n"
+        f"ZKAI_RELAY_SECRET={relay_config.get('relay_secret', '')}\n"
+        f"ZKAI_PRICE_PER_REQUEST={relay_config.get('price_per_request', 100)}\n"
+        f"OLLAMA_MODEL=qwen2.5:1.5b\n"
+        f"MAX_TOKENS=512\n"
+    )
+    ef.write_text(env_content)
+    ef.chmod(0o600)
+    console.print(f"  [green]✓[/green] {ef}")
+
+
+def _print_next_steps(repo: Path, private_key: str):
+    console.print()
+    console.print(Panel(
+        "[bold yellow]Fund your wallet before starting[/bold yellow]\n\n"
+        "Your wallet pays gas for on-chain transactions on 0G Galileo testnet.\n\n"
+        "[bold]1.[/bold] Get your wallet address:\n"
+        "   [cyan]zkai start[/cyan]\n"
+        "   [cyan]zkai logs bridge[/cyan]  (look for '0G address: 0x...')\n\n"
+        "[bold]2.[/bold] Get testnet A0GI from the faucet:\n"
+        "   [link=https://faucet.0g.ai]https://faucet.0g.ai[/link]\n\n"
+        "[bold]3.[/bold] Once funded, register and go live:\n"
+        "   [cyan]zkai register --model qwen2.5:1.5b --price 100[/cyan]\n\n"
+        "[bold]4.[/bold] Check status:\n"
+        "   [cyan]zkai status[/cyan]",
+        border_style="yellow",
+        title="Next steps",
+    ))

zkai_cli/util.py

@@ -0,0 +1,154 @@
+"""Shared utilities: repo detection, console, subprocess."""
+
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+console = Console()
+err_console = Console(stderr=True)
+
+GITHUB_REPO = "https://github.com/Eshan276/zkai.git"
+DEFAULT_CLONE_DIR = Path.home() / "zkai"
+
+
+# ── Repo detection ────────────────────────────────────────────────────────────
+
+def find_repo_root(hint: str | None = None, auto_clone: bool = False) -> Path:
+    """
+    Locate the zkai repo root. Search order:
+    1. --dir flag passed by user
+    2. Walk up from cwd looking for provider/docker-compose.yml
+    3. ~/zkai
+    4. If auto_clone=True, clone to ~/zkai automatically
+    """
+    if hint:
+        p = Path(hint).expanduser().resolve()
+        _assert_repo(p)
+        return p
+
+    # Walk up from cwd
+    cur = Path.cwd()
+    for candidate in [cur, *cur.parents]:
+        if (candidate / "provider" / "docker-compose.yml").exists():
+            return candidate
+
+    # ~/zkai fallback
+    if DEFAULT_CLONE_DIR.exists() and (DEFAULT_CLONE_DIR / "provider" / "docker-compose.yml").exists():
+        return DEFAULT_CLONE_DIR
+
+    if auto_clone:
+        return _clone_repo()
+
+    err_console.print(
+        "[red]ZKai repo not found.[/red] "
+        "Run [bold]zkai init[/bold] to set up, or pass [bold]--dir /path/to/zkai[/bold]."
+    )
+    raise typer.Exit(1)
+
+
+def ensure_repo(repo_dir: str | None) -> Path:
+    """Like find_repo_root but always auto-clones if missing. Used by init."""
+    if repo_dir:
+        p = Path(repo_dir).expanduser().resolve()
+        _assert_repo(p)
+        return p
+
+    # Walk up from cwd
+    cur = Path.cwd()
+    for candidate in [cur, *cur.parents]:
+        if (candidate / "provider" / "docker-compose.yml").exists():
+            return candidate
+
+    # ~/zkai fallback
+    if DEFAULT_CLONE_DIR.exists() and (DEFAULT_CLONE_DIR / "provider" / "docker-compose.yml").exists():
+        return DEFAULT_CLONE_DIR
+
+    return _clone_repo()
+
+
+def _clone_repo() -> Path:
+    dest = DEFAULT_CLONE_DIR
+    console.print(f"[bold]Cloning ZKai repo to {dest}...[/bold]")
+    if not _check_git():
+        err_console.print("[red]git not found.[/red] Install git and retry.")
+        raise typer.Exit(1)
+    result = subprocess.run(
+        ["git", "clone", "--depth=1", GITHUB_REPO, str(dest)],
+        check=False,
+    )
+    if result.returncode != 0:
+        err_console.print("[red]Failed to clone repo.[/red]")
+        raise typer.Exit(1)
+    console.print(f"[green]Cloned to {dest}[/green]")
+    return dest
+
+
+def _assert_repo(p: Path):
+    if not (p / "provider" / "docker-compose.yml").exists():
+        err_console.print(f"[red]{p}[/red] does not look like a zkai repo (missing provider/docker-compose.yml).")
+        raise typer.Exit(1)
+
+
+def _check_git() -> bool:
+    return subprocess.run(["git", "--version"], capture_output=True).returncode == 0
+
+
+def compose_dir(repo: Path) -> Path:
+    return repo / "provider"
+
+
+def deploy_dir(repo: Path) -> Path:
+    return repo / "deploy"
+
+
+def env_file(repo: Path) -> Path:
+    return compose_dir(repo) / ".env"
+
+
+def read_env_file(repo: Path) -> dict[str, str]:
+    """Parse provider/.env into a dict. Returns empty dict if file missing."""
+    ef = env_file(repo)
+    result: dict[str, str] = {}
+    if not ef.exists():
+        return result
+    for line in ef.read_text().splitlines():
+        line = line.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+        k, _, v = line.partition("=")
+        result[k.strip()] = v.strip()
+    return result
+
+
+# ── Shell helpers ─────────────────────────────────────────────────────────────
+
+def run(cmd: list[str], cwd: Path | None = None, check: bool = True, capture: bool = False) -> subprocess.CompletedProcess:
+    kwargs: dict = dict(cwd=str(cwd) if cwd else None)
+    if capture:
+        kwargs["capture_output"] = True
+        kwargs["text"] = True
+    return subprocess.run(cmd, check=check, **kwargs)
+
+
+def stream(cmd: list[str], cwd: Path | None = None):
+    result = subprocess.run(cmd, cwd=str(cwd) if cwd else None)
+    if result.returncode != 0:
+        raise typer.Exit(result.returncode)
+
+
+def require_docker():
+    r = subprocess.run(["docker", "compose", "version"], capture_output=True)
+    if r.returncode != 0:
+        err_console.print("[red]docker compose not found.[/red] Install Docker Engine with the Compose plugin.")
+        raise typer.Exit(1)
+
+
+def require_node(repo: Path):
+    r = subprocess.run(["node", "--version"], capture_output=True)
+    if r.returncode != 0:
+        err_console.print("[red]node not found.[/red] Install Node.js 20+.")
+        raise typer.Exit(1)

zkai_cli-0.5.0.dist-info/METADATA

@@ -0,0 +1,102 @@
+Metadata-Version: 2.4
+Name: zkai-cli
+Version: 0.5.0
+Summary: ZKai provider CLI — setup, register, and manage your verifiable AI inference node on 0G chain
+Project-URL: Homepage, https://zkai-ether-og.vercel.app
+Project-URL: Repository, https://github.com/skyyycodes/zkai-eth
+Project-URL: Issues, https://github.com/skyyycodes/zkai-eth/issues
+Author-email: ZKai <team@zkai.network>
+License: MIT
+Keywords: 0g,ai,blockchain,cli,inference,node,provider,tdx,tee,verifiable
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: System :: Distributed Computing
+Requires-Python: >=3.9
+Requires-Dist: requests>=2.31
+Requires-Dist: rich>=13
+Requires-Dist: typer>=0.12
+Description-Content-Type: text/markdown
+
+# zkai-cli
+
+Provider node management CLI for [ZKai](https://zkai-ether-og.vercel.app) — the verifiable AI inference marketplace on 0G chain.
+
+This package installs the `zkai` command, which automates everything a provider needs: wallet setup, container lifecycle (Docker Compose), and on-chain registration against the ZKai contracts deployed on 0G mainnet.
+
+## Install
+
+```bash
+pip install zkai-cli
+```
+
+## Quick start
+
+Becoming a provider takes 4 commands:
+
+```bash
+# 1. Initial setup — prompts for an EVM private key, writes .env
+zkai init
+
+# 2. Start the provider (bridge + TDX-attested enclave)
+zkai start
+
+# 3. Verify it's running
+zkai status
+
+# 4. Register on-chain — your wallet becomes your provider ID
+zkai register --model qwen2.5:1.5b --price 100
+```
+
+Your node is now discoverable by ZKai consumers. Every inference you serve pays you native 0G straight to your wallet.
+
+## Commands
+
+| Command | Purpose |
+|---|---|
+| `zkai init` | First-time setup wizard (wallet, .env, relay config). |
+| `zkai start` | Bring up the provider containers via `docker compose`. |
+| `zkai stop` | Stop and remove containers. |
+| `zkai restart [service]` | Restart all or one of: `bridge`, `enclave`. |
+| `zkai status` | Show container health, wallet sync, enclave state, dashboard URL. |
+| `zkai logs [service]` | Tail logs from a service. |
+| `zkai register` | Register the provider in the on-chain `ProviderRegistry`. |
+| `zkai deregister` | Remove the provider from the on-chain registry. |
+| `zkai info` | Print local provider metadata. |
+| `zkai keys` | Print API key management info. |
+
+Run `zkai --help` for the full reference.
+
+## Requirements
+
+- Linux machine with Docker Engine + Compose plugin (Docker Desktop on macOS works too).
+- An EVM-compatible wallet with a small amount of native 0G for gas. Get testnet 0G from [faucet.0g.ai](https://faucet.0g.ai).
+- A model you want to serve (`qwen2.5:1.5b` is the default; any Ollama model works).
+
+## How it fits together
+
+ZKai providers run two containers:
+
+- **bridge** — Node.js sidecar that wraps `ethers.js` and talks to 0G chain on your behalf. Registers, attests, and accepts payment.
+- **enclave** — Python/FastAPI service running inside a Gramine TDX-sealed runtime, serving an OpenAI-compatible inference endpoint.
+
+The CLI hides all of this behind a few commands. Edit `provider/.env` if you need to override the model, gateway URL, or relay endpoint.
+
+## Links
+
+- Repository — https://github.com/skyyycodes/zkai-eth
+- Dashboard — https://zkai-ether-og.vercel.app
+- 0G chain explorer — https://chainscan.0g.ai
+
+## License
+
+MIT

zkai_cli-0.5.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+zkai_cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+zkai_cli/__main__.py,sha256=zAZUVLhNWmbUyWyCXEJaoQVhcrizYzUzdwCWhWwkt08,68
+zkai_cli/docker.py,sha256=YpeQ_erk_HAYM3V8bNy7ux2zbD7Crgu15XeXzz20pHk,9741
+zkai_cli/keys.py,sha256=xcGEd-xOw4PRd0v3AnpWLVdvmM9N3XJrbiYx27P8Z2M,894
+zkai_cli/main.py,sha256=LB2izVjeQpLN1CyeNUm9DWoi2K_NYghfFLmZ4gYa9j4,5225
+zkai_cli/register.py,sha256=mdUqQpTnJy_do9wI9hk5u3Pp0c1gzBfF5rjhLzys2ss,9235
+zkai_cli/setup.py,sha256=KPjJHYfEp50crm1eFqcpIyjpanapWgbX4TYD2Wr4NGY,4716
+zkai_cli/util.py,sha256=hiDGC7IMt_UdD0iwmRVfzz8-bNxreHEq6ZGP0qI-WM8,4952
+zkai_cli-0.5.0.dist-info/METADATA,sha256=EmKq4SZjvC_vPTJxnI_7uRwJ0WqpOvySeD-B7kknIY8,3866
+zkai_cli-0.5.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+zkai_cli-0.5.0.dist-info/entry_points.txt,sha256=syWg-3FI522vjYjZHjcfuOpEU1w-e8so3fHCzd9LESs,43
+zkai_cli-0.5.0.dist-info/RECORD,,

zkai_cli-0.5.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

zkai_cli-0.5.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+zkai = zkai_cli.main:app