flowstash-cli 0.1.0__tar.gz

flowstash_cli-0.1.0/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.3
+Name: flowstash-cli
+Version: 0.1.0
+Summary: CLI for the flowstash Managed Platform
+Author: juraj.bezdek@gmail.com
+Author-email: juraj.bezdek@gmail.com
+Requires-Python: >=3.11
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: flowstash-runtime (>=0.3.0,<0.4.0)
+Requires-Dist: httpx (>=0.27.0)
+Requires-Dist: keyring (>=25.0.0)
+Requires-Dist: pydantic (>=2.0.0)
+Requires-Dist: pyyaml (>=6.0.1)
+Requires-Dist: questionary (>=2.0.1)
+Requires-Dist: rich (>=13.7.0)
+Requires-Dist: typer[all] (>=0.12.0)

flowstash_cli-0.1.0/flowstash/commands/auth.py

@@ -0,0 +1,112 @@
+from typing import Optional
+import typer
+import webbrowser
+import uuid
+import secrets
+from rich.console import Console
+import asyncio
+import httpx
+from ..core.auth_server import start_callback_server
+from ..core.config import (
+    load_global_config, 
+    set_access_token, 
+    get_access_token, 
+    delete_access_token,
+    load_project_config
+)
+
+app = typer.Typer()
+console = Console()
+import os
+API_URL = os.getenv("flowstash_API_URL", "https://api.flowstash.dev")
+
+@app.command()
+def login(
+    username: Optional[str] = typer.Option(None, "--username", "-u", help="Username for manual login"),
+    password: Optional[str] = typer.Option(None, "--password", "-p", help="Password for manual login")
+):
+    """Log in to the flowstash Managed Platform."""
+    if username and password:
+        # Manual login
+        console.print(f"Logging in to {API_URL} as {username}...")
+        
+        async def do_login():
+            async with httpx.AsyncClient() as client:
+                try:
+                    resp = await client.post(
+                        f"{API_URL}/v1/auth/login",
+                        json={"email": username, "password": password}
+                    )
+                    resp.raise_for_status()
+                    return resp.json()
+                except Exception as e:
+                    console.print(f"[red]Login failed: {e}[/red]")
+                    return None
+
+        result = asyncio.run(do_login())
+        if not result:
+            raise typer.Exit(code=1)
+            
+        access_token = result.get("access_token")
+        tenant_id = result.get("tenant_id")
+        
+        set_access_token(access_token)
+        console.print(f"[green]Successfully logged in as tenant: {tenant_id}[/green]")
+        return
+
+    # Browser login
+    state = secrets.token_urlsafe(16)
+    port = 8888
+    callback_url = f"http://localhost:{port}/callback"
+    
+    login_url = f"{API_URL}/cli-login?redirect_uri={callback_url}&state={state}"
+    
+    console.print(f"Opening your browser to authenticate...")
+    console.print(f"If the browser doesn't open, visit: [link={login_url}]{login_url}[/link]")
+    
+    webbrowser.open(login_url)
+    
+    console.print("Waiting for authentication...")
+    result = start_callback_server(port)
+    
+    if not result:
+        console.print("[red]Authentication timed out or failed.[/red]")
+        raise typer.Exit(code=1)
+    
+    if result.get("state") != state:
+        console.print("[red]Invalid state received. Auth session might be compromised.[/red]")
+        raise typer.Exit(code=1)
+    
+    access_token = result.get("access_token")
+    tenant_id = result.get("tenant_id")
+    
+    if not access_token:
+        console.print("[red]No access token received.[/red]")
+        raise typer.Exit(code=1)
+    
+    set_access_token(access_token)
+    
+    console.print(f"[green]Successfully logged in as tenant: {tenant_id}[/green]")
+
+@app.command()
+def logout():
+    """Log out from the flowstash Managed Platform."""
+    delete_access_token()
+    console.print("[yellow]Logged out successfully.[/yellow]")
+
+@app.command()
+def whoami():
+    """Show current login status."""
+    token = get_access_token()
+    global_config = load_global_config()
+    project_config = load_project_config()
+    
+    if token:
+        console.print(f"API URL: {global_config.api_url}")
+        if project_config:
+            console.print(f"Logged in as tenant: [bold]{project_config.tenant_id}[/bold]")
+            console.print(f"Current Project: [bold]{project_config.project_id}[/bold]")
+        else:
+            console.print("Logged in, but no project context found in this directory.")
+    else:
+        console.print("Not logged in.")

flowstash_cli-0.1.0/flowstash/commands/build.py

@@ -0,0 +1,127 @@
+import typer
+import asyncio
+import time
+from pathlib import Path
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from ..core.api_client import APIClient
+from ..core.config import load_project_config
+from ..core.builder import bundle_source
+
+import subprocess
+
+app = typer.Typer()
+console = Console()
+
+from .project import find_project_root
+from ..core.docker_utils import check_docker_binary, check_docker_daemon, get_docker_compose_cmd
+
+async def run_managed_build(tag: str = "latest"):
+    project_config = load_project_config()
+    if not project_config or not project_config.project_id:
+        console.print("[red]Project not linked. Run 'flowstash init' to link to a managed project.[/red]")
+        raise typer.Exit(code=1)
+    
+    api = APIClient()
+    # ... rest of existing managed build logic ...
+    # (I'll keep the existing implementation but wrap it)
+
+@app.command()
+def build(
+    env: str = typer.Argument(..., help="Environment to build"),
+    tag: str = typer.Option("latest", "--tag", "-t", help="Tag for the image")
+):
+    """Build project artifacts/images for the specified environment."""
+    project_config = load_project_config()
+    
+    # Check if env is managed
+    is_managed = False
+    if project_config:
+        for em in project_config.environments:
+            if em.name == env:
+                is_managed = em.managed
+                break
+    
+    if is_managed:
+        result = asyncio.run(run_build_flow(tag))
+        console.print(f"[green]Managed build completed successfully![/green]")
+        console.print(f"Artifact ID: [bold]{result['artifact_id']}[/bold]")
+    else:
+        # Local build
+        root = find_project_root()
+        if not root:
+            console.print("[red]Not in a flowstash project.[/red]")
+            raise typer.Exit(code=1)
+
+        if not check_docker_binary():
+            console.print("[red]Docker not found.[/red]")
+            raise typer.Exit(code=1)
+
+        compose_file = root / "deployment" / env / "docker-compose.yaml"
+        if not compose_file.exists():
+            console.print(f"[red]No docker-compose.yaml found for env '{env}' at {compose_file}[/red]")
+            raise typer.Exit(code=1)
+
+        cmd = get_docker_compose_cmd() + ["-f", str(compose_file), "build"]
+        console.print(f"Building images for [bold]{env}[/bold]...")
+        try:
+            subprocess.run(cmd, check=True, cwd=root)
+            console.print(f"[green]Local build for '{env}' complete![/green]")
+        except subprocess.CalledProcessError:
+            console.print("[red]Local build failed.[/red]")
+            raise typer.Exit(code=1)
+
+async def run_build_flow(tag: str = "latest"):
+    # (Moved existing run_build_flow logic here for completeness in the file)
+    project_config = load_project_config()
+    project_id = project_config.project_id
+    api = APIClient()
+    
+    try:
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+        ) as progress:
+            task = progress.add_task(description="Bundling source code...", total=None)
+            tar_path = bundle_source(Path.cwd())
+            progress.update(task, description="Source bundled.")
+            
+            task = progress.add_task(description="Requesting upload path...", total=None)
+            upload_data = await api.get("/v1/builds/upload-path")
+            build_id = upload_data["build_id"]
+            upload_url = upload_data["upload_url"]
+            progress.update(task, description="Upload path received.")
+            
+            task = progress.add_task(description="Uploading source...", total=None)
+            with open(tar_path, "rb") as f:
+                data = f.read()
+            await api.put_binary(upload_url, data, headers={"Content-Type": "application/gzip"})
+            progress.update(task, description="Source uploaded.")
+            
+            task = progress.add_task(description="Triggering build...", total=None)
+            trigger_resp = await api.post(f"/v1/builds/{build_id}/trigger", json={"image_tag": tag})
+            
+            # update build_id to the triggered true GCP build ID
+            build_id = trigger_resp["build_id"]
+            progress.update(task, description=f"Build triggered (ID: {build_id}).")
+            
+            task = progress.add_task(description="Building...", total=None)
+            while True:
+                status_data = await api.get(f"/v1/builds/{build_id}/status")
+                status = status_data["status"]
+                if status == "SUCCESS":
+                    progress.update(task, description="Build successful!")
+                    return status_data
+                elif status in ["FAILURE", "INTERNAL_ERROR", "TIMEOUT", "CANCELLED"]:
+                    progress.update(task, description=f"[red]Build failed: {status}[/red]")
+                    console.print(f"[red]Build ended with status: {status}[/red]")
+                    log_url = status_data.get('log_url')
+                    if log_url:
+                        console.print(f"Check logs here: [link={log_url}]{log_url}[/link]")
+                    raise typer.Exit(code=1)
+                await asyncio.sleep(5)
+    except Exception as e:
+        if isinstance(e, typer.Exit):
+            raise
+        console.print(f"[red]Error during build: {e}[/red]")
+        raise typer.Exit(code=1)

flowstash_cli-0.1.0/flowstash/commands/deploy.py

@@ -0,0 +1,143 @@
+from typing import Optional
+import asyncio
+import typer
+from pathlib import Path
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from ..core.api_client import APIClient
+from ..core.config import load_project_config
+from .build import run_build_flow
+
+app = typer.Typer()
+console = Console()
+
+# Status labels shown to the user while polling
+_STATUS_LABELS = {
+    "QUEUED":         "Queued, waiting for deployment to start...",
+    "DEPLOYING":      "Deploying services to Cloud Run...",
+    "HEALTH_CHECK":   "Health-checking API and Worker...",
+    "SYNCING_SCHEDULES": "Fetching and syncing scheduled tasks...",
+    "DEPLOYED":       "Deployed successfully ✓",
+    "FAILED":         "Deployment failed.",
+}
+
+_TERMINAL_STATUSES = {"DEPLOYED", "FAILED"}
+
+
+async def run_deploy_flow(env: str, artifact_id: Optional[str] = None):
+    project_config = load_project_config()
+    if not project_config:
+        console.print("[red]No .flowstash found. Please run 'flowstash init' first.[/red]")
+        raise typer.Exit(code=1)
+
+    project_id = project_config.project_id
+    if not project_id:
+        console.print("[red]project_id not found in .flowstash[/red]")
+        raise typer.Exit(code=1)
+
+    api = APIClient()
+
+    # 1. If artifact_id is not provided, run build first
+    if not artifact_id:
+        console.print("No artifact ID provided. Building first...")
+        build_result = await run_build_flow()
+        artifact_id = build_result["artifact_id"]
+        console.print(f"Build finished. Deploying artifact: [bold]{artifact_id}[/bold]")
+
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        transient=True,
+    ) as progress:
+        # 2. Trigger deployment
+        task = progress.add_task(description="Triggering deployment...", total=None)
+        deploy_data = await api.post("/v1/deploy", json={
+            "project_id": project_id,
+            "artifact_id": artifact_id,
+            "env_vars": {"ENVIRONMENT": env}
+        })
+        deploy_id = deploy_data["deploy_id"]
+        progress.update(task, description=f"Deployment triggered (ID: {deploy_id}).")
+
+        # 3. Poll status until terminal
+        last_status = None
+        while True:
+            status_data = await api.get(f"/v1/deploy/{deploy_id}/status")
+            current_status = status_data["status"]
+
+            if current_status != last_status:
+                label = _STATUS_LABELS.get(current_status, f"Status: {current_status}")
+                progress.update(task, description=label)
+                last_status = current_status
+
+            if current_status == "DEPLOYED":
+                break
+            elif current_status == "FAILED":
+                error = status_data.get("error_message", "Unknown error")
+                console.print(f"[red]Deployment failed: {error}[/red]")
+                raise typer.Exit(code=1)
+
+            await asyncio.sleep(5)
+
+    return status_data
+
+
+@app.command()
+def deploy(
+    env: str = typer.Argument(..., help="Environment to deploy to"),
+    artifact: Optional[str] = typer.Option(None, "--artifact", "-a", help="Artifact ID to deploy"),
+    non_interactive: bool = typer.Option(False, "--non-interactive", help="Do not ask for confirmation")
+):
+    """Deploy an artifact to the managed platform for a specified environment."""
+    project_config = load_project_config()
+    if not project_config:
+        console.print("[red]No .flowstash found. Please run 'flowstash init' first.[/red]")
+        raise typer.Exit(code=1)
+
+    # Ask for confirmation unless non-interactive is provided
+    if not non_interactive:
+        from rich.prompt import Confirm
+        if not Confirm.ask(f"Are you sure you want to deploy to '{env}'?"):
+            console.print("Deployment cancelled.")
+            raise typer.Exit(code=0)
+
+    # Check if env is managed
+    is_managed = False
+    for em in project_config.environments:
+        if em.name == env:
+            is_managed = em.managed
+            break
+
+    if not is_managed:
+        console.print(f"[red]Environment '{env}' is not managed. Deployment is only supported for managed environments.[/red]")
+        console.print("[yellow]Update your .flowstash environments if this is incorrect.[/yellow]")
+        raise typer.Exit(code=1)
+
+    project_id = project_config.project_id
+    if not project_id:
+        if not non_interactive:
+            from rich.prompt import Confirm
+            if Confirm.ask("Project ID not found. Would you like to link to a managed project now?"):
+                from .project import _link_project
+                _link_project(project_config)
+                project_id = project_config.project_id
+
+        if not project_id:
+            console.print("[red]project_id not found in .flowstash. Use 'flowstash init' or link to a project.[/red]")
+            raise typer.Exit(code=1)
+
+    result = asyncio.run(run_deploy_flow(env, artifact))
+
+    api_url = result.get("api_url", "")
+    console.print(f"[green]✓ Deployment complete![/green]")
+    console.print(f"  Deployment ID : [bold]{result['deploy_id']}[/bold]")
+    if api_url:
+        console.print(f"  API URL       : [bold]{api_url}[/bold]")
+    
+    scheduled_tasks = result.get("scheduled_tasks")
+    if scheduled_tasks:
+        console.print("  Scheduled Tasks:")
+        for task in scheduled_tasks:
+            console.print(f"    - [cyan]{task['task_name']}[/cyan] : [yellow]{task['cron']}[/yellow]")
+    elif scheduled_tasks is not None:
+        console.print("  Scheduled Tasks: [dim]None[/dim]")