moss-agent-cli 0.1.0__tar.gz

moss_agent_cli-0.1.0/PKG-INFO

@@ -0,0 +1,164 @@
+Metadata-Version: 2.4
+Name: moss-agent-cli
+Version: 0.1.0
+Summary: CLI tool for deploying Moss voice agents
+Author-email: Moss Team <support@moss.dev>
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: typer>=0.9.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: python-dotenv>=1.0.0
+
+# Moss Agent CLI
+
+Command-line tool for deploying voice agents to the Moss platform.
+
+## Installation
+
+```bash
+pip install moss-agent-cli
+```
+
+Or install from source:
+
+```bash
+cd moss-agent-cli
+pip install -e .
+```
+
+## Usage
+
+### Deploy Command
+
+Deploy your agent to the Moss platform:
+
+```bash
+moss-agent deploy
+```
+
+### Required Environment Variables
+
+Set these environment variables or pass as CLI options:
+
+```bash
+export MOSS_PROJECT_ID="your-project-id"
+export MOSS_PROJECT_KEY="your-project-key"
+export MOSS_VOICE_AGENT_ID="your-voice-agent-id"
+```
+
+Or pass as options:
+
+```bash
+moss-agent deploy \
+  --project-id "your-project-id" \
+  --project-key "your-project-key" \
+  --voice-agent-id "your-voice-agent-id"
+```
+
+### Agent Structure
+
+Your agent directory must contain an entry point file that imports from `moss_voice_agent_manager`:
+
+**Simple structure:**
+```
+my-agent/
+├── agent.py              # Entry point (uses MossAgentSession)
+├── requirements.txt      # Optional: Additional dependencies
+└── tools/               # Optional: Custom tools
+    └── my_tools.py
+```
+
+**Or with main.py:**
+```
+my-agent/
+├── main.py              # Entry point
+├── requirements.txt
+└── ...
+```
+
+**Or with src structure:**
+```
+my-agent/
+├── src/
+│   └── my_agent/
+│       └── main.py      # Entry point
+├── requirements.txt
+└── ...
+```
+
+#### Example agent.py
+
+```python
+from moss_voice_agent_manager import MossAgentSession
+
+def get_weather(city: str) -> str:
+    """Get weather for a city."""
+    return f"Weather in {city} is sunny"
+
+session = MossAgentSession(
+    function_tools=[get_weather],
+    max_tool_steps=10,
+)
+
+if __name__ == "__main__":
+    session.run()
+```
+
+## CLI Options
+
+```
+moss-agent deploy [OPTIONS] [DIRECTORY]
+
+Arguments:
+  DIRECTORY                Agent directory to deploy (defaults to current directory)
+
+Options:
+  --project-id, -p TEXT    Moss project ID (or set MOSS_PROJECT_ID env var)
+  --project-key, -k TEXT   Moss project key (or set MOSS_PROJECT_KEY env var)
+  --voice-agent-id, -v TEXT Voice agent ID (or set MOSS_VOICE_AGENT_ID env var)
+  --api-url TEXT          Moss platform API URL (defaults to production)
+  --help                  Show this message and exit
+```
+
+## What Gets Deployed
+
+When you run `moss-agent deploy`, the CLI:
+
+1. **Validates** your agent structure
+2. **Packages** your agent directory (excluding .env, __pycache__, .git, etc.)
+3. **Uploads** the package to Moss platform
+4. **Deploys** to LiveKit Cloud
+
+Your agent code is deployed as-is - no modification or generation.
+
+## Excluded Files
+
+The following files/directories are automatically excluded from deployment:
+
+- `.env` - Environment variables (secrets)
+- `__pycache__/` - Python cache
+- `.git/` - Git repository
+- `*.pyc` - Compiled Python files
+- `.venv/`, `venv/` - Virtual environments
+- `.DS_Store` - macOS metadata
+
+## Development
+
+Install in development mode:
+
+```bash
+cd moss-agent-cli
+pip install -e .
+```
+
+Run the CLI:
+
+```bash
+moss-agent deploy
+```
+
+## License
+
+MIT

moss_agent_cli-0.1.0/README.md

@@ -0,0 +1,151 @@
+# Moss Agent CLI
+
+Command-line tool for deploying voice agents to the Moss platform.
+
+## Installation
+
+```bash
+pip install moss-agent-cli
+```
+
+Or install from source:
+
+```bash
+cd moss-agent-cli
+pip install -e .
+```
+
+## Usage
+
+### Deploy Command
+
+Deploy your agent to the Moss platform:
+
+```bash
+moss-agent deploy
+```
+
+### Required Environment Variables
+
+Set these environment variables or pass as CLI options:
+
+```bash
+export MOSS_PROJECT_ID="your-project-id"
+export MOSS_PROJECT_KEY="your-project-key"
+export MOSS_VOICE_AGENT_ID="your-voice-agent-id"
+```
+
+Or pass as options:
+
+```bash
+moss-agent deploy \
+  --project-id "your-project-id" \
+  --project-key "your-project-key" \
+  --voice-agent-id "your-voice-agent-id"
+```
+
+### Agent Structure
+
+Your agent directory must contain an entry point file that imports from `moss_voice_agent_manager`:
+
+**Simple structure:**
+```
+my-agent/
+├── agent.py              # Entry point (uses MossAgentSession)
+├── requirements.txt      # Optional: Additional dependencies
+└── tools/               # Optional: Custom tools
+    └── my_tools.py
+```
+
+**Or with main.py:**
+```
+my-agent/
+├── main.py              # Entry point
+├── requirements.txt
+└── ...
+```
+
+**Or with src structure:**
+```
+my-agent/
+├── src/
+│   └── my_agent/
+│       └── main.py      # Entry point
+├── requirements.txt
+└── ...
+```
+
+#### Example agent.py
+
+```python
+from moss_voice_agent_manager import MossAgentSession
+
+def get_weather(city: str) -> str:
+    """Get weather for a city."""
+    return f"Weather in {city} is sunny"
+
+session = MossAgentSession(
+    function_tools=[get_weather],
+    max_tool_steps=10,
+)
+
+if __name__ == "__main__":
+    session.run()
+```
+
+## CLI Options
+
+```
+moss-agent deploy [OPTIONS] [DIRECTORY]
+
+Arguments:
+  DIRECTORY                Agent directory to deploy (defaults to current directory)
+
+Options:
+  --project-id, -p TEXT    Moss project ID (or set MOSS_PROJECT_ID env var)
+  --project-key, -k TEXT   Moss project key (or set MOSS_PROJECT_KEY env var)
+  --voice-agent-id, -v TEXT Voice agent ID (or set MOSS_VOICE_AGENT_ID env var)
+  --api-url TEXT          Moss platform API URL (defaults to production)
+  --help                  Show this message and exit
+```
+
+## What Gets Deployed
+
+When you run `moss-agent deploy`, the CLI:
+
+1. **Validates** your agent structure
+2. **Packages** your agent directory (excluding .env, __pycache__, .git, etc.)
+3. **Uploads** the package to Moss platform
+4. **Deploys** to LiveKit Cloud
+
+Your agent code is deployed as-is - no modification or generation.
+
+## Excluded Files
+
+The following files/directories are automatically excluded from deployment:
+
+- `.env` - Environment variables (secrets)
+- `__pycache__/` - Python cache
+- `.git/` - Git repository
+- `*.pyc` - Compiled Python files
+- `.venv/`, `venv/` - Virtual environments
+- `.DS_Store` - macOS metadata
+
+## Development
+
+Install in development mode:
+
+```bash
+cd moss-agent-cli
+pip install -e .
+```
+
+Run the CLI:
+
+```bash
+moss-agent deploy
+```
+
+## License
+
+MIT

moss_agent_cli-0.1.0/moss_agent_cli/__init__.py

@@ -0,0 +1,3 @@
+"""Moss Agent CLI - Deploy voice agents to Moss platform."""
+
+__version__ = "0.1.0"

moss_agent_cli-0.1.0/moss_agent_cli/cli.py

@@ -0,0 +1,21 @@
+"""Main CLI entry point."""
+
+import typer
+from rich.console import Console
+
+from .commands.deploy import deploy_command
+
+app = typer.Typer(
+    name="moss-agent",
+    help="Moss Agent CLI - Deploy voice agents to Moss platform",
+    add_completion=False,
+)
+
+console = Console()
+
+# Register commands
+app.command(name="deploy")(deploy_command)
+
+
+if __name__ == "__main__":
+    app()

moss_agent_cli-0.1.0/moss_agent_cli/commands/__init__.py

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

moss_agent_cli-0.1.0/moss_agent_cli/commands/deploy.py

@@ -0,0 +1,108 @@
+"""Deploy command implementation."""
+
+import os
+from pathlib import Path
+from typing import Optional
+
+import typer
+from dotenv import load_dotenv
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+from ..core.deployer import deploy_agent_package
+
+console = Console()
+
+# Load .env file from current directory if it exists
+load_dotenv()
+
+
+def deploy_command(
+    directory: Optional[Path] = typer.Argument(
+        None,
+        help="Agent directory to deploy (defaults to current directory)",
+    ),
+    project_id: Optional[str] = typer.Option(
+        None,
+        "--project-id",
+        "-p",
+        help="Moss project ID (or set MOSS_PROJECT_ID env var)",
+    ),
+    project_key: Optional[str] = typer.Option(
+        None,
+        "--project-key",
+        "-k",
+        help="Moss project key (or set MOSS_PROJECT_KEY env var)",
+    ),
+    voice_agent_id: Optional[str] = typer.Option(
+        None,
+        "--voice-agent-id",
+        "-v",
+        help="Voice agent ID (or set MOSS_VOICE_AGENT_ID env var)",
+    ),
+    api_url: Optional[str] = typer.Option(
+        None,
+        "--api-url",
+        help="Moss platform API URL (defaults to production)",
+    ),
+) -> None:
+    """Deploy agent to Moss platform."""
+
+    # Resolve directory
+    agent_dir = directory or Path.cwd()
+    if not agent_dir.exists():
+        console.print(f"[red]Error:[/red] Directory not found: {agent_dir}")
+        raise typer.Exit(1)
+
+    # Load credentials from env or arguments
+    project_id = project_id or os.getenv("MOSS_PROJECT_ID")
+    project_key = project_key or os.getenv("MOSS_PROJECT_KEY")
+    voice_agent_id = voice_agent_id or os.getenv("MOSS_VOICE_AGENT_ID")
+    api_url = api_url or os.getenv("MOSS_PLATFORM_API_URL", "https://service.usemoss.dev")
+
+    # Validate credentials
+    if not project_id or not project_key or not voice_agent_id:
+        console.print("[red]Error:[/red] Missing required credentials")
+        console.print("\nProvide via options or environment variables:")
+        console.print("  --project-id / MOSS_PROJECT_ID")
+        console.print("  --project-key / MOSS_PROJECT_KEY")
+        console.print("  --voice-agent-id / MOSS_VOICE_AGENT_ID")
+        raise typer.Exit(1)
+
+    console.print(f"\n[bold]Deploying agent from:[/bold] {agent_dir}")
+    console.print(f"[dim]Project ID:[/dim] {project_id}")
+    console.print(f"[dim]Voice Agent ID:[/dim] {voice_agent_id}\n")
+
+    # Deploy with progress indicator
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console,
+    ) as progress:
+        task = progress.add_task("Deploying agent...", total=None)
+
+        try:
+            result = deploy_agent_package(
+                agent_dir=agent_dir,
+                project_id=project_id,
+                project_key=project_key,
+                voice_agent_id=voice_agent_id,
+                api_url=api_url,
+            )
+
+            progress.update(task, completed=True)
+
+            if result.get("ok"):
+                console.print("[green]✓[/green] Deployment successful!")
+                if result.get("deployment_url"):
+                    console.print(f"\n[bold]Deployment URL:[/bold] {result['deployment_url']}")
+            else:
+                console.print("[red]✗[/red] Deployment failed")
+                if result.get("error"):
+                    console.print(f"\n[red]Error:[/red] {result['error']}")
+                raise typer.Exit(1)
+
+        except Exception as exc:
+            progress.update(task, completed=True)
+            console.print(f"\n[red]Error:[/red] {exc}")
+            raise typer.Exit(1)

moss_agent_cli-0.1.0/moss_agent_cli/core/__init__.py

@@ -0,0 +1 @@
+"""Core CLI logic."""

moss_agent_cli-0.1.0/moss_agent_cli/core/deployer.py

@@ -0,0 +1,315 @@
+"""Agent deployment logic."""
+
+import tarfile
+import tempfile
+from pathlib import Path
+from typing import Dict, Any
+
+import httpx
+
+
+def validate_agent_structure(agent_dir: Path) -> None:
+    """
+    Validate that the agent directory has required files.
+
+    Args:
+        agent_dir: Path to agent directory
+
+    Raises:
+        ValueError: If validation fails
+    """
+    # Check for either agent.py or main.py (or src/*/main.py pattern)
+    agent_py = agent_dir / "agent.py"
+    main_py = agent_dir / "main.py"
+
+    # Also check for src/*/main.py pattern (like src/moss_voice_agent/main.py)
+    src_main_files = list(agent_dir.glob("src/*/main.py"))
+
+    entry_point = None
+    if agent_py.exists():
+        entry_point = agent_py
+    elif main_py.exists():
+        entry_point = main_py
+    elif src_main_files:
+        entry_point = src_main_files[0]
+
+    if not entry_point:
+        raise ValueError(
+            "Missing entry point file. Agent directory must contain one of:\n"
+            "  - agent.py (at root)\n"
+            "  - main.py (at root)\n"
+            "  - src/*/main.py (in src subdirectory)"
+        )
+
+    # Check that entry point uses moss_voice_agent_manager
+    entry_content = entry_point.read_text()
+    if "moss_voice_agent_manager" not in entry_content:
+        raise ValueError(
+            f"{entry_point.name} must import from moss_voice_agent_manager"
+        )
+
+
+def package_agent(agent_dir: Path) -> Path:
+    """
+    Package agent directory into a tarball.
+
+    Args:
+        agent_dir: Path to agent directory
+
+    Returns:
+        Path to created tarball
+
+    Raises:
+        ValueError: If packaging fails
+    """
+    # Create temporary tarball
+    temp_dir = Path(tempfile.gettempdir())
+    tarball_path = temp_dir / f"agent-{agent_dir.name}.tar.gz"
+
+    # Files to exclude
+    exclude_patterns = {
+        ".env",
+        "__pycache__",
+        ".git",
+        "*.pyc",
+        ".venv",
+        "venv",
+        ".DS_Store",
+    }
+
+    def should_exclude(file_path: Path) -> bool:
+        """Check if file should be excluded from package."""
+        name = file_path.name
+        # Check exact matches
+        if name in exclude_patterns:
+            return True
+        # Check pattern matches (*.pyc, etc.)
+        for pattern in exclude_patterns:
+            if "*" in pattern:
+                ext = pattern.replace("*", "")
+                if name.endswith(ext):
+                    return True
+        # Check if in excluded directory
+        for part in file_path.parts:
+            if part in exclude_patterns:
+                return True
+        return False
+
+    try:
+        with tarfile.open(tarball_path, "w:gz") as tar:
+            for item in agent_dir.rglob("*"):
+                if item.is_file() and not should_exclude(item):
+                    arcname = item.relative_to(agent_dir)
+                    tar.add(item, arcname=arcname)
+
+        return tarball_path
+
+    except Exception as exc:
+        raise ValueError(f"Failed to package agent: {exc}") from exc
+
+
+def upload_agent_package(
+    tarball_path: Path,
+    project_id: str,
+    project_key: str,
+    voice_agent_id: str,
+    api_url: str,
+    poll_status: bool = True,
+) -> Dict[str, Any]:
+    """
+    Upload agent package to Moss platform.
+
+    Args:
+        tarball_path: Path to agent tarball
+        project_id: Moss project ID
+        project_key: Moss project key
+        voice_agent_id: Voice agent ID
+        api_url: API base URL
+        poll_status: Whether to poll for deployment status
+
+    Returns:
+        Deployment response
+
+    Raises:
+        httpx.HTTPError: If upload fails
+    """
+    endpoint = f"{api_url}/api/voice-agent/upload"
+    print(f"DEBUG: Uploading to {endpoint}")
+
+    headers = {
+        "X-Project-Id": project_id,
+        "X-Project-Key": project_key,
+    }
+
+    with open(tarball_path, "rb") as f:
+        files = {
+            "agent_package": ("agent.tar.gz", f, "application/gzip")
+        }
+        data = {
+            "voice_agent_id": voice_agent_id,
+        }
+
+        with httpx.Client(timeout=30.0) as client:  # Quick upload timeout
+            response = client.post(
+                endpoint,
+                headers=headers,
+                files=files,
+                data=data,
+            )
+            response.raise_for_status()
+            result = response.json()
+
+            # If async deployment (202 status), poll for status
+            if response.status_code == 202 and poll_status:
+                deployment_id = result.get("deployment_id")
+                if deployment_id:
+                    print(f"DEBUG: Polling status for deployment {deployment_id}")
+                    final_status = poll_deployment_status(
+                        deployment_id=deployment_id,
+                        project_id=project_id,
+                        project_key=project_key,
+                        api_url=api_url,
+                    )
+                    return final_status
+
+            return result
+
+
+def poll_deployment_status(
+    deployment_id: str,
+    project_id: str,
+    project_key: str,
+    api_url: str,
+    max_wait: int = 600,  # 10 minutes max
+    poll_interval: int = 5,  # Check every 5 seconds
+) -> Dict[str, Any]:
+    """
+    Poll deployment status until completion.
+
+    Args:
+        deployment_id: Deployment ID to check
+        project_id: Moss project ID
+        project_key: Moss project key
+        api_url: API base URL
+        max_wait: Maximum seconds to wait
+        poll_interval: Seconds between polls
+
+    Returns:
+        Final deployment status
+    """
+    import time
+
+    endpoint = f"{api_url}/api/voice-agent/deployment-status/{deployment_id}"
+    headers = {
+        "X-Project-Id": project_id,
+        "X-Project-Key": project_key,
+    }
+
+    start_time = time.time()
+
+    with httpx.Client(timeout=10.0) as client:
+        while True:
+            elapsed = time.time() - start_time
+            if elapsed > max_wait:
+                return {
+                    "ok": False,
+                    "error": f"Deployment timed out after {max_wait} seconds",
+                    "status": "timeout",
+                }
+
+            try:
+                response = client.get(endpoint, headers=headers)
+                response.raise_for_status()
+                status_data = response.json()
+
+                status_value = status_data.get("status")
+                print(f"DEBUG: Status = {status_value}")
+
+                if status_value == "completed":
+                    return {
+                        "ok": True,
+                        "deployment_url": status_data.get("deployment_url"),
+                        "status": "completed",
+                    }
+                elif status_value == "failed":
+                    return {
+                        "ok": False,
+                        "error": status_data.get("error", "Deployment failed"),
+                        "status": "failed",
+                    }
+
+                # Still in progress, wait and retry
+                time.sleep(poll_interval)
+
+            except httpx.HTTPError as exc:
+                print(f"DEBUG: Polling error: {exc}")
+                time.sleep(poll_interval)
+
+
+def deploy_agent_package(
+    agent_dir: Path,
+    project_id: str,
+    project_key: str,
+    voice_agent_id: str,
+    api_url: str,
+) -> Dict[str, Any]:
+    """
+    Deploy agent package to Moss platform.
+
+    Args:
+        agent_dir: Path to agent directory
+        project_id: Moss project ID
+        project_key: Moss project key
+        voice_agent_id: Voice agent ID
+        api_url: API base URL
+
+    Returns:
+        Deployment response
+    """
+    print(f"DEBUG: Starting deployment with API URL: {api_url}")
+
+    # Validate agent structure
+    validate_agent_structure(agent_dir)
+    print("DEBUG: Validation passed")
+
+    # Package agent
+    tarball_path = package_agent(agent_dir)
+    print(f"DEBUG: Packaged to {tarball_path}")
+
+    try:
+        # Upload to platform
+        result = upload_agent_package(
+            tarball_path=tarball_path,
+            project_id=project_id,
+            project_key=project_key,
+            voice_agent_id=voice_agent_id,
+            api_url=api_url,
+        )
+        return result
+
+    except httpx.HTTPError as exc:
+        print(f"DEBUG: HTTP Error: {exc}")
+        print(f"DEBUG: Exception type: {type(exc)}")
+        error_msg = str(exc)
+        if hasattr(exc, "response") and exc.response is not None:
+            print(f"DEBUG: Response status: {exc.response.status_code}")
+            print(f"DEBUG: Response text: {exc.response.text[:500]}")
+            try:
+                error_detail = exc.response.json().get("detail", error_msg)
+                error_msg = error_detail
+            except Exception as e:
+                print(f"DEBUG: Could not parse JSON: {e}")
+                pass
+        return {"ok": False, "error": error_msg}
+
+    except Exception as exc:
+        print(f"DEBUG: Unexpected error: {exc}")
+        print(f"DEBUG: Exception type: {type(exc)}")
+        import traceback
+        traceback.print_exc()
+        return {"ok": False, "error": str(exc)}
+
+    finally:
+        # Clean up tarball
+        if tarball_path.exists():
+            tarball_path.unlink()

moss_agent_cli-0.1.0/moss_agent_cli.egg-info/PKG-INFO

@@ -0,0 +1,164 @@
+Metadata-Version: 2.4
+Name: moss-agent-cli
+Version: 0.1.0
+Summary: CLI tool for deploying Moss voice agents
+Author-email: Moss Team <support@moss.dev>
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: typer>=0.9.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: python-dotenv>=1.0.0
+
+# Moss Agent CLI
+
+Command-line tool for deploying voice agents to the Moss platform.
+
+## Installation
+
+```bash
+pip install moss-agent-cli
+```
+
+Or install from source:
+
+```bash
+cd moss-agent-cli
+pip install -e .
+```
+
+## Usage
+
+### Deploy Command
+
+Deploy your agent to the Moss platform:
+
+```bash
+moss-agent deploy
+```
+
+### Required Environment Variables
+
+Set these environment variables or pass as CLI options:
+
+```bash
+export MOSS_PROJECT_ID="your-project-id"
+export MOSS_PROJECT_KEY="your-project-key"
+export MOSS_VOICE_AGENT_ID="your-voice-agent-id"
+```
+
+Or pass as options:
+
+```bash
+moss-agent deploy \
+  --project-id "your-project-id" \
+  --project-key "your-project-key" \
+  --voice-agent-id "your-voice-agent-id"
+```
+
+### Agent Structure
+
+Your agent directory must contain an entry point file that imports from `moss_voice_agent_manager`:
+
+**Simple structure:**
+```
+my-agent/
+├── agent.py              # Entry point (uses MossAgentSession)
+├── requirements.txt      # Optional: Additional dependencies
+└── tools/               # Optional: Custom tools
+    └── my_tools.py
+```
+
+**Or with main.py:**
+```
+my-agent/
+├── main.py              # Entry point
+├── requirements.txt
+└── ...
+```
+
+**Or with src structure:**
+```
+my-agent/
+├── src/
+│   └── my_agent/
+│       └── main.py      # Entry point
+├── requirements.txt
+└── ...
+```
+
+#### Example agent.py
+
+```python
+from moss_voice_agent_manager import MossAgentSession
+
+def get_weather(city: str) -> str:
+    """Get weather for a city."""
+    return f"Weather in {city} is sunny"
+
+session = MossAgentSession(
+    function_tools=[get_weather],
+    max_tool_steps=10,
+)
+
+if __name__ == "__main__":
+    session.run()
+```
+
+## CLI Options
+
+```
+moss-agent deploy [OPTIONS] [DIRECTORY]
+
+Arguments:
+  DIRECTORY                Agent directory to deploy (defaults to current directory)
+
+Options:
+  --project-id, -p TEXT    Moss project ID (or set MOSS_PROJECT_ID env var)
+  --project-key, -k TEXT   Moss project key (or set MOSS_PROJECT_KEY env var)
+  --voice-agent-id, -v TEXT Voice agent ID (or set MOSS_VOICE_AGENT_ID env var)
+  --api-url TEXT          Moss platform API URL (defaults to production)
+  --help                  Show this message and exit
+```
+
+## What Gets Deployed
+
+When you run `moss-agent deploy`, the CLI:
+
+1. **Validates** your agent structure
+2. **Packages** your agent directory (excluding .env, __pycache__, .git, etc.)
+3. **Uploads** the package to Moss platform
+4. **Deploys** to LiveKit Cloud
+
+Your agent code is deployed as-is - no modification or generation.
+
+## Excluded Files
+
+The following files/directories are automatically excluded from deployment:
+
+- `.env` - Environment variables (secrets)
+- `__pycache__/` - Python cache
+- `.git/` - Git repository
+- `*.pyc` - Compiled Python files
+- `.venv/`, `venv/` - Virtual environments
+- `.DS_Store` - macOS metadata
+
+## Development
+
+Install in development mode:
+
+```bash
+cd moss-agent-cli
+pip install -e .
+```
+
+Run the CLI:
+
+```bash
+moss-agent deploy
+```
+
+## License
+
+MIT

moss_agent_cli-0.1.0/moss_agent_cli.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+moss_agent_cli/__init__.py
+moss_agent_cli/cli.py
+moss_agent_cli.egg-info/PKG-INFO
+moss_agent_cli.egg-info/SOURCES.txt
+moss_agent_cli.egg-info/dependency_links.txt
+moss_agent_cli.egg-info/entry_points.txt
+moss_agent_cli.egg-info/requires.txt
+moss_agent_cli.egg-info/top_level.txt
+moss_agent_cli/commands/__init__.py
+moss_agent_cli/commands/deploy.py
+moss_agent_cli/core/__init__.py
+moss_agent_cli/core/deployer.py

moss_agent_cli-0.1.0/moss_agent_cli.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

moss_agent_cli-0.1.0/moss_agent_cli.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+moss-agent = moss_agent_cli.cli:app

moss_agent_cli-0.1.0/moss_agent_cli.egg-info/requires.txt

@@ -0,0 +1,4 @@
+typer>=0.9.0
+rich>=13.0.0
+httpx>=0.27.0
+python-dotenv>=1.0.0

moss_agent_cli-0.1.0/moss_agent_cli.egg-info/top_level.txt

@@ -0,0 +1 @@
+moss_agent_cli

moss_agent_cli-0.1.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools>=45", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "moss-agent-cli"
+version = "0.1.0"
+description = "CLI tool for deploying Moss voice agents"
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "MIT"}
+authors = [
+    {name = "Moss Team", email = "support@moss.dev"}
+]
+dependencies = [
+    "typer>=0.9.0",
+    "rich>=13.0.0",
+    "httpx>=0.27.0",
+    "python-dotenv>=1.0.0",
+]
+
+[project.scripts]
+moss-agent = "moss_agent_cli.cli:app"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["moss_agent_cli*"]
+exclude = ["tests*"]

moss_agent_cli-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+