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

llama_deploy/cli/textual/deployment_form.py

@@ -1,28 +1,53 @@
 """Textual-based deployment forms for CLI interactions"""
 
-from dataclasses import dataclass, field
 import dataclasses
 import logging
+import re
+from dataclasses import dataclass, field
 from pathlib import Path
+from urllib.parse import urlsplit
 
-from llama_deploy.cli.textual.secrets_form import SecretsWidget
+from llama_deploy.cli.client import get_project_client as get_client
+from llama_deploy.cli.env import load_env_secrets_from_string
+from llama_deploy.cli.textual.deployment_help import (
+    DeploymentHelpBackMessage,
+    DeploymentHelpWidget,
+)
+from llama_deploy.cli.textual.deployment_monitor import (
+    DeploymentMonitorWidget,
+    MonitorCloseMessage,
+)
 from llama_deploy.cli.textual.git_validation import (
     GitValidationWidget,
-    ValidationResultMessage,
     ValidationCancelMessage,
+    ValidationResultMessage,
+)
+from llama_deploy.cli.textual.secrets_form import SecretsWidget
+from llama_deploy.core.deployment_config import (
+    DEFAULT_DEPLOYMENT_NAME,
+    read_deployment_config,
+)
+from llama_deploy.core.git.git_util import (
+    get_current_branch,
+    get_git_root,
+    get_unpushed_commits_count,
+    is_git_repo,
+    list_remotes,
+    working_tree_has_changes,
 )
 from llama_deploy.core.schema.deployments import (
     DeploymentCreate,
     DeploymentResponse,
     DeploymentUpdate,
 )
+from textual import events
 from textual.app import App, ComposeResult
 from textual.containers import Container, HorizontalGroup, Widget
+from textual.content import Content
+from textual.message import Message
+from textual.reactive import reactive
 from textual.validation import Length
 from textual.widgets import Button, Input, Label, Static
-from textual.reactive import reactive
-from llama_deploy.cli.client import get_client
-from textual.message import Message
 
 
 @dataclass
@@ -34,7 +59,7 @@ class DeploymentForm:
     id: str | None = None
     repo_url: str = ""
     git_ref: str = "main"
-    deployment_file_path: str = "llama_deploy.yaml"
+    deployment_file_path: str = ""
     personal_access_token: str = ""
     # indicates if the deployment has a personal access token (value is unknown)
     has_existing_pat: bool = False
@@ -46,6 +71,10 @@ class DeploymentForm:
     removed_secrets: set[str] = field(default_factory=set)
     # if the deployment is being edited
     is_editing: bool = False
+    # warnings shown to the user
+    warnings: list[str] = field(default_factory=list)
+    # env info
+    env_info_messages: str | None = None
 
     @classmethod
     def from_deployment(cls, deployment: DeploymentResponse) -> "DeploymentForm":
@@ -56,7 +85,7 @@ class DeploymentForm:
             id=deployment.id,
             repo_url=deployment.repo_url,
             git_ref=deployment.git_ref or "main",
-            deployment_file_path=deployment.deployment_file_path or "llama_deploy.yaml",
+            deployment_file_path=deployment.deployment_file_path,
             personal_access_token="",  # Always start empty for security
             has_existing_pat=deployment.has_personal_access_token,
             secrets={},
@@ -74,7 +103,7 @@ class DeploymentForm:
         data = DeploymentUpdate(
             repo_url=self.repo_url,
             git_ref=self.git_ref or "main",
-            deployment_file_path=self.deployment_file_path or "llama_deploy.yaml",
+            deployment_file_path=self.deployment_file_path or None,
             personal_access_token=(
                 ""
                 if self.personal_access_token is None and not self.has_existing_pat
@@ -91,7 +120,7 @@ class DeploymentForm:
         return DeploymentCreate(
             name=self.name,
             repo_url=self.repo_url,
-            deployment_file_path=self.deployment_file_path or "llama_deploy.yaml",
+            deployment_file_path=self.deployment_file_path or None,
             git_ref=self.git_ref or "main",
             personal_access_token=self.personal_access_token,
             secrets=self.secrets,
@@ -119,8 +148,11 @@ class DeploymentFormWidget(Widget):
 
     def compose(self) -> ComposeResult:
         title = "Edit Deployment" if self.form_data.is_editing else "Create Deployment"
+
         yield Static(
-            title,
+            Content.from_markup(
+                f"{title} [italic][@click=app.show_help()]More info[/][/italic]"
+            ),
             classes="primary-message",
         )
         yield Static(
@@ -128,6 +160,13 @@ class DeploymentFormWidget(Widget):
             id="error-message",
             classes="error-message " + ("visible" if self.error_message else "hidden"),
         )
+        # Top-of-form warnings banner
+        yield Static(
+            "Note: " + " ".join(f"{w}" for w in self.form_data.warnings),
+            id="warning-list",
+            classes="warning-message mb-1 hidden "
+            + ("visible" if self.form_data.warnings else ""),
+        )
 
         # Main deployment fields
         with Widget(classes="two-column-form-grid"):
@@ -161,10 +200,10 @@ class DeploymentFormWidget(Widget):
                 compact=True,
             )
 
-            yield Label("Deployment File:", classes="form-label", shrink=True)
+            yield Label("Config File:", classes="form-label", shrink=True)
             yield Input(
                 value=self.form_data.deployment_file_path,
-                placeholder="llama_deploy.yaml",
+                placeholder="Optional path to config dir/file",
                 id="deployment_file_path",
                 compact=True,
             )
@@ -191,6 +230,7 @@ class DeploymentFormWidget(Widget):
         yield SecretsWidget(
             initial_secrets=self.form_data.secrets,
             prior_secrets=self.form_data.initial_secrets,
+            info_message=self.form_data.env_info_messages,
         )
 
         with HorizontalGroup(classes="button-row"):
@@ -201,7 +241,7 @@ class DeploymentFormWidget(Widget):
         if event.button.id == "save":
             self._save()
         elif event.button.id == "change_pat":
-            updated_form = dataclasses.replace(self._get_form_data())
+            updated_form = dataclasses.replace(self.resolve_form_data())
             updated_form.has_existing_pat = False
             updated_form.personal_access_token = ""
             self.form_data = updated_form
@@ -210,7 +250,7 @@ class DeploymentFormWidget(Widget):
             self.post_message(CancelFormMessage())
 
     def _save(self) -> None:
-        self.form_data = self._get_form_data()
+        self.form_data = self.resolve_form_data()
         if self._validate_form():
             # Post message to parent app to start validation
             self.post_message(StartValidationMessage(self.form_data))
@@ -245,7 +285,7 @@ class DeploymentFormWidget(Widget):
         """Show an error message"""
         self.error_message = message
 
-    def _get_form_data(self) -> DeploymentForm:
+    def resolve_form_data(self) -> DeploymentForm:
         """Extract form data from inputs"""
         name_input = self.query_one("#name", Input)
         repo_url_input = self.query_one("#repo_url", Input)
@@ -269,8 +309,7 @@ class DeploymentFormWidget(Widget):
             id=self.form_data.id,
             repo_url=repo_url_input.value.strip(),
             git_ref=git_ref_input.value.strip() or "main",
-            deployment_file_path=deployment_file_input.value.strip()
-            or "llama_deploy.yaml",
+            deployment_file_path=deployment_file_input.value.strip(),
             personal_access_token=pat_value,
             secrets=updated_secrets,
             initial_secrets=self.original_form_data.initial_secrets,
@@ -299,15 +338,26 @@ class StartValidationMessage(Message):
         self.form_data = form_data
 
 
+class ShowHelpMessage(Message):
+    def __init__(self, form_data: DeploymentForm):
+        super().__init__()
+        self.form_data = form_data
+
+
+class HelpBackMessage(Message):
+    pass
+
+
 class DeploymentEditApp(App[DeploymentResponse | None]):
     """Textual app for editing/creating deployments"""
 
     CSS_PATH = Path(__file__).parent / "styles.tcss"
 
-    # App states: 'form' or 'validation'
+    # App states: 'form', 'validation', 'help', or 'monitor'
     current_state: reactive[str] = reactive("form", recompose=True)
     form_data: reactive[DeploymentForm] = reactive(DeploymentForm())
     save_error: reactive[str] = reactive("", recompose=True)
+    saved_deployment = reactive[DeploymentResponse | None](None, recompose=True)
 
     def __init__(self, initial_data: DeploymentForm):
         super().__init__()
@@ -317,13 +367,17 @@ class DeploymentEditApp(App[DeploymentResponse | None]):
     def on_mount(self) -> None:
         self.theme = "tokyo-night"
 
-    def on_key(self, event) -> None:
+    def on_key(self, event: events.Key) -> None:
         """Handle key events, including Ctrl+C"""
         if event.key == "ctrl+c":
-            self.exit(None)
+            if self.current_state == "monitor" and self.saved_deployment is not None:
+                self.exit(self.saved_deployment)
+            else:
+                self.exit(None)
 
     def compose(self) -> ComposeResult:
-        with Container(classes="form-container"):
+        is_slim = self.current_state != "monitor"
+        with Container(classes="form-container" if is_slim else ""):
             if self.current_state == "form":
                 yield DeploymentFormWidget(self.form_data, self.save_error)
             elif self.current_state == "validation":
@@ -336,6 +390,28 @@ class DeploymentEditApp(App[DeploymentResponse | None]):
                     if self.form_data.personal_access_token
                     else None,
                 )
+            elif self.current_state == "help":
+                yield DeploymentHelpWidget()
+            elif self.current_state == "monitor":
+                deployment_id = (
+                    self.saved_deployment.id if self.saved_deployment else ""
+                )
+                yield DeploymentMonitorWidget(deployment_id)
+            else:
+                yield Static("Unknown state: " + self.current_state)
+
+    def action_show_help(self) -> None:
+        widget = self.query("DeploymentFormWidget")
+        if widget:
+            typed_widget: DeploymentFormWidget = widget[0]
+            self.form_data = typed_widget.resolve_form_data()
+
+        self.current_state = "help"
+
+    def on_deployment_help_back_message(
+        self, message: DeploymentHelpBackMessage
+    ) -> None:
+        self.current_state = "form"
 
     def on_start_validation_message(self, message: StartValidationMessage) -> None:
         """Handle validation start message from form widget"""
@@ -343,7 +419,9 @@ class DeploymentEditApp(App[DeploymentResponse | None]):
         self.save_error = ""  # Clear any previous errors
         self.current_state = "validation"
 
-    def on_validation_result_message(self, message: ValidationResultMessage) -> None:
+    async def on_validation_result_message(
+        self, message: ValidationResultMessage
+    ) -> None:
         """Handle validation success from git validation widget"""
         logging.info("validation result message", message)
         # Update form data with validated PAT if provided
@@ -355,30 +433,44 @@ class DeploymentEditApp(App[DeploymentResponse | None]):
                 updated_form.has_existing_pat = False
             self.form_data = updated_form
 
-        # Proceed with save
-        self._perform_save()
+        # Proceed with save (async)
+        await self._perform_save()
 
     def on_validation_cancel_message(self, message: ValidationCancelMessage) -> None:
         """Handle validation cancellation from git validation widget"""
         # Return to form, clearing any save error
-        print("DEBUG: on_validation_cancel_message")
         self.save_error = ""
         self.current_state = "form"
 
-    def _perform_save(self) -> None:
+    def on_show_help_message(self, message: ShowHelpMessage) -> None:
+        """Navigate to help view, preserving current form state."""
+        self.form_data = message.form_data
+        self.current_state = "help"
+
+    def on_help_back_message(self, message: HelpBackMessage) -> None:
+        """Return from help to form, keeping form state intact."""
+        self.current_state = "form"
+
+    async def _perform_save(self) -> None:
         """Actually save the deployment after validation"""
         logging.info("saving form data", self.form_data)
         result = self.form_data
         client = get_client()
         try:
-            if result.is_editing:
-                update_deployment = client.update_deployment(
-                    result.id, result.to_update()
-                )
-            else:
-                update_deployment = client.create_deployment(result.to_create())
-            # Exit with result
-            self.exit(update_deployment)
+            update_deployment = (
+                await client.update_deployment(result.id, result.to_update())
+                if result.is_editing
+                else await client.create_deployment(result.to_create())
+            )
+            # Save and navigate to embedded monitor screen
+            self.saved_deployment = update_deployment
+            # Ensure form_data carries the new ID for any subsequent operations
+            if not result.is_editing and update_deployment.id:
+                updated_form = dataclasses.replace(self.form_data)
+                updated_form.id = update_deployment.id
+                updated_form.is_editing = True
+                self.form_data = updated_form
+            self.current_state = "monitor"
         except Exception as e:
             # Return to form and show error
             self.save_error = f"Error saving deployment: {e}"
@@ -392,6 +484,10 @@ class DeploymentEditApp(App[DeploymentResponse | None]):
         """Handle cancel message from form widget"""
         self.exit(None)
 
+    def on_monitor_close_message(self, _: MonitorCloseMessage) -> None:
+        """Handle close from embedded monitor by exiting with saved deployment."""
+        self.exit(self.saved_deployment)
+
 
 def edit_deployment_form(
     deployment: DeploymentResponse,
@@ -404,6 +500,137 @@ def edit_deployment_form(
 
 def create_deployment_form() -> DeploymentResponse | None:
     """Launch deployment creation form and return result"""
-    initial_data = DeploymentForm()
+    initial_data = _initialize_deployment_data()
     app = DeploymentEditApp(initial_data)
     return app.run()
+
+
+def _initialize_deployment_data() -> DeploymentForm:
+    """
+    initialize the deployment form data from the current git repo and .env file
+    """
+
+    repo_url: str | None = None
+    git_ref: str | None = None
+    secrets: dict[str, str] = {}
+    name: str | None = None
+    config_file_path: str | None = None
+    warnings: list[str] = []
+    has_git = is_git_repo()
+    has_no_workflows = False
+    try:
+        config = read_deployment_config(Path("."), Path("."))
+        if config.name != DEFAULT_DEPLOYMENT_NAME:
+            name = config.name
+        has_no_workflows = config.has_no_workflows()
+    except Exception:
+        warnings.append("Could not parse local deployment config. It may be invalid.")
+    if not has_git and has_no_workflows:
+        warnings = [
+            "Run from within a git repository to automatically generate a deployment config."
+        ]
+    elif has_no_workflows:
+        warnings = [
+            "The current project has no workflows configured. It may be invalid."
+        ]
+    elif not has_git:
+        warnings.append(
+            "Current directory is not a git repository. If you are trying to deploy this directory, you will need to create a git repository and push it before creating a deployment."
+        )
+    else:
+        seen = set[str]()
+        remotes = list_remotes()
+        candidate_origins = []
+        for remote in remotes:
+            normalized_url = _normalize_to_http(remote)
+            if normalized_url not in seen:
+                candidate_origins.append(normalized_url)
+                seen.add(normalized_url)
+        preferred_origin = sorted(
+            candidate_origins, key=lambda x: "github.com" in x, reverse=True
+        )
+        if preferred_origin:
+            repo_url = preferred_origin[0]
+        git_ref = get_current_branch()
+        root = get_git_root()
+        if root != Path.cwd():
+            config_file_path = str(Path.cwd().relative_to(root))
+
+        if not preferred_origin:
+            warnings.append(
+                "No git remote was found. You will need to push your changes to a remote repository before creating a deployment from this repository."
+            )
+        else:
+            # Working tree changes
+            if working_tree_has_changes() and preferred_origin:
+                warnings.append(
+                    "Working tree has uncommitted or untracked changes. You may want to push them before creating a deployment from this branch."
+                )
+            else:
+                # Unpushed commits (ahead of upstream)
+                ahead = get_unpushed_commits_count()
+                if ahead is None:
+                    warnings.append(
+                        "Current branch has no upstream configured. You will need to push them or choose a different branch."
+                    )
+                elif ahead > 0:
+                    warnings.append(
+                        f"There are {ahead} local commits not pushed to upstream. They won't be included in the deployment unless you push them first."
+                    )
+    env_info_message = None
+    if Path(".env").exists():
+        secrets = load_env_secrets_from_string(Path(".env").read_text())
+        if len(secrets) > 0:
+            env_info_message = "Secrets were automatically seeded from your .env file. Remove or change any that should not be set. They must be manually configured after creation."
+
+    form = DeploymentForm(
+        name=name or "",
+        repo_url=repo_url or "",
+        git_ref=git_ref or "main",
+        secrets=secrets,
+        deployment_file_path=config_file_path or "",
+        warnings=warnings,
+        env_info_messages=env_info_message,
+    )
+    return form
+
+
+def _normalize_to_http(url: str) -> str:
+    """
+    normalize a git url to a best guess for a corresponding http(s) url
+    """
+    candidate = (url or "").strip()
+
+    # If no scheme, first try scp-like SSH syntax: [user@]host:path
+    has_scheme = "://" in candidate
+    if not has_scheme:
+        scp_match = re.match(
+            r"^(?:(?P<user>[^@]+)@)?(?P<host>[^:/\s]+):(?P<path>[^/].+)$",
+            candidate,
+        )
+        if scp_match:
+            host = scp_match.group("host")
+            path = scp_match.group("path").lstrip("/")
+            if path.endswith(".git"):
+                path = path[:-4]
+            return f"https://{host}/{path}"
+
+    # If no scheme (and not scp), assume host/path and prepend https
+    parsed = urlsplit(candidate if has_scheme else f"https://{candidate}")
+
+    # Drop credentials from netloc
+    netloc = parsed.netloc.split("@", 1)[-1]
+
+    # Drop explicit port (common for SSH like :7999 which is wrong for https)
+    if ":" in netloc:
+        netloc = netloc.split(":", 1)[0]
+
+    # Normalize path and strip .git
+    path = parsed.path.lstrip("/")
+    if path.endswith(".git"):
+        path = path[:-4]
+
+    if path:
+        return f"https://{netloc}/{path}"
+    else:
+        return f"https://{netloc}"

llama_deploy/cli/textual/deployment_help.py

@@ -0,0 +1,53 @@
+from textwrap import dedent
+
+from textual.app import ComposeResult
+from textual.containers import HorizontalGroup, Widget
+from textual.content import Content
+from textual.message import Message
+from textual.widgets import Button, Static
+
+
+class DeploymentHelpBackMessage(Message):
+    pass
+
+
+class DeploymentHelpWidget(Widget):
+    DEFAULT_CSS = """
+    DeploymentHelpWidget {
+        layout: vertical;
+        height: auto;
+    }
+    """
+
+    def compose(self) -> ComposeResult:
+        yield Static(
+            "Deploy your app to llama cloud or your own infrastructure:",
+            classes="primary-message",
+        )
+        yield Static(
+            Content.from_markup(
+                dedent("""
+                [b]Deployment Name[/b]
+                A unique name to identify this deployment. Controls the URL where your deployment is accessible. Will have a random suffix appended if not unique.
+                
+                [b]Git Repository[/b]
+                A git repository URL to pull code from. If not publically accessible, you will be prompted to install the llama deploy github app. If code is on another platform, either provide a Personal Access Token (basic access credentials) instead.
+                
+                [b]Git Ref[/b]
+                The git ref to deploy. This can be a branch, tag, or commit hash. If this is a branch, after deploying, run a `[slategrey reverse]llamactl deploy update[/]` to update the deployment to the latest git ref after you make updates.
+                
+                [b]Config File[/b]
+                Path to a directory or file containing a `[slategrey reverse]pyproject.toml[/]` or `[slategrey reverse]llama_deploy.yaml[/]` containing the llama deploy configuration. Only necessary if you have the configuration not at the root of the repo, or you have an unconventional configuration file.
+                
+                [b]Secrets[/b]
+                Secrets to add as environment variables to the deployment. e.g. to access a database or an API. Supports adding in `[slategrey reverse].env[/]` file format.
+                
+                """).strip()
+            ),
+        )
+        with HorizontalGroup(classes="button-row"):
+            yield Button("Back", variant="primary", id="help_back", compact=True)
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "help_back":
+            self.post_message(DeploymentHelpBackMessage())