general-augment-cli 0.1.0__py3-none-any.whl

platform_cli/commands/auth.py

@@ -0,0 +1,96 @@
+"""Authentication commands."""
+
+from __future__ import annotations
+
+from typing import cast
+
+import typer
+from rich.prompt import Prompt
+
+from platform_cli.config import clear_config, save_config
+from platform_cli.output import panel, print_success
+from platform_cli.runtime import Runtime
+
+app = typer.Typer(help="Authenticate the CLI.")
+
+
+@app.command("login")
+def login(
+    ctx: typer.Context,
+    api_key: str | None = typer.Option(None, help="Admin API key."),
+    base_url: str | None = typer.Option(None, help="Platform API base URL."),
+    skip_verify: bool = typer.Option(
+        False,
+        "--skip-verify",
+        help="Store the key without calling the platform API.",
+    ),
+) -> None:
+    """Store an API key locally after verifying it can reach the API."""
+    runtime = _runtime(ctx)
+    key = api_key or Prompt.ask("API key", password=True)
+    next_config = runtime.config.model_copy(
+        update={
+            "api_key": key,
+            "base_url": (base_url or runtime.config.base_url).rstrip("/"),
+        }
+    )
+    identity: dict[str, object] | None = None
+    if not skip_verify:
+        verify_runtime = Runtime(
+            config=next_config,
+            config_path=runtime.config_path,
+            loaded_config_path=runtime.loaded_config_path,
+        )
+        with verify_runtime.client() as client:
+            identity = client.admin("GET", "/me")
+    path = save_config(next_config, runtime.config_path)
+    print_success(f"Authenticated. Config saved to {path}")
+    if identity is not None:
+        print_success(
+            f"Verified API access as {identity.get('auth_method', 'api_key')!s}; "
+            f"projects: {_project_scope(identity)}"
+        )
+
+
+@app.command("logout")
+def logout(ctx: typer.Context) -> None:
+    """Remove local authentication."""
+    runtime = _runtime(ctx)
+    clear_config(runtime.config_path)
+    if runtime.loaded_config_path != runtime.config_path:
+        clear_config(runtime.loaded_config_path)
+    print_success("Logged out.")
+
+
+@app.command("whoami")
+def whoami(ctx: typer.Context) -> None:
+    """Show the current API identity."""
+    runtime = _runtime(ctx)
+    if not runtime.config.api_key:
+        panel("Not authenticated", "Run genaug auth login to configure an API key.")
+        return
+    with runtime.client() as client:
+        payload = client.admin("GET", "/me")
+    panel(
+        "Current identity",
+        f"Base URL: {runtime.config.base_url}\n"
+        f"Auth method: {payload.get('auth_method', 'unknown')}\n"
+        f"Project IDs: {_project_scope(payload)}",
+    )
+
+
+def _runtime(ctx: typer.Context) -> Runtime:
+    """Return the current runtime object."""
+    return cast(Runtime, ctx.obj)
+
+
+def _project_scope(identity: dict[str, object]) -> str:
+    """Return a display string for project scope from /me."""
+    raw_project_ids = identity.get("project_ids")
+    if isinstance(raw_project_ids, list) and raw_project_ids:
+        project_ids = raw_project_ids
+    elif identity.get("project_id"):
+        project_ids = [identity["project_id"]]
+    else:
+        project_ids = []
+    return ", ".join(str(project_id) for project_id in project_ids) or "global"

platform_cli/commands/billing.py

@@ -0,0 +1,143 @@
+"""Billing lifecycle commands."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+from platform_cli.client import encode_path_segment, resolve_project
+from platform_cli.output import print_json, print_success, print_warning, table
+from platform_cli.runtime import Runtime
+
+app = typer.Typer(help="Manage hosted billing lifecycle actions.")
+
+
+@app.command("checkout")
+def create_checkout_session(
+    ctx: typer.Context,
+    project: Annotated[str, typer.Option(help="Project id, slug, or name.")],
+    tier: Annotated[str, typer.Option(help="Paid target tier: pro or team.")],
+    json_output: Annotated[
+        bool,
+        typer.Option("--json", help="Print machine-readable JSON."),
+    ] = False,
+) -> None:
+    """Create a hosted Stripe Checkout session URL for a paid tier."""
+    target_tier = _target_tier(tier)
+    runtime: Runtime = ctx.obj
+    with runtime.client() as client:
+        project_payload = resolve_project(client, project)
+        response = client.admin(
+            "POST",
+            f"/projects/{encode_path_segment(str(project_payload['id']))}/billing/checkout-session",
+            json={"target_tier": target_tier},
+        )
+    if json_output:
+        print_json(response)
+        return
+    url = _value(response, "url")
+    print_success(
+        f"Created {target_tier} checkout session for {project_payload.get('slug', project)}."
+    )
+    table(
+        "Billing checkout",
+        ["Field", "Value"],
+        [
+            ["Target tier", target_tier],
+            ["URL", url],
+            ["Next step", "Open the hosted URL and confirm the Stripe webhook event syncs."],
+        ],
+    )
+
+
+@app.command("portal")
+def create_portal_session(
+    ctx: typer.Context,
+    project: Annotated[str, typer.Option(help="Project id, slug, or name.")],
+    json_output: Annotated[
+        bool,
+        typer.Option("--json", help="Print machine-readable JSON."),
+    ] = False,
+) -> None:
+    """Create a hosted Stripe Customer Portal session URL."""
+    runtime: Runtime = ctx.obj
+    with runtime.client() as client:
+        project_payload = resolve_project(client, project)
+        response = client.admin(
+            "POST",
+            f"/projects/{encode_path_segment(str(project_payload['id']))}/billing/portal-session",
+        )
+    if json_output:
+        print_json(response)
+        return
+    url = _value(response, "url")
+    print_success(f"Created customer portal session for {project_payload.get('slug', project)}.")
+    table(
+        "Billing portal",
+        ["Field", "Value"],
+        [
+            ["URL", url],
+            ["Next step", "Open the hosted URL for card, invoice, cancellation, or plan actions."],
+        ],
+    )
+
+
+@app.command("events")
+def list_billing_events(
+    ctx: typer.Context,
+    project: Annotated[str, typer.Option(help="Project id, slug, or name.")],
+    json_output: Annotated[
+        bool,
+        typer.Option("--json", help="Print machine-readable JSON."),
+    ] = False,
+) -> None:
+    """List recent Stripe billing lifecycle events stored by General Augment."""
+    runtime: Runtime = ctx.obj
+    with runtime.client() as client:
+        project_payload = resolve_project(client, project)
+        response = client.admin(
+            "GET",
+            f"/projects/{encode_path_segment(str(project_payload['id']))}/billing/events",
+        )
+    if json_output:
+        print_json(response)
+        return
+    items = response.get("items", []) if isinstance(response, dict) else []
+    rows = [_event_row(item) for item in items if isinstance(item, dict)]
+    if not rows:
+        print_warning("No billing events are stored for this project yet.")
+    table(
+        f"Billing events for {project_payload.get('slug', project)}",
+        ["Event", "Status", "Tier", "Invoice", "Processed at"],
+        rows,
+    )
+
+
+def _target_tier(value: str) -> str:
+    """Normalize and validate a checkout target tier."""
+
+    target = value.casefold()
+    if target not in {"pro", "team"}:
+        raise typer.BadParameter("Paid target tier must be 'pro' or 'team'.")
+    return target
+
+
+def _event_row(item: dict[str, object]) -> list[object]:
+    """Return one billing event table row."""
+
+    return [
+        item.get("event_type", ""),
+        item.get("status", "") or "",
+        item.get("target_pricing_tier", "") or "",
+        item.get("stripe_invoice_id", "") or "",
+        item.get("processed_at", "") or item.get("created_at", "") or "",
+    ]
+
+
+def _value(payload: object, key: str) -> object:
+    """Safely read one response value."""
+
+    if isinstance(payload, dict):
+        return payload.get(key, "")
+    return ""

platform_cli/commands/channels.py

@@ -0,0 +1,212 @@
+"""Channel management commands."""
+
+from __future__ import annotations
+
+import typer
+
+from platform_cli.client import encode_path_segment, resolve_project
+from platform_cli.output import panel, print_json, print_success, table
+from platform_cli.runtime import Runtime
+
+app = typer.Typer(help="Manage channels.")
+
+
+@app.command("status")
+def channel_status(
+    ctx: typer.Context,
+    project: str = typer.Option(..., help="Project id, slug, or name."),
+    json_output: bool = typer.Option(False, "--json", help="Print machine-readable JSON."),
+) -> None:
+    """Show channel status."""
+    runtime: Runtime = ctx.obj
+    with runtime.client() as client:
+        project_payload = resolve_project(client, project)
+        telegram = client.admin(
+            "GET",
+            "/channels/telegram/status",
+            params={"project_id": project_payload["id"]},
+        )
+    if json_output:
+        print_json(
+            {
+                "project": project_payload,
+                "channels": {
+                    "whatsapp": {
+                        "connected": bool(project_payload.get("whatsapp_phone_number_id")),
+                        "phone_number_id": project_payload.get("whatsapp_phone_number_id"),
+                    },
+                    "sms": {
+                        "connected": bool(project_payload.get("twilio_phone_number")),
+                        "twilio_phone_number": project_payload.get("twilio_phone_number"),
+                    },
+                    "telegram": telegram,
+                },
+            }
+        )
+        return
+    rows: list[list[object]] = [
+        ["WhatsApp", "connected" if project_payload.get("whatsapp_phone_number_id") else "open"],
+        ["SMS", "connected" if project_payload.get("twilio_phone_number") else "open"],
+        ["Telegram", "connected" if telegram.get("connected") else "open"],
+    ]
+    table("Channels", ["Channel", "Status"], rows)
+    if telegram.get("bot_username"):
+        panel(
+            "Telegram",
+            f"Bot: @{telegram['bot_username']}\n"
+            f"Last message: {telegram.get('last_message_at') or 'never'}\n"
+            f"24h messages: {telegram.get('message_count_24h', 0)}",
+        )
+
+
+@app.command("connect")
+def channel_connect(
+    ctx: typer.Context,
+    project: str = typer.Option(..., help="Project id, slug, or name."),
+    channel: str = typer.Option("telegram", help="Channel to connect."),
+    bot_token: str | None = typer.Option(None, help="Telegram bot token."),
+    phone_number_id: str | None = typer.Option(
+        None,
+        "--phone-number-id",
+        help="WhatsApp Business phone number id.",
+    ),
+    twilio_number: str | None = typer.Option(
+        None,
+        "--twilio-number",
+        help="Twilio SMS sender number.",
+    ),
+    webhook_base_url: str | None = typer.Option(None, help="Public API base URL."),
+) -> None:
+    """Connect a provider channel."""
+    normalized_channel = _normalize_channel(channel)
+    runtime: Runtime = ctx.obj
+    with runtime.client() as client:
+        project_payload = resolve_project(client, project)
+        if normalized_channel == "telegram":
+            if not bot_token:
+                bot_token = typer.prompt("Telegram bot token", hide_input=True)
+            response = client.admin(
+                "POST",
+                "/channels/telegram/connect",
+                json={
+                    "project_id": str(project_payload["id"]),
+                    "bot_token": bot_token,
+                    "webhook_base_url": webhook_base_url or runtime.config.base_url,
+                },
+            )
+            print_success(f"Telegram connected: @{response.get('bot_username', 'bot')}")
+            return
+        if normalized_channel == "whatsapp":
+            value = _required_channel_value(
+                phone_number_id or typer.prompt("WhatsApp Business phone number id"),
+                "--phone-number-id",
+            )
+            client.admin(
+                "PATCH",
+                f"/projects/{encode_path_segment(str(project_payload['id']))}",
+                json={"whatsapp_phone_number_id": value},
+            )
+            print_success("WhatsApp sender configured.")
+            return
+        value = _required_channel_value(
+            twilio_number or typer.prompt("Twilio SMS sender number"),
+            "--twilio-number",
+        )
+        client.admin(
+            "PATCH",
+            f"/projects/{encode_path_segment(str(project_payload['id']))}",
+            json={"twilio_phone_number": value},
+        )
+        print_success("SMS sender configured.")
+
+
+@app.command("disconnect")
+def channel_disconnect(
+    ctx: typer.Context,
+    project: str = typer.Option(..., help="Project id, slug, or name."),
+    channel: str = typer.Option("telegram", help="Channel to disconnect."),
+    yes: bool = typer.Option(False, "--yes", help="Confirm disconnecting this channel."),
+    json_output: bool = typer.Option(False, "--json", help="Print machine-readable JSON."),
+) -> None:
+    """Disconnect a provider channel."""
+    normalized_channel = _normalize_channel(channel)
+    label = _channel_label(normalized_channel)
+    if not yes and not typer.confirm(f"Disconnect {label} for project {project}?"):
+        raise typer.Exit(1)
+    runtime: Runtime = ctx.obj
+    with runtime.client() as client:
+        project_payload = resolve_project(client, project)
+        if normalized_channel == "telegram":
+            response = client.admin(
+                "POST",
+                "/channels/telegram/disconnect",
+                json={"project_id": str(project_payload["id"])},
+            )
+        else:
+            field = (
+                "whatsapp_phone_number_id"
+                if normalized_channel == "whatsapp"
+                else "twilio_phone_number"
+            )
+            response = client.admin(
+                "PATCH",
+                f"/projects/{encode_path_segment(str(project_payload['id']))}",
+                json={field: None},
+            )
+    if json_output:
+        print_json(response)
+        return
+    print_success(f"{label} disconnected.")
+
+
+@app.command("test")
+def channel_test(
+    ctx: typer.Context,
+    project: str = typer.Option(..., help="Project id, slug, or name."),
+    channel: str = typer.Option("telegram", help="Channel to test."),
+    chat_id: str | None = typer.Option(None, help="Telegram chat id for a test message."),
+    message: str = typer.Option("Hello from your General Augment agent.", help="Test message."),
+    json_output: bool = typer.Option(False, "--json", help="Print machine-readable JSON."),
+) -> None:
+    """Send a provider test message."""
+    if channel != "telegram":
+        raise typer.BadParameter("Only telegram guided test is supported by this command.")
+    if not chat_id:
+        chat_id = typer.prompt("Telegram chat id")
+    runtime: Runtime = ctx.obj
+    with runtime.client() as client:
+        project_payload = resolve_project(client, project)
+        response = client.admin(
+            "POST",
+            "/channels/telegram/test",
+            json={
+                "project_id": str(project_payload["id"]),
+                "chat_id": chat_id,
+                "message": message,
+            },
+        )
+    if json_output:
+        print_json(response)
+        return
+    print_success("Telegram test message sent.")
+
+
+def _normalize_channel(channel: str) -> str:
+    """Return a supported channel id."""
+    normalized = channel.strip().casefold()
+    if normalized not in {"telegram", "whatsapp", "sms"}:
+        raise typer.BadParameter("--channel must be one of: telegram, whatsapp, sms")
+    return normalized
+
+
+def _channel_label(channel: str) -> str:
+    """Return a display label for a channel id."""
+    return {"telegram": "Telegram", "whatsapp": "WhatsApp", "sms": "SMS"}[channel]
+
+
+def _required_channel_value(value: str, option_name: str) -> str:
+    """Return a non-empty channel configuration value."""
+    normalized = value.strip()
+    if not normalized:
+        raise typer.BadParameter(f"{option_name} is required for this channel")
+    return normalized

platform_cli/commands/deploy.py

@@ -0,0 +1,72 @@
+"""Deploy local agent configuration."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated, Any, cast
+
+import typer
+
+from platform_cli.client import encode_path_segment, resolve_project
+from platform_cli.errors import CLIError
+from platform_cli.openapi import load_deploy_payload, project_name_from_config
+from platform_cli.output import panel, print_success
+from platform_cli.runtime import Runtime
+
+
+def deploy(
+    ctx: typer.Context,
+    config_path: Annotated[
+        Path,
+        typer.Argument(
+            exists=True,
+            dir_okay=False,
+            help="genaug-agent.yaml manifest to deploy.",
+        ),
+    ],
+    project: Annotated[
+        str | None,
+        typer.Option("--project", help="Project id, slug, or name."),
+    ] = None,
+) -> None:
+    """Validate and upload a local agent manifest."""
+    runtime: Runtime = ctx.obj
+    deploy_path(runtime, config_path, project_ref=project)
+
+
+def deploy_path(runtime: Runtime, config_path: Path, project_ref: str | None) -> dict[str, Any]:
+    """Deploy a local config path."""
+    payload = load_deploy_payload(config_path)
+    local_name = project_ref or project_name_from_config(config_path)
+    with runtime.client() as client:
+        try:
+            existing = resolve_project(client, local_name)
+        except CLIError as exc:
+            if "Project not found" not in exc.message:
+                raise
+            existing = None
+        if existing:
+            response = cast(
+                dict[str, Any],
+                client.admin(
+                    "PUT",
+                    f"/projects/{encode_path_segment(str(existing['id']))}/config",
+                    json=payload,
+                ),
+            )
+            action = "updated"
+        else:
+            response = cast(
+                dict[str, Any],
+                client.admin("POST", "/projects/from-config", json=payload),
+            )
+            action = "created"
+    name = response.get("name") or response.get("slug") or local_name
+    print_success(f"Project {action}: {name}")
+    panel(
+        "Webhook URLs",
+        f"WhatsApp: {runtime.config.base_url}/api/v1/webhooks/whatsapp\n"
+        f"Telegram: {runtime.config.base_url}/api/v1/webhooks/telegram\n"
+        f"SMS: {runtime.config.base_url}/api/v1/webhooks/sms",
+    )
+    return response

platform_cli/commands/dev.py

@@ -0,0 +1,38 @@
+"""Local development command."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+import yaml
+
+from platform_cli.output import panel
+
+
+def dev(
+    config_path: Annotated[
+        Path,
+        typer.Argument(
+            exists=True,
+            dir_okay=False,
+            help="genaug-agent.yaml manifest to run locally.",
+        ),
+    ],
+    message: Annotated[
+        str | None,
+        typer.Option(help="Run one message and exit."),
+    ] = None,
+) -> None:
+    """Run a local mock REPL for config and personality iteration."""
+    payload = yaml.safe_load(config_path.read_text(encoding="utf-8")) or {}
+    metadata = payload.get("metadata", {}) if isinstance(payload, dict) else {}
+    name = metadata.get("display_name") or metadata.get("name") or "Agent"
+    if message:
+        panel("Local dev response", f"{name} would respond to: {message}")
+        return
+    panel("Local dev", f"Loaded {name}. Type Ctrl+C to exit.")
+    while True:
+        user_message = typer.prompt("you")
+        panel("Local dev response", f"{name} would respond to: {user_message}")