pyvolt-cli 0.3.2__tar.gz → 0.4.0__tar.gz

{pyvolt_cli-0.3.2 → pyvolt_cli-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyvolt-cli
-Version: 0.3.2
+Version: 0.4.0
 Summary: The command-line companion to Pyvolt: managed Python deployments on infrastructure you actually own.
 Project-URL: Homepage, https://pyvolt.com
 Project-URL: Repository, https://github.com/pyvolt-hq/pyvolt-cli

{pyvolt_cli-0.3.2 → pyvolt_cli-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pyvolt-cli"
-version = "0.3.2"
+version = "0.4.0"
 description = "The command-line companion to Pyvolt: managed Python deployments on infrastructure you actually own."
 readme = "README.md"
 license = { text = "MIT" }

pyvolt_cli-0.4.0/pyvolt_cli/__init__.py

@@ -0,0 +1,9 @@
+"""pyvolt-cli: the terminal companion to Pyvolt — managed Python deployments
+on infrastructure you actually own. Docs: https://pyvolt.com/docs/cli/"""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("pyvolt-cli")
+except PackageNotFoundError:  # running from a source tree without an install
+    __version__ = "0.0.0.dev0"

{pyvolt_cli-0.3.2 → pyvolt_cli-0.4.0}/pyvolt_cli/app.py

@@ -36,7 +36,7 @@ def _emit(data) -> bool:
     return False
 
 STATUS_STYLE = {
-    "ready": "green", "live": "green", "succeeded": "green", "running": "cyan",
+    "ready": "green", "live": "green", "success": "green", "running": "cyan",
     "active": "green", "queued": "yellow", "deploying": "cyan",
     "failed": "red", "error": "red", "inactive": "red",
 }
@@ -171,9 +171,18 @@ def ssh(
     os.execvp("ssh", args)
 
 
-@app.command()
-def apps(server: str = typer.Option("", "--server", help="Filter by server name.")):
+apps_app = typer.Typer(help="List your apps; `pyvolt apps create` makes a new one.")
+app.add_typer(apps_app, name="apps")
+
+
+@apps_app.callback(invoke_without_command=True)
+def apps(
+    ctx: typer.Context,
+    server: str = typer.Option("", "--server", help="Filter by server name."),
+):
     """List your apps."""
+    if ctx.invoked_subcommand is not None:
+        return
     data = Api().get("/v1/apps", params={"server": server} if server else None)
     if _emit(data):
         return
@@ -183,6 +192,101 @@ def apps(server: str = typer.Option("", "--server", help="Filter by server name.
     console.print(t)
 
 
+@apps_app.command("create")
+def apps_create(
+    server: str = typer.Option(..., "--server", "-s", metavar="SERVER", help="Server to create the app on."),
+    domain: str = typer.Option(..., "--domain", "-d", help="Subdomain prefix (no dots — becomes <prefix>.preview.pyvolt.com) or a full custom domain."),
+    repo: str = typer.Option("", "--repo", "-r", metavar="OWNER/REPO", help="GitHub repository, resolved through your connection."),
+    repo_url: str = typer.Option("", "--repo-url", help="Raw git URL for repos outside a GitHub connection."),
+    branch: str = typer.Option("main", "--branch", "-b", help="Branch deploys ship from."),
+    path: str = typer.Option("", "--path", help="Project directory inside the repo (monorepos)."),
+    env: list[str] = typer.Option([], "--env", "-e", metavar="KEY=VALUE", help="Create-time env var (repeatable)."),
+    serve_command: str = typer.Option("", "--serve-command", help="Override the detected start command."),
+    release_command: str = typer.Option("", "--release-command", help="Override the detected release steps."),
+    build_command: str = typer.Option("", "--build-command", help="Override the detected build command."),
+    python_version: str = typer.Option("", "--python", help="Override the detected Python version."),
+    dry_run: bool = typer.Option(False, "--dry-run", help="Show the resolved plan without creating anything."),
+):
+    """Create an app on one of your servers.
+
+    Repo autodiscovery prefills the framework, serve and release commands
+    (same as the dashboard form); every flag above overrides it. Use
+    --dry-run to inspect the plan first, then create and follow up with
+    `pyvolt deploy DOMAIN --follow`."""
+    api = Api()
+    srv = api.resolve_server(server)
+    env_map: dict[str, str] = {}
+    for pair in env:
+        if "=" not in pair:
+            raise fail(f"Expected KEY=VALUE, got [bold]{pair}[/bold]")
+        key, _, value = pair.partition("=")
+        env_map[key] = value
+    payload = {
+        "server": srv["name"],
+        "repo": repo,
+        "repo_url": repo_url,
+        "branch": branch,
+        "project_path": path,
+        "env": env_map,
+        "serve_command": serve_command,
+        "release_command": release_command,
+        "build_command": build_command,
+        "python_version": python_version,
+        "dry_run": dry_run,
+    }
+    # A dot means "that's the whole domain"; a bare word is a pyvolt
+    # subdomain prefix. Prefixes can't contain dots, so this never guesses.
+    payload["custom_domain" if "." in domain else "domain_prefix"] = domain
+    r = api.post("/v1/apps", ok=(200, 201, 400, 402, 409), json=payload)
+    if r.status_code in (400, 402, 409):
+        raise fail(r.json()["detail"])
+    body = r.json()
+    if _emit(body):
+        return
+
+    plan = body["plan"]
+    t = _table("FIELD", "VALUE")
+    t.add_row("domain", plan["domain"])
+    t.add_row("repo", f"{plan['repo_url']} @ {plan['branch']}")
+    if plan["framework"]:
+        t.add_row("framework", plan["framework"])
+    t.add_row("protocol", plan["app_protocol"].upper())
+    t.add_row("package manager", plan["package_manager"])
+    if plan["python_version"]:
+        t.add_row("python", plan["python_version"])
+    if plan["serve_command"]:
+        t.add_row("serve", plan["serve_command"])
+    if plan["release_command"]:
+        t.add_row("release", plan["release_command"])
+    if plan["build_command"]:
+        t.add_row("build", plan["build_command"])
+    if plan["frontend_dir"]:
+        t.add_row("frontend", f"{plan['frontend_dir']}/ (passthrough: {plan['frontend_passthrough'] or 'none'})")
+    console.print(t)
+    if plan["evidence"]:
+        console.print(f"[dim]Found: {', '.join(plan['evidence'])}[/dim]")
+    for w in plan["warnings"]:
+        console.print(f"[yellow]⚠[/yellow] {w}")
+
+    if dry_run:
+        console.print("[dim]Dry run — nothing was created.[/dim]")
+        return
+    created = body["app"]
+    if not body["scaffolded"]:
+        err_detail = body["scaffold_error"] or "unknown error"
+        console.print(f"[red]✗[/red] App row created but scaffolding failed: {err_detail}")
+        console.print(f"  Retry from the dashboard: {created['dashboard_url']}")
+        raise typer.Exit(1)
+    if body["deploy_key_ok"] is False:
+        console.print(
+            "[yellow]⚠[/yellow] Deploy key push failed — deploys will fail at clone. "
+            "Grant the Pyvolt GitHub App access to the repo, then redeploy."
+        )
+    console.print(f"[green]✓[/green] Created [bold]{created['domain']}[/bold]")
+    console.print(f"  Deploy:     [bold]pyvolt deploy {created['domain']} --follow[/bold]")
+    console.print(f"  Dashboard:  {created['dashboard_url']}")
+
+
 @app.command()
 def status(app_name: str = typer.Argument(..., metavar="DOMAIN")):
     """Show one app's details: status, URLs, repo and branch."""
@@ -202,7 +306,7 @@ def status(app_name: str = typer.Argument(..., metavar="DOMAIN")):
 
 # ---- deployments --------------------------------------------------------------
 
-TERMINAL = ("succeeded", "failed")
+TERMINAL = ("success", "failed")
 
 
 def _follow(api: Api, deployment_id: int) -> str:

pyvolt_cli-0.3.2/pyvolt_cli/__init__.py

@@ -1,4 +0,0 @@
-"""pyvolt-cli: the terminal companion to Pyvolt — managed Python deployments
-on infrastructure you actually own. Docs: https://pyvolt.com/docs/cli/"""
-
-__version__ = "0.3.0"