notifer-cli 1.0.0__py3-none-any.whl

notifer_cli/__init__.py

@@ -0,0 +1,3 @@
+"""Notifer CLI - Command-line interface for Notifer notification service."""
+
+__version__ = "1.0.0"

notifer_cli/cli.py

@@ -0,0 +1,47 @@
+"""Main CLI entry point."""
+import click
+from rich.console import Console
+
+from .commands import publish, subscribe, keys, topics, config, auth
+
+console = Console()
+
+
+@click.group()
+@click.version_option(version="1.0.0", prog_name="notifer")
+@click.pass_context
+def cli(ctx):
+    """
+    Notifer CLI - Simple pub-sub notifications from the command line.
+
+    Send and receive notifications, manage API keys, and configure topics.
+
+    \b
+    Examples:
+      # Publish a message
+      notifer publish my-topic "Hello World!"
+
+      # Subscribe to messages
+      notifer subscribe my-topic
+
+      # Manage API keys
+      notifer keys create "CI/CD" --scopes publish
+
+    For more help on a specific command:
+      notifer <command> --help
+    """
+    ctx.ensure_object(dict)
+
+
+# Register command groups
+cli.add_command(publish.publish)
+cli.add_command(subscribe.subscribe)
+cli.add_command(keys.keys)
+cli.add_command(topics.topics)
+cli.add_command(config.config)
+cli.add_command(auth.login)
+cli.add_command(auth.logout)
+
+
+if __name__ == "__main__":
+    cli()

notifer_cli/client.py

@@ -0,0 +1,198 @@
+"""HTTP client for Notifer API."""
+import requests
+from typing import Any, Optional
+from .config import Config
+
+
+class NotiferClient:
+    """HTTP client for Notifer API."""
+
+    def __init__(self, config: Optional[Config] = None):
+        """Initialize client with configuration."""
+        self.config = config or Config.load()
+        self.session = requests.Session()
+        self._setup_auth()
+
+    def _setup_auth(self):
+        """Setup authentication headers."""
+        if self.config.api_key:
+            self.session.headers["X-API-Key"] = self.config.api_key
+        elif self.config.access_token:
+            self.session.headers["Authorization"] = f"Bearer {self.config.access_token}"
+
+    def publish(
+        self,
+        topic: str,
+        message: str,
+        title: Optional[str] = None,
+        priority: int = 3,
+        tags: Optional[list[str]] = None,
+    ) -> dict[str, Any]:
+        """
+        Publish a message to a topic.
+
+        Args:
+            topic: Topic name
+            message: Message content
+            title: Optional message title
+            priority: Priority (1-5, default: 3)
+            tags: Optional list of tags
+
+        Returns:
+            Published message data
+
+        Raises:
+            requests.HTTPError: On API error
+        """
+        url = f"{self.config.server}/{topic}"
+        payload = {
+            "message": message,
+            "priority": priority,
+        }
+        if title:
+            payload["title"] = title
+        if tags:
+            payload["tags"] = tags
+
+        response = self.session.post(url, json=payload)
+        response.raise_for_status()
+        return response.json()
+
+    def subscribe(self, topic: str, since: Optional[str] = None):
+        """
+        Subscribe to a topic via SSE.
+
+        Args:
+            topic: Topic name
+            since: Optional timestamp to get messages since
+
+        Yields:
+            Message events as they arrive
+        """
+        url = f"{self.config.server}/{topic}/sse"
+        params = {}
+        if since:
+            params["since"] = since
+
+        response = self.session.get(url, params=params, stream=True)
+        response.raise_for_status()
+
+        # Simple SSE parsing
+        for line in response.iter_lines(decode_unicode=True):
+            if line.startswith("data: "):
+                import json
+                data = line[6:]  # Remove "data: " prefix
+                try:
+                    yield json.loads(data)
+                except json.JSONDecodeError:
+                    continue
+
+    # API Keys
+    def list_api_keys(self) -> list[dict[str, Any]]:
+        """List all API keys."""
+        url = f"{self.config.server}/api/keys"
+        response = self.session.get(url)
+        response.raise_for_status()
+        return response.json()["keys"]
+
+    def create_api_key(
+        self,
+        name: str,
+        description: Optional[str] = None,
+        scopes: Optional[list[str]] = None,
+        expires_at: Optional[str] = None,
+    ) -> dict[str, Any]:
+        """Create a new API key."""
+        url = f"{self.config.server}/api/keys"
+        payload = {"name": name}
+        if description:
+            payload["description"] = description
+        if scopes:
+            payload["scopes"] = scopes
+        if expires_at:
+            payload["expires_at"] = expires_at
+
+        response = self.session.post(url, json=payload)
+        response.raise_for_status()
+        return response.json()
+
+    def revoke_api_key(self, key_id: str) -> dict[str, Any]:
+        """Revoke an API key."""
+        url = f"{self.config.server}/api/keys/{key_id}/revoke"
+        response = self.session.post(url)
+        response.raise_for_status()
+        return response.json()
+
+    def delete_api_key(self, key_id: str):
+        """Delete an API key."""
+        url = f"{self.config.server}/api/keys/{key_id}"
+        response = self.session.delete(url)
+        response.raise_for_status()
+
+    # Topics
+    def list_topics(self, limit: int = 50, offset: int = 0) -> list[dict[str, Any]]:
+        """List all topics."""
+        url = f"{self.config.server}/api/topics"
+        params = {"limit": limit, "offset": offset}
+        response = self.session.get(url, params=params)
+        response.raise_for_status()
+        return response.json()
+
+    def my_topics(self, limit: int = 50, offset: int = 0) -> list[dict[str, Any]]:
+        """List user's topics."""
+        url = f"{self.config.server}/api/topics/my"
+        params = {"limit": limit, "offset": offset}
+        response = self.session.get(url, params=params)
+        response.raise_for_status()
+        return response.json()
+
+    def get_topic(self, name: str) -> dict[str, Any]:
+        """Get topic details."""
+        url = f"{self.config.server}/api/topics/{name}"
+        response = self.session.get(url)
+        response.raise_for_status()
+        return response.json()
+
+    def create_topic(
+        self,
+        name: str,
+        description: Optional[str] = None,
+        is_private: bool = False,
+        is_discoverable: bool = True,
+    ) -> dict[str, Any]:
+        """Create a new topic."""
+        url = f"{self.config.server}/api/topics"
+        payload = {
+            "name": name,
+            "access_level": "private" if is_private else "public",
+            "is_discoverable": is_discoverable,
+        }
+        if description:
+            payload["description"] = description
+
+        response = self.session.post(url, json=payload)
+        response.raise_for_status()
+        return response.json()
+
+    def delete_topic(self, topic_id: str):
+        """Delete a topic."""
+        url = f"{self.config.server}/api/topics/{topic_id}"
+        response = self.session.delete(url)
+        response.raise_for_status()
+
+    # Auth
+    def login(self, email: str, password: str) -> dict[str, Any]:
+        """Login with email/password."""
+        url = f"{self.config.server}/auth/login"
+        payload = {"email": email, "password": password}
+        response = self.session.post(url, json=payload)
+        response.raise_for_status()
+        data = response.json()
+
+        # Update config with tokens
+        self.config.access_token = data["access_token"]
+        self.config.refresh_token = data["refresh_token"]
+        self.config.email = email
+        self._setup_auth()
+
+        return data

notifer_cli/commands/__init__.py

@@ -0,0 +1 @@
+"""CLI commands."""

notifer_cli/commands/auth.py

@@ -0,0 +1,91 @@
+"""Authentication commands."""
+import click
+from rich.console import Console
+from rich.panel import Panel
+from getpass import getpass
+
+from ..client import NotiferClient
+from ..config import Config
+
+console = Console()
+
+
+@click.command()
+@click.argument("email", required=False)
+@click.option("--server", help="Override server URL")
+def login(email, server):
+    """
+    Login with email and password.
+
+    Stores JWT tokens in ~/.notifer.yaml for future requests.
+
+    \b
+    Examples:
+      notifer login user@example.com
+      notifer login  # Will prompt for email
+    """
+    try:
+        # Load config
+        config = Config.load()
+        if server:
+            config.server = server
+
+        # Get email if not provided
+        if not email:
+            email = click.prompt("Email")
+
+        # Get password (hidden input)
+        password = getpass("Password: ")
+
+        # Login
+        client = NotiferClient(config)
+        result = client.login(email, password)
+
+        # Save tokens to config
+        config.save()
+
+        console.print(
+            Panel(
+                f"[green]✓[/green] Logged in as [cyan]{result['user']['email']}[/cyan]\n\n"
+                f"Username: {result['user']['username']}\n"
+                f"Tier: {result['user']['subscription_tier']}\n"
+                f"Tokens saved to: {Config.config_path()}",
+                title="Login Successful",
+                border_style="green",
+            )
+        )
+
+    except Exception as e:
+        console.print(f"[red]✗ Login failed:[/red] {str(e)}", style="red")
+        raise click.Abort()
+
+
+@click.command()
+def logout():
+    """
+    Logout and clear stored credentials.
+
+    Removes tokens from ~/.notifer.yaml
+    """
+    try:
+        config = Config.load()
+
+        # Clear auth data
+        config.email = None
+        config.access_token = None
+        config.refresh_token = None
+        config.api_key = None
+        config.save()
+
+        console.print(
+            Panel(
+                "[green]✓[/green] Logged out successfully\n\n"
+                "All credentials cleared from config file.",
+                title="Logout",
+                border_style="green",
+            )
+        )
+
+    except Exception as e:
+        console.print(f"[red]✗ Error:[/red] {str(e)}", style="red")
+        raise click.Abort()

notifer_cli/commands/config.py

@@ -0,0 +1,142 @@
+"""Configuration management commands."""
+import click
+from rich.console import Console
+from rich.panel import Panel
+from rich.syntax import Syntax
+import yaml
+
+from ..config import Config
+
+console = Console()
+
+
+@click.group()
+def config():
+    """Manage CLI configuration."""
+    pass
+
+
+@config.command("init")
+def init_config():
+    """Initialize configuration file."""
+    config_file = Config.config_path()
+
+    if config_file.exists():
+        console.print(f"[yellow]Config file already exists:[/yellow] {config_file}")
+        if not click.confirm("Overwrite?", default=False):
+            return
+
+    # Create default config
+    cfg = Config()
+    cfg.save()
+
+    console.print(
+        Panel(
+            f"[green]✓[/green] Configuration file created\n\n"
+            f"Location: {config_file}\n\n"
+            f"Edit this file to set your default server and credentials.",
+            title="Config Initialized",
+            border_style="green",
+        )
+    )
+
+
+@config.command("show")
+def show_config():
+    """Show current configuration."""
+    try:
+        cfg = Config.load()
+        config_data = cfg.to_dict()
+
+        # Format as YAML for display
+        yaml_output = yaml.dump(config_data, default_flow_style=False)
+        syntax = Syntax(yaml_output, "yaml", theme="monokai", line_numbers=False)
+
+        console.print(
+            Panel(
+                syntax,
+                title=f"Configuration ({Config.config_path()})",
+                border_style="cyan",
+            )
+        )
+
+    except FileNotFoundError:
+        console.print(
+            "[yellow]No configuration file found.[/yellow]\n"
+            "Run: notifer config init"
+        )
+    except Exception as e:
+        console.print(f"[red]✗ Error:[/red] {str(e)}", style="red")
+        raise click.Abort()
+
+
+@config.command("set")
+@click.argument("key")
+@click.argument("value")
+def set_config(key, value):
+    """
+    Set a configuration value.
+
+    \b
+    Examples:
+      notifer config set server http://localhost:8080
+      notifer config set api-key noti_abc123...
+    """
+    try:
+        cfg = Config.load()
+
+        # Map CLI keys to config attributes
+        key_mapping = {
+            "server": "server",
+            "api-key": "api_key",
+            "api_key": "api_key",
+            "email": "email",
+        }
+
+        config_key = key_mapping.get(key)
+        if not config_key:
+            console.print(
+                f"[red]✗ Unknown config key:[/red] {key}\n"
+                f"Valid keys: {', '.join(key_mapping.keys())}"
+            )
+            raise click.Abort()
+
+        # Set value
+        setattr(cfg, config_key, value)
+        cfg.save()
+
+        console.print(f"[green]✓[/green] Set {key} = {value}")
+
+    except Exception as e:
+        console.print(f"[red]✗ Error:[/red] {str(e)}", style="red")
+        raise click.Abort()
+
+
+@config.command("get")
+@click.argument("key")
+def get_config(key):
+    """Get a configuration value."""
+    try:
+        cfg = Config.load()
+
+        key_mapping = {
+            "server": "server",
+            "api-key": "api_key",
+            "api_key": "api_key",
+            "email": "email",
+        }
+
+        config_key = key_mapping.get(key)
+        if not config_key:
+            console.print(f"[red]✗ Unknown config key:[/red] {key}")
+            raise click.Abort()
+
+        value = getattr(cfg, config_key, None)
+        if value:
+            console.print(value)
+        else:
+            console.print(f"[dim]{key} not set[/dim]")
+
+    except Exception as e:
+        console.print(f"[red]✗ Error:[/red] {str(e)}", style="red")
+        raise click.Abort()

notifer_cli/commands/keys.py

@@ -0,0 +1,187 @@
+"""API keys management commands."""
+import click
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich.prompt import Confirm
+
+from ..client import NotiferClient
+from ..config import Config
+
+console = Console()
+
+
+@click.group()
+def keys():
+    """Manage API keys for programmatic access."""
+    pass
+
+
+@keys.command("list")
+@click.option("--api-key", help="API key for authentication")
+@click.option("--server", help="Override server URL")
+def list_keys(api_key, server):
+    """List all API keys."""
+    try:
+        config = Config.load()
+        if server:
+            config.server = server
+        if api_key:
+            config.api_key = api_key
+
+        client = NotiferClient(config)
+        keys_data = client.list_api_keys()
+
+        if not keys_data:
+            console.print("[yellow]No API keys found[/yellow]")
+            return
+
+        # Create table
+        table = Table(title="API Keys", show_header=True, header_style="bold cyan")
+        table.add_column("Name", style="cyan")
+        table.add_column("Prefix", style="dim")
+        table.add_column("Scopes", style="green")
+        table.add_column("Requests", justify="right")
+        table.add_column("Status", justify="center")
+        table.add_column("Created")
+        table.add_column("Last Used")
+
+        for key in keys_data:
+            scopes_str = ", ".join(key["scopes"][:3])
+            if len(key["scopes"]) > 3:
+                scopes_str += f" +{len(key['scopes']) - 3} more"
+
+            status = "[green]✓ Active[/green]" if key["is_active"] else "[red]✗ Revoked[/red]"
+            last_used = key["last_used"] or "[dim]Never[/dim]"
+
+            table.add_row(
+                key["name"],
+                key["key_prefix"],
+                scopes_str,
+                str(key["request_count"]),
+                status,
+                key["created_at"][:10],
+                last_used[:10] if key["last_used"] else last_used,
+            )
+
+        console.print(table)
+
+    except Exception as e:
+        console.print(f"[red]✗ Error:[/red] {str(e)}", style="red")
+        raise click.Abort()
+
+
+@keys.command("create")
+@click.argument("name")
+@click.option("--description", "-d", help="Key description")
+@click.option("--scopes", "-s", default="*", help="Comma-separated scopes (default: *)")
+@click.option("--expires", help="Expiration date (ISO format)")
+@click.option("--api-key", help="API key for authentication")
+@click.option("--server", help="Override server URL")
+def create_key(name, description, scopes, expires, api_key, server):
+    """
+    Create a new API key.
+
+    \b
+    Examples:
+      notifer keys create "CI/CD Pipeline"
+      notifer keys create "Monitoring" --scopes publish,subscribe
+      notifer keys create "Read Only" --scopes topics:read,subscribe
+    """
+    try:
+        config = Config.load()
+        if server:
+            config.server = server
+        if api_key:
+            config.api_key = api_key
+
+        # Parse scopes
+        scope_list = [s.strip() for s in scopes.split(",")] if scopes != "*" else ["*"]
+
+        client = NotiferClient(config)
+        result = client.create_api_key(
+            name=name,
+            description=description,
+            scopes=scope_list,
+            expires_at=expires,
+        )
+
+        # Show the key (only shown once!)
+        console.print(
+            Panel(
+                f"[yellow]⚠ IMPORTANT: Save this key now - it won't be shown again![/yellow]\n\n"
+                f"[bold green]{result['key']}[/bold green]\n\n"
+                f"Name: {result['name']}\n"
+                f"Scopes: {', '.join(result['scopes'])}\n"
+                f"Created: {result['created_at'][:19]}",
+                title="API Key Created",
+                border_style="green",
+            )
+        )
+
+        # Offer to save to config
+        if Confirm.ask("\nSave this key to config file?", default=False):
+            config.api_key = result["key"]
+            config.save()
+            console.print("[green]✓[/green] Key saved to ~/.notifer.yaml")
+
+    except Exception as e:
+        console.print(f"[red]✗ Error:[/red] {str(e)}", style="red")
+        raise click.Abort()
+
+
+@keys.command("revoke")
+@click.argument("key_id")
+@click.option("--api-key", help="API key for authentication")
+@click.option("--server", help="Override server URL")
+def revoke_key(key_id, api_key, server):
+    """Revoke an API key (keeps for audit)."""
+    try:
+        config = Config.load()
+        if server:
+            config.server = server
+        if api_key:
+            config.api_key = api_key
+
+        if not Confirm.ask(f"Revoke API key {key_id}?", default=False):
+            console.print("Cancelled")
+            return
+
+        client = NotiferClient(config)
+        client.revoke_api_key(key_id)
+
+        console.print(f"[green]✓[/green] API key revoked: {key_id}")
+
+    except Exception as e:
+        console.print(f"[red]✗ Error:[/red] {str(e)}", style="red")
+        raise click.Abort()
+
+
+@keys.command("delete")
+@click.argument("key_id")
+@click.option("--api-key", help="API key for authentication")
+@click.option("--server", help="Override server URL")
+def delete_key(key_id, api_key, server):
+    """Permanently delete an API key."""
+    try:
+        config = Config.load()
+        if server:
+            config.server = server
+        if api_key:
+            config.api_key = api_key
+
+        if not Confirm.ask(
+            f"[red]Permanently delete[/red] API key {key_id}? This cannot be undone!",
+            default=False,
+        ):
+            console.print("Cancelled")
+            return
+
+        client = NotiferClient(config)
+        client.delete_api_key(key_id)
+
+        console.print(f"[green]✓[/green] API key deleted: {key_id}")
+
+    except Exception as e:
+        console.print(f"[red]✗ Error:[/red] {str(e)}", style="red")
+        raise click.Abort()