llamactl 0.2.7a1__py3-none-any.whl → 0.3.0__py3-none-any.whl

llama_deploy/cli/commands/init.py

@@ -0,0 +1,313 @@
+from __future__ import annotations
+
+import asyncio
+import os
+import shutil
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+
+import click
+import copier
+import questionary
+from click.exceptions import Exit
+from llama_deploy.cli.app import app
+from llama_deploy.cli.options import global_options
+from llama_deploy.cli.styles import HEADER_COLOR_HEX
+from rich import print as rprint
+from vibe_llama.scaffold import create_scaffold
+from vibe_llama.scaffold.scaffold import ProjectName
+from vibe_llama.sdk import VibeLlamaStarter
+
+
+@dataclass
+class TemplateOption:
+    id: str
+    name: str
+    description: str
+    source: VibeLlamaTemplate | GithubTemplateRepo
+    llama_cloud: bool
+
+
+@dataclass
+class VibeLlamaTemplate:
+    name: ProjectName
+
+
+@dataclass
+class GithubTemplateRepo:
+    url: str
+
+
+ui_options = [
+    TemplateOption(
+        id="basic-ui",
+        name="Basic UI",
+        description="A basic starter workflow with a React Vite UI",
+        source=GithubTemplateRepo(
+            url="https://github.com/run-llama/template-workflow-basic-ui"
+        ),
+        llama_cloud=False,
+    ),
+    TemplateOption(
+        id="extraction-review",
+        name="Extraction Agent with Review UI",
+        description="Extract data from documents using a custom schema and Llama Cloud. Includes a UI to review and correct the results",
+        source=GithubTemplateRepo(
+            url="https://github.com/run-llama/template-workflow-data-extraction"
+        ),
+        llama_cloud=True,
+    ),
+]
+headless_options = [
+    TemplateOption(
+        id="basic",
+        name="Basic Workflow",
+        description="A base example that showcases usage patterns for workflows",
+        source=VibeLlamaTemplate(name="basic"),
+        llama_cloud=False,
+    ),
+    TemplateOption(
+        id="document_parsing",
+        name="Document Parser",
+        description="A workflow that, using LlamaParse, parses unstructured documents and returns their raw text content",
+        source=VibeLlamaTemplate(name="document_parsing"),
+        llama_cloud=True,
+    ),
+    TemplateOption(
+        id="human_in_the_loop",
+        name="Human in the Loop",
+        description="A workflow showcasing how to use human in the loop with LlamaIndex workflows",
+        source=VibeLlamaTemplate(name="human_in_the_loop"),
+        llama_cloud=False,
+    ),
+    TemplateOption(
+        id="invoice_extraction",
+        name="Invoice Extraction",
+        description="A workflow that, given an invoice, extracts several key details using LlamaExtract",
+        source=VibeLlamaTemplate(name="invoice_extraction"),
+        llama_cloud=True,
+    ),
+    TemplateOption(
+        id="rag",
+        name="RAG",
+        description="A workflow that embeds, indexes and queries your documents on the fly, providing you with a simple RAG pipeline",
+        source=VibeLlamaTemplate(name="rag"),
+        llama_cloud=False,
+    ),
+    TemplateOption(
+        id="web_scraping",
+        name="Web Scraping",
+        description="A workflow that, given several urls, scrapes and summarizes their content using Google's Gemini API",
+        source=VibeLlamaTemplate(name="web_scraping"),
+        llama_cloud=False,
+    ),
+]
+
+
+@app.command()
+@click.option(
+    "--update",
+    is_flag=True,
+    help="Instead of creating a new app, update the current app to the latest version. Other options will be ignored.",
+)
+@click.option(
+    "--template",
+    type=click.Choice([o.id for o in ui_options]),
+    help="The template to use for the new app",
+)
+@click.option(
+    "--dir",
+    help="The directory to create the new app in",
+    type=click.Path(
+        file_okay=False, dir_okay=True, writable=True, resolve_path=True, path_type=Path
+    ),
+)
+@click.option(
+    "--force",
+    is_flag=True,
+    help="Force overwrite the directory if it exists",
+)
+@global_options
+def init(
+    update: bool,
+    template: str | None,
+    dir: Path | None,
+    force: bool,
+) -> None:
+    """Create a new app repository from a template"""
+    if update:
+        _update()
+    else:
+        _create(template, dir, force)
+
+
+def _create(template: str | None, dir: Path | None, force: bool) -> None:
+    if template is None:
+        rprint(
+            "[bold]Select a template to start from.[/bold] Either with javascript frontend UI, or just a python workflow that can be used as an API."
+        )
+        template = questionary.select(
+            "",
+            choices=[questionary.Separator("------------ With UI -------------")]
+            + [
+                questionary.Choice(title=o.name, value=o.id, description=o.description)
+                for o in ui_options
+            ]
+            + [
+                questionary.Separator(" "),
+                questionary.Separator("--- Headless Workflows (No UI) ---"),
+            ]
+            + [
+                questionary.Choice(title=o.name, value=o.id, description=o.description)
+                for o in headless_options
+            ],
+            style=questionary.Style(
+                [
+                    ("separator", f"fg:{HEADER_COLOR_HEX}"),
+                ]
+            ),
+        ).ask()
+    if template is None:
+        rprint("No template selected")
+        raise Exit(1)
+    if dir is None:
+        dir_str = questionary.text(
+            "Enter the directory to create the new app in", default=template
+        ).ask()
+        if not dir_str:
+            rprint("No directory provided")
+            raise Exit(1)
+        dir = Path(dir_str)
+    resolved_template: TemplateOption | None = next(
+        (o for o in ui_options + headless_options if o.id == template), None
+    )
+    if resolved_template is None:
+        rprint(f"Template {template} not found")
+        raise Exit(1)
+    if dir.exists():
+        is_ok = (
+            force
+            or questionary.confirm("Directory exists. Overwrite?", default=False).ask()
+        )
+        if not is_ok:
+            raise Exit(1)
+        else:
+            shutil.rmtree(dir, ignore_errors=True)
+
+    if isinstance(resolved_template.source, GithubTemplateRepo):
+        copier.run_copy(
+            resolved_template.source.url,
+            dir,
+            quiet=True,
+        )
+    else:
+        asyncio.run(create_scaffold(resolved_template.source.name, str(dir)))
+    # Initialize git repository if git is available
+    has_git = False
+    try:
+        subprocess.run(["git", "--version"], check=True, capture_output=True)
+        has_git = True
+    except subprocess.CalledProcessError:
+        pass
+
+    # Change to the new directory and initialize git repo
+    original_cwd = Path.cwd()
+    os.chdir(dir)
+
+    try:
+        # Dump in a bunch of docs for AI agents
+        vibe_llama_starter = VibeLlamaStarter(
+            agents=["OpenAI Codex CLI"],  # AGENTS.md, supported by Cursor,
+            services=["LlamaIndex", "llama-index-workflows"]
+            + (["LlamaCloud Services"] if resolved_template.llama_cloud else []),
+        )
+        asyncio.run(vibe_llama_starter.write_instructions(overwrite=True))
+        # Create symlink for Claude.md to point to AGENTS.md
+        for alternate in ["CLAUDE.md", "GEMINI.md"]:  # don't support AGENTS.md (yet?)
+            claude_path = Path(alternate)  # not supported yet
+            agents_path = Path("AGENTS.md")
+            if agents_path.exists() and not claude_path.exists():
+                claude_path.symlink_to("AGENTS.md")
+            if has_git:
+                subprocess.run(["git", "init"], check=True, capture_output=True)
+                subprocess.run(["git", "add", "."], check=True, capture_output=True)
+                subprocess.run(
+                    ["git", "commit", "-m", "Initial commit"],
+                    check=True,
+                    capture_output=True,
+                )
+    finally:
+        os.chdir(original_cwd)
+
+    rprint(
+        f"Successfully created [blue]{dir}[/] using the [blue]{resolved_template.name}[/] template! 🎉 🦙 💾"
+    )
+    rprint("")
+    rprint("[bold]To run locally:[/]")
+    rprint(f"    [orange3]cd[/] {dir}")
+    rprint("    [orange3]uvx[/] llamactl serve")
+    rprint("")
+    rprint("[bold]To deploy:[/]")
+    if has_git:
+        rprint("    [orange3]git[/] init")
+        rprint("    [orange3]git[/] add .")
+        rprint("    [orange3]git[/] commit -m 'Initial commit'")
+        rprint("")
+    rprint("[dim](Create a new repo and add it as a remote)[/]")
+    rprint("")
+    rprint("    [orange3]git[/] remote add origin <your-repo-url>")
+    rprint("    [orange3]git[/] push -u origin main")
+    rprint("")
+    # rprint("  [orange3]uvx[/] llamactl login")
+    rprint("    [orange3]uvx[/] llamactl deploy")
+    rprint("")
+
+
+def _update():
+    """Update the app to the latest version"""
+    try:
+        copier.run_update(
+            overwrite=True,
+            skip_answered=True,
+            quiet=True,
+        )
+    except copier.UserMessageError as e:
+        rprint(f"{e}")
+        raise Exit(1)
+
+    # Check git status and warn about conflicts
+    try:
+        result = subprocess.run(
+            ["git", "status", "--porcelain"],
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+
+        if result.stdout.strip():
+            conflicted_files = []
+            modified_files = []
+
+            for line in result.stdout.strip().split("\n"):
+                status = line[:2]
+                filename = line[3:]
+
+                if "UU" in status or "AA" in status or "DD" in status:
+                    conflicted_files.append(filename)
+                elif status.strip():
+                    modified_files.append(filename)
+
+            if conflicted_files:
+                rprint("")
+                rprint("⚠️  [bold]Files with conflicts detected:[/]")
+                for file in conflicted_files:
+                    rprint(f"    {file}")
+                rprint("")
+                rprint(
+                    "Please manually resolve conflicts with a merge editor before proceeding."
+                )
+
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        # Git not available or not in a git repo - continue silently
+        pass

llama_deploy/cli/commands/serve.py

@@ -0,0 +1,239 @@
+import logging
+import os
+from pathlib import Path
+from typing import Literal
+
+import click
+import questionary
+from llama_deploy.appserver.app import (
+    prepare_server,
+    start_server_in_target_venv,
+)
+from llama_deploy.appserver.deployment_config_parser import get_deployment_config
+from llama_deploy.appserver.workflow_loader import parse_environment_variables
+from llama_deploy.cli.commands.auth import validate_authenticated_profile
+from llama_deploy.cli.config.env_service import service
+from llama_deploy.cli.config.schema import Auth
+from llama_deploy.cli.options import interactive_option
+from llama_deploy.cli.styles import WARNING
+from llama_deploy.core.config import DEFAULT_DEPLOYMENT_FILE_PATH
+from llama_deploy.core.deployment_config import (
+    read_deployment_config_from_git_root_or_cwd,
+)
+from rich import print as rprint
+
+from ..app import app
+
+logger = logging.getLogger(__name__)
+
+
+@app.command(
+    "serve",
+    help="Serve a LlamaDeploy app locally for development and testing",
+)
+@click.argument(
+    "deployment_file",
+    required=False,
+    default=DEFAULT_DEPLOYMENT_FILE_PATH,
+    type=click.Path(dir_okay=True, resolve_path=True, path_type=Path),
+)
+@click.option(
+    "--no-install", is_flag=True, help="Skip installing python and js dependencies"
+)
+@click.option(
+    "--no-reload", is_flag=True, help="Skip reloading the API server on code changes"
+)
+@click.option("--no-open-browser", is_flag=True, help="Skip opening the browser")
+@click.option(
+    "--preview",
+    is_flag=True,
+    help="Preview mode pre-builds the UI to static files, like a production build",
+)
+@click.option("--port", type=int, help="The port to run the API server on")
+@click.option("--ui-port", type=int, help="The port to run the UI proxy server on")
+@click.option(
+    "--log-level",
+    type=click.Choice(
+        ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"], case_sensitive=False
+    ),
+    help="The log level to run the API server at",
+)
+@click.option(
+    "--log-format",
+    type=click.Choice(["console", "json"], case_sensitive=False),
+    help="The format to use for logging",
+)
+@click.option(
+    "--persistence",
+    type=click.Choice(["memory", "local", "cloud"]),
+    help="The persistence mode to use for the workflow server",
+)
+@click.option(
+    "--local-persistence-path",
+    type=click.Path(dir_okay=True, resolve_path=True, path_type=Path),
+    help="The path to the sqlite database to use for the workflow server if using local persistence",
+)
+@interactive_option
+def serve(
+    deployment_file: Path,
+    no_install: bool,
+    no_reload: bool,
+    no_open_browser: bool,
+    preview: bool,
+    port: int | None = None,
+    ui_port: int | None = None,
+    log_level: str | None = None,
+    log_format: str | None = None,
+    persistence: Literal["memory", "local", "cloud"] | None = None,
+    local_persistence_path: Path | None = None,
+    interactive: bool = False,
+) -> None:
+    """Run llama_deploy API Server in the foreground. Reads the deployment configuration from the current directory. Can optionally specify a deployment file path."""
+    if not deployment_file.exists():
+        rprint(f"[red]Deployment file '{deployment_file}' not found[/red]")
+        raise click.Abort()
+
+    try:
+        # Pre-check: if the template requires llama cloud access, ensure credentials
+        _maybe_inject_llama_cloud_credentials(
+            deployment_file, interactive, require_cloud=persistence == "cloud"
+        )
+
+        prepare_server(
+            deployment_file=deployment_file,
+            install=not no_install,
+            build=preview,
+        )
+        deployment_config = get_deployment_config()
+        start_server_in_target_venv(
+            cwd=Path.cwd(),
+            deployment_file=deployment_file,
+            proxy_ui=not preview,
+            reload=not no_reload,
+            open_browser=not no_open_browser,
+            port=port,
+            ui_port=ui_port,
+            log_level=log_level.upper() if log_level else None,
+            log_format=log_format.lower() if log_format else None,
+            persistence=persistence if persistence else "local",
+            local_persistence_path=str(local_persistence_path)
+            if local_persistence_path and persistence == "local"
+            else None,
+            cloud_persistence_name=f"_public:serve_workflows_{deployment_config.name}"
+            if persistence == "cloud"
+            else None,
+        )
+
+    except KeyboardInterrupt:
+        logger.debug("Shutting down...")
+
+    except Exception as e:
+        rprint(f"[red]Error: {e}[/red]")
+        raise click.Abort()
+
+
+def _set_env_vars_from_profile(profile: Auth):
+    if profile.api_key:
+        _set_env_vars(profile.api_key, profile.api_url)
+    _set_project_id_from_profile(profile)
+
+
+def _set_env_vars_from_env(env_vars: dict[str, str]):
+    key = env_vars.get("LLAMA_CLOUD_API_KEY")
+    url = env_vars.get("LLAMA_CLOUD_BASE_URL", "https://api.cloud.llamaindex.ai")
+    # Also propagate project id if present in the environment
+    _set_project_id_from_env(env_vars)
+    if key:
+        _set_env_vars(key, url)
+
+
+def _set_env_vars(key: str, url: str):
+    os.environ["LLAMA_CLOUD_API_KEY"] = key
+    os.environ["LLAMA_CLOUD_BASE_URL"] = url
+    # kludge for common web servers to inject local auth key
+    for prefix in ["VITE_", "NEXT_PUBLIC_"]:
+        os.environ[f"{prefix}LLAMA_CLOUD_API_KEY"] = key
+        os.environ[f"{prefix}LLAMA_CLOUD_BASE_URL"] = url
+
+
+def _set_project_id_from_env(env_vars: dict[str, str]):
+    project_id = env_vars.get("LLAMA_DEPLOY_PROJECT_ID")
+    if project_id:
+        os.environ["LLAMA_DEPLOY_PROJECT_ID"] = project_id
+
+
+def _set_project_id_from_profile(profile: Auth):
+    if profile.project_id:
+        os.environ["LLAMA_DEPLOY_PROJECT_ID"] = profile.project_id
+
+
+def _maybe_inject_llama_cloud_credentials(
+    deployment_file: Path, interactive: bool, require_cloud: bool
+) -> None:
+    """If the deployment config indicates Llama Cloud usage, ensure LLAMA_CLOUD_API_KEY is set.
+
+    Behavior:
+    - If LLAMA_CLOUD_API_KEY is already set, do nothing.
+    - Else, try to read current profile's api_key and inject.
+    - If no profile/api_key and session is interactive, prompt to log in and inject afterward.
+    - If user declines or session is non-interactive, warn that deployment may not work.
+    """
+    # Read config directly to avoid cached global settings
+    try:
+        config = read_deployment_config_from_git_root_or_cwd(
+            Path.cwd(), deployment_file
+        )
+    except Exception:
+        rprint(
+            "[red]Error: Could not read a deployment config. This doesn't appear to be a valid llama-deploy project.[/red]"
+        )
+        raise click.Abort()
+
+    if not config.llama_cloud and not require_cloud:
+        return
+
+    vars = parse_environment_variables(
+        config, deployment_file.parent if deployment_file.is_file() else deployment_file
+    )
+
+    # Ensure project id is available to the app and UI processes
+    _set_project_id_from_env({**os.environ, **vars})
+
+    existing = os.environ.get("LLAMA_CLOUD_API_KEY") or vars.get("LLAMA_CLOUD_API_KEY")
+    if existing:
+        _set_env_vars_from_env({**os.environ, **vars})
+        return
+
+    env = service.get_current_environment()
+    if not env.requires_auth:
+        rprint(
+            f"[{WARNING}]Warning: This app requires Llama Cloud authentication, and no LLAMA_CLOUD_API_KEY is present. The app may not work.[/]"
+        )
+        return
+
+    auth_svc = service.current_auth_service()
+    profile = auth_svc.get_current_profile()
+    if profile and profile.api_key:
+        _set_env_vars_from_profile(profile)
+        return
+
+    # No key available; consider prompting if interactive
+    if interactive:
+        should_login = questionary.confirm(
+            "This deployment requires Llama Cloud. Login now to inject credentials? Otherwise the app may not work.",
+            default=True,
+        ).ask()
+        if should_login:
+            authed = validate_authenticated_profile(True)
+            if authed.api_key:
+                _set_env_vars_from_profile(authed)
+                return
+        rprint(
+            f"[{WARNING}]Warning: No Llama Cloud credentials configured. The app may not work.[/]"
+        )
+        return
+
+    # Non-interactive session
+    rprint(
+        f"[{WARNING}]Warning: LLAMA_CLOUD_API_KEY is not set and no logged-in profile was found. The app may not work.[/]"
+    )