PyPI - flowstash-cli - Versions diffs - 0.1.0__py3-none-any.whl - Mend

flowstash-cli 0.1.0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (48) hide show

flowstash/__init__.py +0 -0
flowstash/commands/__init__.py +0 -0
flowstash/commands/auth.py +112 -0
flowstash/commands/build.py +127 -0
flowstash/commands/deploy.py +143 -0
flowstash/commands/project.py +555 -0
flowstash/commands/run.py +65 -0
flowstash/core/__init__.py +0 -0
flowstash/core/api_client.py +62 -0
flowstash/core/auth_server.py +45 -0
flowstash/core/builder.py +40 -0
flowstash/core/config.py +81 -0
flowstash/core/docker_utils.py +33 -0
flowstash/main.py +269 -0
flowstash/templates/AGENTS.md +222 -0
flowstash/templates/README.md +135 -0
flowstash/templates/_.dockerignore +8 -0
flowstash/templates/_.flowstash +4 -0
flowstash/templates/_api_main.py +21 -0
flowstash/templates/_config/[env]/(backend-asyncio)/backend.yaml +4 -0
flowstash/templates/_config/[env]/(backend-dramatiq)/backend.yaml +8 -0
flowstash/templates/_config/[env]/(backend-managed)/backend.yaml +6 -0
flowstash/templates/_config/[env]/_backend.yaml +4 -0
flowstash/templates/_config/shared/.env +1 -0
flowstash/templates/_config/shared/backend.yaml +4 -0
flowstash/templates/_config/shared/clients/demoClient.yaml +39 -0
flowstash/templates/_config/shared/clients.yaml +3 -0
flowstash/templates/_deployment/[env]/(backend-asyncio)/docker-compose.yaml +24 -0
flowstash/templates/_deployment/[env]/(backend-dramatiq)/docker-compose.yaml +34 -0
flowstash/templates/_deployment/[env]/.env +3 -0
flowstash/templates/_deployment/shared/.env +5 -0
flowstash/templates/_deployment/shared/api.Dockerfile +18 -0
flowstash/templates/_deployment/shared/worker.Dockerfile +18 -0
flowstash/templates/_pyproject.toml +40 -0
flowstash/templates/_src/_api/__init__.py +1 -0
flowstash/templates/_src/_api/_routes/webhooks.py +25 -0
flowstash/templates/_src/_shared/__init__.py +1 -0
flowstash/templates/_src/_shared/clients/client.py +18 -0
flowstash/templates/_src/_shared/models/models.py +1 -0
flowstash/templates/_src/_shared/tasks/sharedTasks.py +10 -0
flowstash/templates/_src/_worker/__init__.py +1 -0
flowstash/templates/_src/_worker/tasks/tasks.py +15 -0
flowstash/templates/_worker_main.py +25 -0
flowstash/ui/__init__.py +0 -0
flowstash_cli-0.1.0.dist-info/METADATA +19 -0
flowstash_cli-0.1.0.dist-info/RECORD +48 -0
flowstash_cli-0.1.0.dist-info/WHEEL +4 -0
flowstash_cli-0.1.0.dist-info/entry_points.txt +3 -0

flowstash/core/auth_server.py ADDED Viewed

@@ -0,0 +1,45 @@
+from typing import Dict, Optional
+import threading
+import queue
+from http.server import HTTPServer, BaseHTTPRequestHandler
+from urllib.parse import urlparse, parse_qs
+result_queue = queue.Queue()
+class CallbackHandler(BaseHTTPRequestHandler):
+    def do_GET(self):
+        query_components = parse_qs(urlparse(self.path).query)
+        params = {k: v[0] for k, v in query_components.items()}
+        result_queue.put(params)
+        self.send_response(200)
+        self.send_header('Content-type', 'text/html')
+        self.end_headers()
+        content = """
+        <html>
+            <body style="font-family: sans-serif; text-align: center; padding-top: 50px;">
+                <h1>Authentication Successful</h1>
+                <p>You can now close this window and return to the CLI.</p>
+            </body>
+        </html>
+        """
+        self.wfile.write(content.encode('utf-8'))
+    def log_message(self, format, *args):
+        # Suppress logging
+        pass
+def start_callback_server(port: int = 8888) -> Dict[str, str]:
+    server = HTTPServer(('127.0.0.1', port), CallbackHandler)
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+    # Wait for result
+    try:
+        result = result_queue.get(timeout=300) # 5 minutes timeout
+        server.shutdown()
+        return result
+    except queue.Empty:
+        server.shutdown()
+        return {}

flowstash/core/builder.py ADDED Viewed

@@ -0,0 +1,40 @@
+import os
+import tarfile
+import tempfile
+import gzip
+from pathlib import Path
+from typing import List, Optional
+def bundle_source(directory: Path, ignore_patterns: Optional[List[str]] = None) -> Path:
+    """
+    Bundles the source code in directory into a .tar.gz file.
+    Follows .gitignore if present.
+    """
+    temp_dir = Path(tempfile.gettempdir())
+    tar_path = temp_dir / f"source_{os.urandom(4).hex()}.tar.gz"
+    # Basic ignore logic (should be improved to handle .gitignore properly)
+    default_ignore = {".git", ".venv", "__pycache__", ".pytest_cache", ".flowstash"}
+    if ignore_patterns:
+        default_ignore.update(ignore_patterns)
+    def is_ignored(path: Path) -> bool:
+        for part in path.parts:
+            if part in default_ignore:
+                return True
+        return False
+    with tarfile.open(tar_path, "w:gz") as tar:
+        for root, dirs, files in os.walk(directory):
+            root_path = Path(root)
+            if is_ignored(root_path.relative_to(directory)):
+                continue
+            for file in files:
+                file_path = root_path / file
+                if is_ignored(file_path.relative_to(directory)):
+                    continue
+                tar.add(file_path, arcname=str(file_path.relative_to(directory)))
+    return tar_path

flowstash/core/config.py ADDED Viewed

@@ -0,0 +1,81 @@
+from typing import List
+from pydantic import Field
+import os
+from pathlib import Path
+from typing import Optional, Dict, Any
+import yaml
+import keyring
+from pydantic import BaseModel
+flowstash_DIR = Path.home() / ".flowstash"
+GLOBAL_CONFIG_FILE = flowstash_DIR / "config.yaml"
+PROJECT_CONFIG_FILE = ".flowstash"
+SERVICE_NAME = "flowstash"
+TOKEN_KEY = "access_token"
+class GlobalConfig(BaseModel):
+    api_url: str = os.getenv("flowstash_API_URL", "https://api.flowstash.dev")  # Default to managed platform
+class EnvironmentMode(BaseModel):
+    name: str
+    managed: bool = False
+    options: Dict[str, str] = Field(default_factory=dict)
+class ProjectConfig(BaseModel):
+    project_name: Optional[str] = None
+    project_id: Optional[str] = None
+    tenant_id: Optional[str] = None
+    user_email: Optional[str] = None
+    environments: List[EnvironmentMode] = Field(default_factory=list)
+def load_global_config() -> GlobalConfig:
+    if not GLOBAL_CONFIG_FILE.exists():
+        return GlobalConfig()
+    try:
+        with open(GLOBAL_CONFIG_FILE, "r") as f:
+            data = yaml.safe_load(f) or {}
+            return GlobalConfig(**data)
+    except Exception:
+        return GlobalConfig()
+def save_global_config(config: GlobalConfig):
+    flowstash_DIR.mkdir(parents=True, exist_ok=True)
+    with open(GLOBAL_CONFIG_FILE, "w") as f:
+        yaml.safe_dump(config.model_dump(), f)
+def get_access_token() -> Optional[str]:
+    return keyring.get_password(SERVICE_NAME, TOKEN_KEY)
+def set_access_token(token: str):
+    keyring.set_password(SERVICE_NAME, TOKEN_KEY, token)
+def delete_access_token():
+    try:
+        keyring.delete_password(SERVICE_NAME, TOKEN_KEY)
+    except keyring.errors.PasswordDeleteError:
+        pass
+def load_project_config() -> Optional[ProjectConfig]:
+    path = Path(PROJECT_CONFIG_FILE)
+    if not path.exists():
+        return None
+    try:
+        with open(path, "r") as f:
+            data = yaml.safe_load(f) or {}
+            return ProjectConfig(**data)
+    except Exception:
+        return None
+def save_project_config(config: ProjectConfig):
+    with open(PROJECT_CONFIG_FILE, "w") as f:
+        yaml.safe_dump(config.model_dump(), f)
+# Legacy aliases for compatibility if needed, though we should update callers
+def load_config() -> GlobalConfig:
+    return load_global_config()
+def save_config(config: GlobalConfig):
+    save_global_config(config)

flowstash/core/docker_utils.py ADDED Viewed

@@ -0,0 +1,33 @@
+import shutil
+import subprocess
+from typing import Tuple, Optional
+def check_docker_binary() -> bool:
+    return shutil.which("docker") is not None
+def check_docker_compose_binary() -> bool:
+    # Check for 'docker compose' (V2) or 'docker-compose' (V1)
+    if shutil.which("docker-compose"):
+        return True
+    # Check if 'docker compose' works
+    try:
+        subprocess.run(["docker", "compose", "version"], capture_output=True, check=True)
+        return True
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return False
+def check_docker_daemon() -> Tuple[bool, Optional[str]]:
+    """Returns (is_running, error_message)"""
+    try:
+        subprocess.run(["docker", "info"], capture_output=True, check=True)
+        return True, None
+    except subprocess.CalledProcessError as e:
+        return False, e.stderr.decode().strip()
+    except FileNotFoundError:
+        return False, "Docker binary not found"
+def get_docker_compose_cmd() -> list:
+    if shutil.which("docker-compose"):
+        return ["docker-compose"]
+    return ["docker", "compose"]

flowstash/main.py ADDED Viewed

@@ -0,0 +1,269 @@
+import typer
+import click
+from typing import Optional
+from .commands import auth as auth_cmds
+from .commands import project as project_cmds
+from .commands import build as build_cmds
+from .commands import deploy as deploy_cmds
+from .commands import run as run_cmds
+from rich.console import Console
+import importlib.metadata
+try:
+    __version__ = importlib.metadata.version("flowstash-cli")
+except importlib.metadata.PackageNotFoundError:
+    __version__ = "unknown"
+console = Console()
+app = typer.Typer(
+    name="flowstash",
+    help=f"""
+# 🚀 flowstash CLI (v{__version__})
+Manage your flowstash projects and deployments with ease.
+## 🛠 Usage
+Run commands below to initialize, build, and deploy your integrations.
+""",
+    add_completion=False,
+    no_args_is_help=True,
+    rich_markup_mode="rich"
+)
+env_app = typer.Typer(
+    name="env",
+    help="Manage environments",
+    no_args_is_help=True,
+    rich_markup_mode="rich"
+)
+app.add_typer(env_app, name="env")
+@app.command()
+def help(ctx: typer.Context):
+    """
+    Show help information for all commands.
+    """
+    console.print(ctx.parent.get_help()) if ctx.parent else console.print(ctx.get_help())
+# Shortcuts / Top-level commands
+@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."""
+    auth_cmds.login(username=username, password=password)
+@app.command()
+def init(
+    name: Optional[str] = typer.Option(None, "--name", "-n", help="Project name"),
+    fix: bool = typer.Option(False, "--fix", help="Repair missing components"),
+    force: bool = typer.Option(False, "--force", help="Force overwrite existing files")
+):
+    """
+    [bold green]Initialize[/bold green] or [bold yellow]repair[/bold yellow] a flowstash project.
+    This command sets up the local structure, creates the `.flowstash` config,
+    and lets you configure your first environments.
+    """
+    project_cmds.init(name=name, fix=fix, force=force)
+@app.command()
+def check():
+    """Inspect the current project structure."""
+    project_cmds.check()
+@app.command()
+def link():
+    """
+    [bold cyan]Link[/bold cyan] your current project to a flowstash Managed Project.
+    """
+    from .core.config import load_project_config
+    from .commands.project import _link_project
+    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)
+    _link_project(project_config)
+@env_app.command("add")
+def env_add(
+    env_name: Optional[str] = typer.Argument(None, help="Environment name to add"),
+    force: bool = typer.Option(False, "--force", help="Force overwrite existing files")
+):
+    """
+    [bold blue]Add a new environment[/bold blue] to your project.
+    Choose between Local, Dev, Prod, or Custom. It will automatically filter
+    out existing environments and scaffold necessary files.
+    """
+    project_cmds.env_add(env_name=env_name, force=force)
+@env_app.command("del")
+def env_del(
+    env_name: str = typer.Argument(..., help="Environment name to delete")
+):
+    """
+    [bold red]Delete an environment[/bold red] from your project.
+    Requires confirmation before removal.
+    """
+    project_cmds.env_delete(env_name=env_name)
+@env_app.command("init-vscode")
+def env_init_vscode(
+    env_name: str = typer.Argument(..., help="Environment name to initialize VS Code for"),
+    force: bool = typer.Option(False, "--force", help="Force overwrite existing launch.json if it's malformed or already has the configuration")
+):
+    """
+    [bold blue]Initialize VS Code launch configurations[/bold blue] for an environment.
+    This command will add 'Launch <env> API' and 'Launch <env> Worker' to your .vscode/launch.json,
+    allowing you to easily debug your environment's API and Worker using VS Code.
+    """
+    project_cmds.init_vscode_launch(env_name=env_name, force=force)
+@app.command()
+def run(
+    ctx: typer.Context,
+    env: str = typer.Argument("local", help="Environment to run (default: local)"),
+    build: bool = typer.Option(True, "--build/--no-build", help="Build images before starting"),
+    detach: bool = typer.Option(False, "--detach", "-d", help="Run in background"),
+    logs: bool = typer.Option(False, "--logs", help="Follow logs (useful with --detach)")
+):
+    """
+    [bold magenta]Run[/bold magenta] the project locally using Docker Compose.
+    Defaults to the 'local' environment.
+    [yellow]Note:[/yellow] To run a specific environment, use: [bold]flowstash run <env_name>[/bold]
+    """
+    from .core.config import load_project_config
+    from rich.prompt import Confirm
+    if ctx.get_parameter_source("env") == click.core.ParameterSource.DEFAULT:
+        console.print(f"[dim]Env argument not specified... using [bold]{env}[/bold] as default[/dim]")
+    project_config = load_project_config()
+    if project_config:
+        env_mode = next((e for e in project_config.environments if e.name == env), None)
+        if not env_mode:
+            if env == "local":
+                if Confirm.ask(f"Environment '{env}' not found. Would you like to set it up now?"):
+                    project_cmds.add_environment(project_config, env_name=env)
+                else:
+                    console.print(f"[red]Aborting. Run 'flowstash env add' to create it manually.[/red]")
+                    raise typer.Exit(code=1)
+            else:
+                console.print(f"[red]Environment '{env}' not found.[/red]")
+                raise typer.Exit(code=1)
+    run_cmds.run(env=env, build=build, detach=detach, logs=logs)
+@app.command()
+def build(
+    ctx: typer.Context,
+    env: str = typer.Argument("local", help="Environment to build (default: local)"),
+    tag: str = typer.Option("latest", "--tag", "-t", help="Tag for the image")
+):
+    """
+    [bold yellow]Build[/bold yellow] project artifacts/images.
+    Defaults to the 'local' environment.
+    [yellow]Note:[/yellow] To build for a specific environment, use: [bold]flowstash build <env_name>[/bold]
+    """
+    if ctx.get_parameter_source("env") == click.core.ParameterSource.DEFAULT:
+        console.print(f"[dim]Env argument not specified... using [bold]{env}[/bold] as default[/dim]")
+    from .core.config import load_project_config
+    from rich.prompt import Confirm
+    project_config = load_project_config()
+    if project_config:
+        env_mode = next((e for e in project_config.environments if e.name == env), None)
+        if not env_mode:
+            if env == "local":
+                if Confirm.ask(f"Environment '{env}' not found. Would you like to set it up now?"):
+                    project_cmds.add_environment(project_config, env_name=env)
+                else:
+                    console.print(f"[red]Aborting. Run 'flowstash env add' to create it manually.[/red]")
+                    raise typer.Exit(code=1)
+            else:
+                console.print(f"[red]Environment '{env}' not found.[/red]")
+                raise typer.Exit(code=1)
+    build_cmds.build(env=env, tag=tag)
+@app.command()
+def deploy(
+    ctx: typer.Context,
+    env: str = typer.Argument("prod", help="Environment to deploy to (default: prod)"),
+    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")
+):
+    """
+    [bold cyan]Deploy[/bold cyan] your project to the flowstash Managed Platform.
+    Defaults to the 'prod' environment. If 'prod' is missing, it will prompt you to set it up.
+    [yellow]Note:[/yellow] To deploy to a specific environment, use: [bold]flowstash deploy <env_name>[/bold]
+    """
+    from .core.config import load_project_config
+    from .commands.project import add_environment
+    from rich.prompt import Confirm
+    if ctx.get_parameter_source("env") == click.core.ParameterSource.DEFAULT:
+        console.print(f"[dim]Env argument not specified... using [bold]{env}[/bold] as default[/dim]")
+    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)
+    # Find the requested environment
+    env_mode = next((e for e in project_config.environments if e.name == env), None)
+    if not env_mode:
+        if env == "prod":
+            if not non_interactive and Confirm.ask(f"Environment '{env}' not found. Would you like to set it up now?"):
+                # We need to pass the actual project_config object to add_environment
+                # But project_cmds is a module, we should be careful about cyclic imports or just use it.
+                project_cmds.add_environment(project_config, env_name=env)
+                # Reload or refresh check
+                project_config = load_project_config()
+                env_mode = next((e for e in project_config.environments if e.name == env), None)
+                if not env_mode:
+                    console.print(f"[red]Environment '{env}' was not created. Aborting.[/red]")
+                    raise typer.Exit(code=1)
+            else:
+                console.print(f"[red]Aborting. Use 'flowstash env add' to create environments manually.[/red]")
+                raise typer.Exit(code=1)
+        else:
+            console.print(f"[red]Environment '{env}' not found.[/red]")
+            console.print(f"[yellow]Available environments: {', '.join(e.name for e in project_config.environments)}[/yellow]")
+            console.print(f"To deploy to a specific environment, use: [bold]flowstash deploy <env_name>[/bold]")
+            raise typer.Exit(code=1)
+    deploy_cmds.deploy(env=env, artifact=artifact, non_interactive=non_interactive)
+@app.command()
+def whoami():
+    """Show current login status."""
+    auth_cmds.whoami()
+@app.command()
+def logout():
+    """Log out from the platform."""
+    auth_cmds.logout()
+@app.command()
+def version():
+    """Show the flowstash CLI version."""
+    console.print(f"flowstash CLI version: [bold green]{__version__}[/bold green]")
+if __name__ == "__main__":
+    app()