xelta-cli 0.1.0__py3-none-any.whl

xelta/auth.py

@@ -0,0 +1,28 @@
+import json
+from pathlib import Path
+
+CONFIG_DIR = Path.home() / ".xelta"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+
+
+def save_token(token: str) -> None:
+    CONFIG_DIR.mkdir(exist_ok=True)
+    CONFIG_FILE.write_text(json.dumps({"jwt": token}))
+    try:
+        CONFIG_FILE.chmod(0o600)
+    except Exception:
+        pass
+
+
+def load_token() -> str | None:
+    if not CONFIG_FILE.exists():
+        return None
+    try:
+        return json.loads(CONFIG_FILE.read_text()).get("jwt")
+    except Exception:
+        return None
+
+
+def delete_token() -> None:
+    if CONFIG_FILE.exists():
+        CONFIG_FILE.unlink()

xelta/cli.py

@@ -0,0 +1,102 @@
+import typer
+from rich.console import Console
+from xelta.auth import save_token, delete_token, load_token
+from xelta.commands.status import status_cmd
+from xelta.commands.balance import balance_cmd
+from xelta.commands.image import image_cmd
+from xelta.commands.mixboard import mixboard_cmd
+from xelta.commands.street_ad import street_ad_cmd
+from xelta.commands.reel import reel_cmd
+from xelta.commands import website
+
+console = Console()
+
+app = typer.Typer(
+    name="xelta",
+    help="Official CLI for xelta.ai — generate images, reels, websites, and more.",
+    no_args_is_help=True,
+    rich_markup_mode="rich",
+)
+
+
+@app.command()
+def login(
+    token: str = typer.Option(None, "--token", "-t", help="Paste a JWT directly instead of browser login"),
+):
+    """Authenticate with your Xelta account via browser."""
+    if token:
+        save_token(token.strip())
+        console.print("[green]Logged in successfully.[/green]")
+        return
+
+    try:
+        from xelta.oauth import browser_login
+        console.print("[bold]Opening browser for Xelta login...[/bold]")
+        jwt = browser_login()
+        save_token(jwt)
+        console.print("[green]Logged in successfully.[/green]")
+    except Exception as e:
+        console.print(f"[red]Login failed:[/red] {e}")
+        raise typer.Exit(1)
+
+
+@app.command()
+def logout():
+    """Remove stored credentials."""
+    delete_token()
+    console.print("Logged out.")
+
+
+@app.command()
+def status(debug: bool = typer.Option(False, "--debug", help="Show token prefix and raw API error")):
+    """Check authentication status and API connectivity."""
+    status_cmd(debug=debug)
+
+
+@app.command()
+def balance():
+    """Check your Xelta credit balance."""
+    balance_cmd()
+
+
+@app.command()
+def image(
+    prompt: str = typer.Argument(..., help="Description of the image to generate"),
+    model: str = typer.Option(None, "--model", "-m", help="Model ID (skip interactive picker)"),
+    size: str = typer.Option(None, "--size", "-s", help="Resolution: 1080p, 2K, or 4K"),
+    no_optimize: bool = typer.Option(False, "--no-optimize", help="Disable prompt enhancement"),
+):
+    """Generate an image from a text prompt."""
+    image_cmd(prompt=prompt, model=model, size=size, no_optimize=no_optimize)
+
+
+@app.command()
+def mixboard(
+    prompt: str = typer.Argument(..., help="Creative prompt for the image grid"),
+    num: int = typer.Option(8, "--num", "-n", help="Number of images"),
+):
+    """Generate a mixboard — a grid of AI images from a prompt."""
+    mixboard_cmd(prompt=prompt, num=num)
+
+
+@app.command(name="street-ad")
+def street_ad(
+    brand: str = typer.Argument(..., help="Brand name to feature"),
+    style: str = typer.Option("auto", "--style", help="Art style: auto, graffiti, stencil, wildstyle"),
+    surface: str = typer.Option("brick", "--surface", help="Surface: brick, wall, concrete"),
+    logo: str = typer.Option(None, "--logo", help="Path or URL to logo image"),
+):
+    """Generate a street art / graffiti-style ad for a brand."""
+    street_ad_cmd(brand=brand, style=style, surface=surface, logo=logo)
+
+
+@app.command()
+def reel(
+    prompt: str = typer.Argument(..., help="Description of the reel to generate"),
+    image: str = typer.Option(None, "--image", help="Path or URL to an image to include"),
+):
+    """Generate a short AI video reel from a text prompt."""
+    reel_cmd(prompt=prompt, image=image)
+
+
+app.add_typer(website.app, name="website")

xelta/commands/balance.py

@@ -0,0 +1,26 @@
+import asyncio
+import httpx
+import typer
+from rich.console import Console
+from xelta.config import LIPSYNC_BASE_URL, cookie_headers
+
+console = Console()
+
+
+def balance_cmd():
+    """Check your Xelta credit balance."""
+    asyncio.run(_balance())
+
+
+async def _balance():
+    async with httpx.AsyncClient() as client:
+        r = await client.get(
+            f"{LIPSYNC_BASE_URL}/api/v1/credits/balance",
+            headers=cookie_headers(),
+            timeout=10,
+        )
+        r.raise_for_status()
+        data = r.json()
+        bal = data.get("balance", 0)
+        cur = data.get("currency", "credits")
+        console.print(f"[bold green]Balance:[/bold green] {bal} {cur}")

xelta/commands/image.py

@@ -0,0 +1,111 @@
+import asyncio
+from typing import Optional
+import httpx
+import typer
+from rich.console import Console
+from rich.table import Table
+from xelta.config import IMAGE_GEN_BASE_URL, LIPSYNC_BASE_URL, auth_headers, cookie_headers
+
+console = Console()
+
+
+def image_cmd(
+    prompt: str = typer.Argument(..., help="Description of the image to generate"),
+    model: Optional[str] = typer.Option(None, "--model", "-m", help="Model ID (skip interactive picker)"),
+    size: Optional[str] = typer.Option(None, "--size", "-s", help="Resolution: 1080p, 2K, or 4K"),
+    no_optimize: bool = typer.Option(False, "--no-optimize", help="Disable prompt enhancement"),
+):
+    """Generate an image from a text prompt."""
+    asyncio.run(_image(prompt, model, size, not no_optimize))
+
+
+async def _image(prompt: str, model_id: str | None, size: str | None, optimize: bool):
+    async with httpx.AsyncClient() as client:
+        # Check credits first
+        r = await client.get(
+            f"{LIPSYNC_BASE_URL}/api/v1/credits/balance",
+            headers=cookie_headers(),
+            timeout=10,
+        )
+        r.raise_for_status()
+        if r.json().get("balance", 0) <= 0:
+            console.print("[red]No credits remaining.[/red] Top up at https://www.xelta.ai")
+            raise typer.Exit(1)
+
+        # Step 1: Pick model
+        if not model_id:
+            r = await client.get(
+                f"{IMAGE_GEN_BASE_URL}/api/models/image_generation/all",
+                headers=auth_headers(),
+                timeout=15,
+            )
+            r.raise_for_status()
+            models = r.json().get("data", [])
+            if not models:
+                console.print("[red]No models available.[/red]")
+                raise typer.Exit(1)
+
+            table = Table(title="Available Models", show_lines=True)
+            table.add_column("#", style="bold cyan", width=4)
+            table.add_column("Name", style="bold")
+            table.add_column("ID")
+            table.add_column("Credits", justify="right")
+            table.add_column("Est. Time")
+            for i, m in enumerate(models, 1):
+                table.add_row(
+                    str(i),
+                    m.get("displayName", ""),
+                    m.get("modelId", ""),
+                    str(m.get("creditCost", "?")),
+                    str(m.get("estimatedTime", "?")),
+                )
+            console.print(table)
+            choice = typer.prompt("Pick a model number")
+            try:
+                model_id = models[int(choice) - 1]["modelId"]
+            except (ValueError, IndexError):
+                console.print("[red]Invalid choice.[/red]")
+                raise typer.Exit(1)
+
+        # Step 2: Pick size
+        if not size:
+            console.print("\n[bold]Choose a resolution:[/bold]")
+            console.print("  1. 1080p — standard HD")
+            console.print("  2. 2K    — sharp detail")
+            console.print("  3. 4K    — ultra-high resolution (more credits)")
+            size_map = {"1": "1080p", "2": "2K", "3": "4K"}
+            s = typer.prompt("Pick a size (1/2/3)", default="2")
+            size = size_map.get(s, "2K")
+
+        # Step 3: Generate
+        console.print(f"\n[dim]Generating with model [bold]{model_id}[/bold] at {size}...[/dim]")
+        payload = {
+            "prompt": prompt,
+            "size": size,
+            "optimize_prompt_options": {"mode": "standard" if optimize else "none"},
+        }
+        r = await client.post(
+            f"{IMAGE_GEN_BASE_URL}/api/models/{model_id}/generate",
+            headers={**auth_headers(), "Content-Type": "application/json"},
+            json=payload,
+            timeout=120,
+        )
+        r.raise_for_status()
+        resp = r.json()
+
+        result = resp.get("data", {}).get("result", {})
+        image_url = result.get("content", "")
+        if not image_url:
+            console.print(f"[red]Generation failed:[/red] {resp}")
+            raise typer.Exit(1)
+
+        meta = resp.get("metadata", {})
+        res_meta = result.get("metadata", {})
+        console.print(f"\n[bold green]Image ready![/bold green]")
+        console.print(f"  Model:      {meta.get('modelName', model_id)}")
+        console.print(f"  Resolution: {res_meta.get('size', size)}")
+        console.print(f"  Time:       {meta.get('executionTime', '?')}")
+        console.print(f"  [bold]URL:[/bold]        {image_url}")
+        bal = resp.get("creditTransaction", {}).get("newBalance")
+        if bal is not None:
+            console.print(f"  Balance:    {bal} credits remaining")

xelta/commands/mixboard.py

@@ -0,0 +1,89 @@
+import asyncio
+import httpx
+import typer
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from xelta.config import MIXBOARD_BASE_URL, LIPSYNC_BASE_URL, auth_headers, cookie_headers
+from xelta.auth import load_token
+import base64, json
+
+console = Console()
+
+
+def _user_id() -> str:
+    token = load_token() or ""
+    try:
+        payload = token.split(".")[1]
+        payload += "=" * (4 - len(payload) % 4)
+        return str(json.loads(base64.urlsafe_b64decode(payload)).get("id", ""))
+    except Exception:
+        return ""
+
+
+def mixboard_cmd(
+    prompt: str = typer.Argument(..., help="Creative prompt for the image grid"),
+    num: int = typer.Option(8, "--num", "-n", help="Number of images (default: 8)"),
+):
+    """Generate a mixboard — a grid of AI images from a prompt."""
+    asyncio.run(_mixboard(prompt, num))
+
+
+async def _mixboard(prompt: str, num_images: int):
+    async with httpx.AsyncClient(timeout=60) as client:
+        r = await client.get(
+            f"{LIPSYNC_BASE_URL}/api/v1/credits/balance",
+            headers=cookie_headers(),
+            timeout=10,
+        )
+        r.raise_for_status()
+        if r.json().get("balance", 0) <= 0:
+            console.print("[red]No credits remaining.[/red] Top up at https://www.xelta.ai")
+            raise typer.Exit(1)
+
+        r = await client.post(
+            f"{MIXBOARD_BASE_URL}/api/mixboards/",
+            json={"command": prompt, "user_id": _user_id(), "num_images": num_images},
+            headers=auth_headers(),
+            timeout=30,
+        )
+        r.raise_for_status()
+        board_id = r.json().get("id")
+        if not board_id:
+            console.print(f"[red]Unexpected response:[/red] {r.json()}")
+            raise typer.Exit(1)
+
+        console.print(f"[dim]Mixboard created (id: {board_id}). Generating {num_images} images...[/dim]")
+
+        progress_url = f"{MIXBOARD_BASE_URL}/api/mixboards/{board_id}/progress"
+        timed_out = True
+        for _ in range(60):
+            await asyncio.sleep(5)
+            pr = await client.get(progress_url, headers=auth_headers(), timeout=15)
+            if pr.status_code == 200:
+                pct = pr.json().get("progress_percent", 0)
+                console.print(f"  [dim]{pct}%[/dim]", end="\r")
+                if pct >= 100:
+                    timed_out = False
+                    break
+
+        if timed_out:
+            console.print(f"[yellow]Timed out.[/yellow] Check board manually: {board_id}")
+            raise typer.Exit(1)
+
+        board_r = await client.get(
+            f"{MIXBOARD_BASE_URL}/api/mixboards/{board_id}",
+            headers=auth_headers(),
+            timeout=15,
+        )
+        board_r.raise_for_status()
+        images = [img for img in board_r.json().get("images", []) if img.get("status") == "completed"]
+
+        if not images:
+            console.print(f"[yellow]No images returned yet.[/yellow] Board ID: {board_id}")
+            raise typer.Exit(1)
+
+        console.print(f"\n[bold green]Mixboard ready![/bold green] {len(images)} images:")
+        for i, img in enumerate(images, 1):
+            url = img.get("image_url", "")
+            if url:
+                console.print(f"  {i}. {url}")

xelta/commands/reel.py

@@ -0,0 +1,116 @@
+import asyncio
+from typing import Optional
+import httpx
+import typer
+from rich.console import Console
+from xelta.config import REEL_BASE_URL, LIPSYNC_BASE_URL, auth_headers, cookie_headers
+
+console = Console()
+
+
+def reel_cmd(
+    prompt: str = typer.Argument(..., help="Description of the reel to generate"),
+    image: Optional[str] = typer.Option(None, "--image", help="Path or URL to an image to include"),
+):
+    """Generate a short AI video reel from a text prompt."""
+    asyncio.run(_reel(prompt, image or ""))
+
+
+async def _reel(prompt: str, image_path: str):
+    async with httpx.AsyncClient(timeout=60) as client:
+        r = await client.get(
+            f"{LIPSYNC_BASE_URL}/api/v1/credits/balance",
+            headers=cookie_headers(),
+            timeout=10,
+        )
+        r.raise_for_status()
+        if r.json().get("balance", 0) <= 0:
+            console.print("[red]No credits remaining.[/red] Top up at https://www.xelta.ai")
+            raise typer.Exit(1)
+
+        console.print(f"[dim]Submitting reel prompt...[/dim]")
+        r = await client.post(
+            f"{REEL_BASE_URL}/api/reels",
+            json={"prompt": prompt},
+            headers=auth_headers(),
+            timeout=30,
+        )
+        r.raise_for_status()
+        reel_id = r.json().get("id")
+        if not reel_id:
+            console.print(f"[red]Unexpected response:[/red] {r.json()}")
+            raise typer.Exit(1)
+
+        if image_path:
+            img_bytes, img_name = await _load_file(client, image_path)
+            ext = img_name.rsplit(".", 1)[-1].lower() if "." in img_name else "jpg"
+            await client.post(
+                f"{REEL_BASE_URL}/api/reels/{reel_id}/upload-image",
+                files={"image": (img_name, img_bytes, f"image/{ext}")},
+                headers=auth_headers(),
+                timeout=30,
+            )
+
+        gen = await client.post(
+            f"{REEL_BASE_URL}/api/reels/{reel_id}/generate",
+            headers=auth_headers(),
+            timeout=30,
+        )
+        gen.raise_for_status()
+        console.print(f"[dim]Rendering... (this can take up to 6 minutes)[/dim]")
+
+        for _ in range(72):
+            await asyncio.sleep(5)
+            st = await client.get(
+                f"{REEL_BASE_URL}/api/reels/{reel_id}",
+                headers=auth_headers(),
+                timeout=15,
+            )
+            if st.status_code == 200:
+                data = st.json()
+                status = str(data.get("status", "")).lower()
+                progress = data.get("progress_percent", 0)
+                console.print(f"  [dim]{progress}%[/dim]", end="\r")
+                if status == "completed" or progress >= 100:
+                    video_url = data.get("video_url", "")
+                    if video_url:
+                        _print_result(reel_id, video_url)
+                        return
+                    break
+                if status in ("failed", "error"):
+                    console.print(f"[red]Failed:[/red] {data.get('error_message') or data}")
+                    raise typer.Exit(1)
+
+        # Fall back to history
+        hist = await client.get(
+            f"{REEL_BASE_URL}/api/reels/history",
+            headers=auth_headers(),
+            timeout=15,
+        )
+        if hist.status_code == 200:
+            for item in hist.json().get("items", []):
+                if str(item.get("id")) == str(reel_id):
+                    video_url = item.get("video_url", "")
+                    if video_url:
+                        _print_result(reel_id, video_url)
+                        return
+
+        console.print(f"[yellow]Timed out.[/yellow] Reel ID: {reel_id}")
+
+
+def _print_result(reel_id: str, video_url: str):
+    console.print(f"\n[bold green]Reel ready![/bold green]")
+    console.print(f"  Video:   {video_url}")
+    console.print(f"  Reel ID: {reel_id}")
+
+
+async def _load_file(client: httpx.AsyncClient, path_or_url: str) -> tuple[bytes, str]:
+    if path_or_url.startswith("http://") or path_or_url.startswith("https://"):
+        r = await client.get(path_or_url, follow_redirects=True, timeout=60)
+        r.raise_for_status()
+        name = path_or_url.split("/")[-1].split("?")[0] or "image.jpg"
+        return r.content, name
+    import os
+    path = os.path.normpath(path_or_url)
+    with open(path, "rb") as f:
+        return f.read(), os.path.basename(path)

xelta/commands/status.py

@@ -0,0 +1,61 @@
+import asyncio
+import base64
+import json
+import httpx
+import typer
+from rich.console import Console
+from xelta.auth import load_token
+from xelta.config import LIPSYNC_BASE_URL, cookie_headers
+
+console = Console()
+
+
+def status_cmd(debug: bool = typer.Option(False, "--debug", help="Show token prefix and raw API error")):
+    """Check authentication status and API connectivity."""
+    asyncio.run(_status(debug))
+
+
+async def _status(debug: bool):
+    token = load_token()
+    if not token:
+        console.print("[red]Not logged in.[/red] Run `xelta login` to authenticate.")
+        raise typer.Exit(1)
+
+    user_id, email = _decode_jwt(token)
+    is_jwt = token.startswith("eyJ")
+
+    console.print("[bold]Xelta CLI — connection status[/bold]")
+    console.print(f"  Auth:    [green]logged in[/green]")
+    console.print(f"  Token:   {'JWT ✓' if is_jwt else '[yellow]not a JWT (starts with: ' + token[:12] + '...)[/yellow]'}")
+    if user_id:
+        console.print(f"  User ID: {user_id}")
+    if email:
+        console.print(f"  Email:   {email}")
+
+    try:
+        async with httpx.AsyncClient() as client:
+            r = await client.get(
+                f"{LIPSYNC_BASE_URL}/api/v1/credits/balance",
+                headers=cookie_headers(),
+                timeout=10,
+            )
+            if debug:
+                console.print(f"  [dim]Status: {r.status_code} | Body: {r.text[:200]}[/dim]")
+            r.raise_for_status()
+            bal = r.json().get("balance", 0)
+            console.print(f"  Balance: {bal} credits")
+            console.print(f"  API:     [green]reachable[/green]")
+    except Exception as e:
+        console.print(f"  API:     [red]unreachable[/red]")
+        if debug:
+            console.print(f"  [dim]{e}[/dim]")
+
+
+def _decode_jwt(token: str) -> tuple[str, str]:
+    try:
+        payload = token.split(".")[1]
+        payload += "=" * (4 - len(payload) % 4)
+        data = json.loads(base64.urlsafe_b64decode(payload))
+        return str(data.get("id") or data.get("sub") or ""), str(data.get("email") or "")
+    except Exception:
+        return "", ""

xelta/commands/street_ad.py

@@ -0,0 +1,86 @@
+import asyncio
+from typing import Optional
+import httpx
+import typer
+from rich.console import Console
+from xelta.config import STREETAD_BASE_URL, LIPSYNC_BASE_URL, auth_headers, cookie_headers
+
+console = Console()
+
+
+def street_ad_cmd(
+    brand: str = typer.Argument(..., help="Brand name to feature"),
+    style: str = typer.Option("auto", "--style", help="Art style: auto, graffiti, stencil, wildstyle"),
+    surface: str = typer.Option("brick", "--surface", help="Surface: brick, wall, concrete"),
+    logo: Optional[str] = typer.Option(None, "--logo", help="Path or URL to logo image"),
+):
+    """Generate a street art / graffiti-style ad for a brand."""
+    asyncio.run(_street_ad(brand, style, surface, logo or ""))
+
+
+async def _street_ad(brand: str, style: str, surface: str, logo_path: str):
+    async with httpx.AsyncClient(timeout=60) as client:
+        r = await client.get(
+            f"{LIPSYNC_BASE_URL}/api/v1/credits/balance",
+            headers=cookie_headers(),
+            timeout=10,
+        )
+        r.raise_for_status()
+        if r.json().get("balance", 0) <= 0:
+            console.print("[red]No credits remaining.[/red] Top up at https://www.xelta.ai")
+            raise typer.Exit(1)
+
+        form: dict = {"brand": brand, "style": style, "surface": surface}
+        files = None
+        if logo_path:
+            logo_bytes, logo_name = await _load_file(client, logo_path)
+            files = {"logo": (logo_name, logo_bytes, "image/png")}
+
+        console.print(f"[dim]Generating street ad for [bold]{brand}[/bold]...[/dim]")
+        r = await client.post(
+            f"{STREETAD_BASE_URL}/generate",
+            data=form,
+            files=files,
+            headers=auth_headers(),
+            timeout=60,
+        )
+        r.raise_for_status()
+        generation_id = r.json().get("generation_id")
+        if not generation_id:
+            console.print(f"[red]Unexpected response:[/red] {r.json()}")
+            raise typer.Exit(1)
+
+        result = await _poll(client, f"{STREETAD_BASE_URL}/status/{generation_id}")
+        console.print("\n[bold green]Street ad ready![/bold green]")
+        if result.get("output_image_url"):
+            console.print(f"  Image: {result['output_image_url']}")
+        if result.get("output_video_url"):
+            console.print(f"  Video: {result['output_video_url']}")
+
+
+async def _load_file(client: httpx.AsyncClient, path_or_url: str) -> tuple[bytes, str]:
+    if path_or_url.startswith("http://") or path_or_url.startswith("https://"):
+        r = await client.get(path_or_url, follow_redirects=True, timeout=60)
+        r.raise_for_status()
+        name = path_or_url.split("/")[-1].split("?")[0] or "logo.png"
+        return r.content, name
+    import os
+    path = os.path.normpath(path_or_url)
+    with open(path, "rb") as f:
+        return f.read(), os.path.basename(path)
+
+
+async def _poll(client: httpx.AsyncClient, url: str, interval: int = 5, timeout: int = 300) -> dict:
+    elapsed = 0
+    while elapsed < timeout:
+        await asyncio.sleep(interval)
+        elapsed += interval
+        r = await client.get(url, headers=auth_headers(), timeout=15)
+        r.raise_for_status()
+        data = r.json()
+        status = str(data.get("status") or data.get("state") or "").lower()
+        if status in ("completed", "done", "success", "finished"):
+            return data
+        if status in ("failed", "error", "cancelled"):
+            raise RuntimeError(f"Job failed: {data.get('error') or data}")
+    raise TimeoutError(f"Job timed out after {timeout}s")

xelta/commands/website.py

@@ -0,0 +1,159 @@
+import asyncio
+from typing import Optional
+import httpx
+import typer
+from rich.console import Console
+from xelta.config import WEBBUILDER_BASE_URL, LIPSYNC_BASE_URL, auth_headers, cookie_headers
+
+console = Console()
+app = typer.Typer(help="AI website builder commands")
+
+
+@app.command("build")
+def build_cmd(
+    prompt: str = typer.Argument(..., help="Description of the website to generate"),
+    industry: str = typer.Option(..., "--industry", "-i", help="Industry: technology, healthcare, fashion, etc."),
+    pages: str = typer.Option("Home, About, Contact", "--pages", "-p", help="Comma-separated page list"),
+    palette: Optional[str] = typer.Option(None, "--palette", help="Color palette name or hex values"),
+    logo: Optional[str] = typer.Option(None, "--logo", help="Path or URL to logo image"),
+    deploy: bool = typer.Option(False, "--deploy", help="Deploy live to Vercel after generation"),
+):
+    """Generate an AI website using the Pomeli Website Builder."""
+    asyncio.run(_build(prompt, industry, pages, palette or "", logo or "", deploy))
+
+
+@app.command("history")
+def history_cmd(
+    limit: int = typer.Option(5, "--limit", "-n", help="Number of recent websites to show"),
+):
+    """List recently generated websites."""
+    asyncio.run(_history(limit))
+
+
+async def _build(prompt: str, industry: str, pages: str, palette: str, logo_path: str, deploy: bool):
+    async with httpx.AsyncClient(timeout=60) as client:
+        r = await client.get(
+            f"{LIPSYNC_BASE_URL}/api/v1/credits/balance",
+            headers=cookie_headers(),
+            timeout=10,
+        )
+        r.raise_for_status()
+        if r.json().get("balance", 0) <= 0:
+            console.print("[red]No credits remaining.[/red] Top up at https://www.xelta.ai")
+            raise typer.Exit(1)
+
+        page_list = [p.strip() for p in pages.split(",") if p.strip()]
+        multipart = [
+            ("prompt", (None, prompt)),
+            ("industry", (None, industry)),
+        ]
+        for page in page_list:
+            multipart.append(("pages", (None, page)))
+        if palette:
+            multipart.append(("palette", (None, palette)))
+        if logo_path:
+            logo_bytes, logo_name = await _load_file(client, logo_path)
+            multipart.append(("logo", (logo_name, logo_bytes, "image/png")))
+
+        console.print(f"[dim]Generating website...[/dim]")
+        r = await client.post(
+            f"{WEBBUILDER_BASE_URL}/generate",
+            files=multipart,
+            headers=auth_headers(),
+            timeout=60,
+        )
+        r.raise_for_status()
+        result = r.json()
+        job_id = result.get("job_id")
+        website_id = result.get("website_id")
+        if not job_id:
+            console.print(f"[red]Unexpected response:[/red] {result}")
+            raise typer.Exit(1)
+
+        for _ in range(60):
+            await asyncio.sleep(5)
+            st = await client.get(
+                f"{WEBBUILDER_BASE_URL}/job-status/{job_id}",
+                headers=auth_headers(),
+                timeout=15,
+            )
+            if st.status_code == 200:
+                st_data = st.json()
+                status = str(st_data.get("status", "")).lower()
+                website_id = st_data.get("website_id", website_id)
+                if status == "completed":
+                    raw_preview = st_data.get("preview_url", "")
+                    preview_url = (
+                        f"{WEBBUILDER_BASE_URL}{raw_preview}"
+                        if raw_preview and not raw_preview.startswith("http")
+                        else raw_preview or f"{WEBBUILDER_BASE_URL}/preview/{website_id}/index.html"
+                    )
+                    if deploy:
+                        dep = await client.post(
+                            f"{WEBBUILDER_BASE_URL}/deploy",
+                            json={"website_id": website_id},
+                            headers=auth_headers(),
+                            timeout=60,
+                        )
+                        if dep.status_code == 200:
+                            dep_data = dep.json()
+                            live_url = (
+                                dep_data.get("final_url")
+                                or dep_data.get("url")
+                                or dep_data.get("deployment_url")
+                                or dep_data.get("vercel_url", "")
+                            )
+                            console.print("\n[bold green]Website built and deployed![/bold green]")
+                            if live_url:
+                                console.print(f"  Live:       {live_url}")
+                            console.print(f"  Preview:    {preview_url}")
+                            console.print(f"  Website ID: {website_id}")
+                            return
+                    console.print("\n[bold green]Website generated![/bold green]")
+                    console.print(f"  Preview:    {preview_url}")
+                    console.print(f"  Website ID: {website_id}")
+                    return
+                if status in ("failed", "error"):
+                    console.print(f"[red]Generation failed:[/red] {st_data}")
+                    raise typer.Exit(1)
+
+        console.print(f"[yellow]Timed out.[/yellow] Website ID: {website_id}")
+
+
+async def _history(limit: int):
+    async with httpx.AsyncClient(timeout=30) as client:
+        r = await client.get(
+            f"{WEBBUILDER_BASE_URL}/history",
+            headers=auth_headers(),
+            timeout=15,
+        )
+        r.raise_for_status()
+        data = r.json()
+        items = data if isinstance(data, list) else data.get("items", [])
+        if not items:
+            console.print("No websites found.")
+            return
+        console.print(f"[bold]Last {min(limit, len(items))} website(s):[/bold]\n")
+        for site in items[:limit]:
+            name = site.get("site_name") or site.get("website_id", "Unnamed")
+            status = site.get("status", "")
+            console.print(f"  [bold]{name}[/bold] [{status}]")
+            if site.get("final_url"):
+                console.print(f"    Live:    {site['final_url']}")
+            if site.get("preview_url"):
+                preview = site["preview_url"]
+                if not preview.startswith("http"):
+                    preview = f"{WEBBUILDER_BASE_URL}{preview}"
+                console.print(f"    Preview: {preview}")
+
+
+async def _load_file(client: httpx.AsyncClient, path_or_url: str) -> tuple[bytes, str]:
+    if path_or_url.startswith("http://") or path_or_url.startswith("https://"):
+        r = await client.get(path_or_url, follow_redirects=True, timeout=60)
+        r.raise_for_status()
+        name = path_or_url.split("/")[-1].split("?")[0] or "logo.png"
+        return r.content, name
+    import os
+    path = os.path.normpath(path_or_url)
+    with open(path, "rb") as f:
+        return f.read(), os.path.basename(path)

xelta/config.py

@@ -0,0 +1,30 @@
+from xelta.auth import load_token
+
+LIPSYNC_BASE_URL    = "https://lipsyncus.xelta.ai"
+MIXBOARD_BASE_URL   = "https://mixboard.xelta.ai"
+STREETAD_BASE_URL   = "https://grf.xelta.ai"
+WEBBUILDER_BASE_URL = "https://webgen.xelta.ai"
+REEL_BASE_URL       = "https://reel.xelta.ai"
+IMAGE_GEN_BASE_URL  = "https://vygxif9kfe.execute-api.ap-south-1.amazonaws.com"
+
+_BROWSER = {
+    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+    "Accept": "application/json",
+    "Origin": "https://www.xelta.ai",
+    "Referer": "https://www.xelta.ai/",
+}
+
+
+def auth_headers() -> dict:
+    token = load_token()
+    if not token:
+        raise RuntimeError("Not logged in. Run `xelta login` first.")
+    return {**_BROWSER, "Authorization": f"Bearer {token}"}
+
+
+def cookie_headers() -> dict:
+    """Cookie-based auth used by lipsync, comic, and similar services."""
+    token = load_token()
+    if not token:
+        raise RuntimeError("Not logged in. Run `xelta login` first.")
+    return {**_BROWSER, "Cookie": f"token={token}"}

xelta/oauth.py

@@ -0,0 +1,113 @@
+import base64
+import hashlib
+import http.server
+import secrets
+import webbrowser
+from urllib.parse import parse_qs, urlencode, urlparse
+
+import httpx
+
+XELTA_AUTHORIZE_URL = "https://api.xelta.ai/api/auth/oauth/authorize"
+XELTA_TOKEN_URL     = "https://api.xelta.ai/api/auth/oauth/token"
+CLI_CLIENT_ID       = "xelta-cli"
+CALLBACK_PORT       = 8787
+REDIRECT_URI        = f"http://localhost:{CALLBACK_PORT}/callback"
+
+_SUCCESS_HTML = b"""<!DOCTYPE html>
+<html>
+<head><meta charset="utf-8"><title>Xelta CLI</title>
+<style>body{font-family:-apple-system,sans-serif;display:flex;align-items:center;
+justify-content:center;min-height:100vh;margin:0;background:#f5f5f7}
+.card{text-align:center;padding:48px 40px;background:#fff;border-radius:16px;
+box-shadow:0 4px 24px rgba(0,0,0,.08);max-width:380px}
+h2{color:#111;margin:0 0 12px}p{color:#555;margin:0}</style></head>
+<body><div class="card">
+<div style="font-size:48px;margin-bottom:16px">&#10003;</div>
+<h2>Logged in to Xelta!</h2>
+<p>You can close this tab and return to the terminal.</p>
+</div></body></html>"""
+
+_ERROR_HTML = b"""<!DOCTYPE html>
+<html><head><meta charset="utf-8"><title>Xelta CLI</title></head>
+<body style="font-family:sans-serif;text-align:center;padding:60px">
+<h2>Login failed</h2><p>Return to the terminal for details.</p>
+</body></html>"""
+
+
+def _pkce_pair() -> tuple[str, str]:
+    verifier = secrets.token_urlsafe(64)
+    challenge = base64.urlsafe_b64encode(
+        hashlib.sha256(verifier.encode()).digest()
+    ).rstrip(b"=").decode()
+    return verifier, challenge
+
+
+def browser_login() -> str:
+    """Open the browser, complete OAuth PKCE flow, return JWT access_token."""
+    verifier, challenge = _pkce_pair()
+    state = secrets.token_urlsafe(16)
+
+    params = {
+        "response_type": "code",
+        "client_id": CLI_CLIENT_ID,
+        "redirect_uri": REDIRECT_URI,
+        "state": state,
+        "code_challenge": challenge,
+        "code_challenge_method": "S256",
+    }
+    auth_url = f"{XELTA_AUTHORIZE_URL}?{urlencode(params)}"
+
+    result: dict = {}
+
+    class _Handler(http.server.BaseHTTPRequestHandler):
+        def do_GET(self):
+            qs = parse_qs(urlparse(self.path).query)
+            result["code"]  = qs.get("code",  [None])[0]
+            result["state"] = qs.get("state", [None])[0]
+            result["error"] = qs.get("error", [None])[0]
+            ok = result["code"] and result["state"] == state
+            self.send_response(200)
+            self.send_header("Content-Type", "text/html")
+            self.end_headers()
+            self.wfile.write(_SUCCESS_HTML if ok else _ERROR_HTML)
+
+        def log_message(self, *args):
+            pass
+
+    server = http.server.HTTPServer(("localhost", CALLBACK_PORT), _Handler)
+    webbrowser.open(auth_url)
+
+    print(f"Browser opened. Waiting for login...")
+    server.handle_request()
+    server.server_close()
+
+    if result.get("error"):
+        raise RuntimeError(f"Login cancelled or failed: {result['error']}")
+    if result.get("state") != state:
+        raise RuntimeError("State mismatch — login aborted for security.")
+
+    code = result.get("code")
+    if not code:
+        raise RuntimeError("No authorization code received.")
+
+    return _exchange_code(code, verifier)
+
+
+def _exchange_code(code: str, verifier: str) -> str:
+    with httpx.Client(timeout=15) as client:
+        r = client.post(
+            XELTA_TOKEN_URL,
+            data={
+                "grant_type": "authorization_code",
+                "code": code,
+                "client_id": CLI_CLIENT_ID,
+                "redirect_uri": REDIRECT_URI,
+                "code_verifier": verifier,
+            },
+            headers={"Accept": "application/json"},
+        )
+        r.raise_for_status()
+        token = r.json().get("access_token", "")
+        if not token:
+            raise RuntimeError(f"No access_token in response: {r.text}")
+        return token

xelta_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: xelta-cli
+Version: 0.1.0
+Summary: Official CLI for xelta.ai
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27
+Requires-Dist: typer>=0.12
+Requires-Dist: rich>=13

xelta_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+xelta/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+xelta/auth.py,sha256=ireuAfqjkj0AoIz9lgI-9nVWA5Y-1cAw-4WFiKbncyw,609
+xelta/cli.py,sha256=LiKKAVAUsfZEUpt5sv9wWOlJ5gdMVQexcQCrqeQhdh8,3429
+xelta/config.py,sha256=BIG71PldUtU3R2OpUj3TUeFZ4L1nlsHawiq0uIw2x_o,1039
+xelta/oauth.py,sha256=23eEOmGPIXNaDgsoc7jbHOGN7JTg1z7npSZIX8N9bkI,3906
+xelta/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+xelta/commands/balance.py,sha256=ggyzjBVfNbaGzySQpW84uwULBbDB5OlDFPymvsSAytI,683
+xelta/commands/image.py,sha256=KNyIpWNhQ83dbhbrDim4DypQjkhhdWG1m4TIhdBIfLQ,4563
+xelta/commands/mixboard.py,sha256=1EYXZcXAnQDfNDvxvt5lDEadCCl3dnPf0f_0W7-QDCw,3238
+xelta/commands/reel.py,sha256=6ts1ctpkRIgEeRzPiBjLslW2cXlcUbyiZPD0WxltamU,4378
+xelta/commands/status.py,sha256=ifHVVmbHJKXCM6ODCC1ph3zQ4Dbgio5rGlG8TfCWdrg,2102
+xelta/commands/street_ad.py,sha256=AAgOUZCHhh5QLibwoF_PxB-pKwUTqBrRsDpKjlvpfH0,3550
+xelta/commands/website.py,sha256=bK12fnqNCry-9uhFfrBt6dR6QZBk5DOPwVQXCSrI1cg,6929
+xelta_cli-0.1.0.dist-info/METADATA,sha256=VGes6GJmH_FMKstFxjCmQKwBskz2JbhGvpGQnkkU-mY,198
+xelta_cli-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+xelta_cli-0.1.0.dist-info/entry_points.txt,sha256=g52sxEdYSTdhdBxmFXClez7tW2m3vos2vTT0XbpS0UY,40
+xelta_cli-0.1.0.dist-info/top_level.txt,sha256=2IxOL5iARzoQ5JLl5CkSm9x31qdiOTTdM03PivUgMHw,6
+xelta_cli-0.1.0.dist-info/RECORD,,

xelta_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

xelta_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+xelta = xelta.cli:app

xelta_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+xelta