videosdkagent-cli 0.0.1__py2.py3-none-any.whl

videosdk_cli/run_agent.py

@@ -0,0 +1,88 @@
+import subprocess
+import sys
+import json
+from pathlib import Path
+from rich.console import Console
+import os
+    
+console = Console()
+
+
+def get_executables(venv_path: Path):
+    """Determine python and pip executables based on venv/conda."""
+    is_windows = sys.platform == "win32"
+
+    venv_path = Path(venv_path)
+
+    if (venv_path / "Scripts").exists() or (venv_path / "bin").exists():
+        python_exe = venv_path / ("Scripts/python.exe" if is_windows else "bin/python")
+        pip_exe = venv_path / ("Scripts/pip.exe" if is_windows else "bin/pip")
+    else:
+        python_exe = venv_path / ("python.exe" if is_windows else "bin/python")
+        pip_exe = venv_path / ("Scripts/pip.exe" if is_windows else "bin/pip")
+
+    return python_exe, pip_exe
+
+
+def run_agent(project_name: str):
+    parent_dir = Path.cwd()
+    project_dir = parent_dir / project_name
+
+    if not project_dir.exists():
+        console.print(f"[bold red]Error:[/bold red] Project '{project_name}' not found.")
+        return
+
+    config_path = project_dir / "config.json"
+    if not config_path.exists():
+        console.print(f"[bold red]Error:[/bold red] config.json not found in project '{project_name}'.")
+        return
+
+    with open(config_path, "r") as f:
+        config = json.load(f)
+
+
+    venv_path_str = config.get("venv_path", str(project_dir / "venv"))
+    venv_path = Path(venv_path_str)
+    python_executable, pip_executable = get_executables(venv_path)
+
+
+    if not python_executable.exists():
+        console.print(f"[bold yellow]Virtual environment not found. Creating...[/bold yellow]")
+        subprocess.run([sys.executable, "-m", "venv", str(venv_path)], check=True)
+        console.print("[green]✅ Virtual environment created[/green]")
+        python_executable, pip_executable = get_executables(venv_path)
+
+
+    if not config.get("requirements_installed", False):
+        console.print("[cyan]Installing project requirements...[/cyan]")
+        subprocess.run([str(pip_executable), "install", "-r", str(project_dir / "requirements.txt")], check=True)
+        print("requirements", )
+        config["requirements_installed"] = True
+        with open(config_path, "w") as f:
+            json.dump(config, f, indent=4)
+        console.print("[green]✅ Requirements installed[/green]")
+
+
+    template_file = config.get("template_file")
+    template_path = project_dir / template_file
+
+    if not template_path.exists():
+        console.print(f"[bold red]Error:[/bold red] Template file '{template_file}' not found.")
+        return
+
+    console.print(f"[cyan]Running project '{project_name}'...[/cyan]")
+
+    env_vars = os.environ.copy()
+    env_file = project_dir / ".env"
+    if env_file.exists():
+        from dotenv import dotenv_values
+        env_vars.update(dotenv_values(env_file))
+    try:
+        subprocess.run(
+            [str(python_executable), str(template_path), "console"],
+            env=env_vars,
+            cwd=parent_dir,
+            check=True
+        )
+    except subprocess.CalledProcessError as e:
+        console.print(f"[bold red]Project exited with code {e.returncode}[/bold red]")

videosdk_cli/secret_set.py

@@ -0,0 +1,82 @@
+
+import click
+from rich.console import Console
+import asyncio
+from videosdk_cli.utils.manager.agent_manager import secret_set_manager,list_secret_manager,remove_secret_set,describe_secret_set,add_secret_set,remove_secret_set_key
+console = Console()
+
+@click.group(name="secret-set")
+def secret_set():
+    """Manage secrets"""
+    pass
+
+
+
+@secret_set.command(name="create")
+@click.option("--name",required=True,help='Secret name (lowercase, no spaces)')
+@click.option('--file','-f',required=False,help='Secret file path')
+def secret_set_create(name,file):
+    try:
+        console.print("[bold blue]Setting Secret...[/bold blue]")
+
+        asyncio.run(
+            secret_set_manager(name,file)
+        )
+    except click.Abort:
+        console.print("\nCancelled. No secrets were saved.")
+    except Exception as e:
+        console.print(f"[bold red]Error:[/bold red] {e}")
+
+@secret_set.command(name="list")
+def secret_set_list():
+    try:
+        console.print("[bold blue]Getting Secret...[/bold blue]")
+        asyncio.run(
+            list_secret_manager()
+        )
+        
+    except Exception as e:
+        console.print(f"[bold red]Error:[/bold red] {e}")   
+
+@secret_set.command(name="delete")
+@click.option("--name",required=True,help='Secret name (lowercase, no spaces)')
+def secret_set_delete(name):
+    try:
+        asyncio.run(
+            remove_secret_set(name)
+        )
+    except Exception as e:
+        console.print(f"[bold red]Error:[/bold red] {e}")
+
+@secret_set.command(name="describe")
+@click.option("--name",required=True,help='Secret name (lowercase, no spaces)')
+def secret_set_describe(name):
+    try:
+        asyncio.run(
+            describe_secret_set(name)
+        )
+    except Exception as e:
+        console.print(f"[bold red]Error:[/bold red] {e}")
+
+@secret_set.command(name="add")
+@click.option("--name",required=True,help='Secret name (lowercase, no spaces)')
+def secret_set_add(name):
+    try:
+        console.print("[bold blue]Setting Secret...[/bold blue]")
+
+        asyncio.run(
+            add_secret_set(name)
+        )
+        console.print(f"[bold green]Secret set successfully.[/bold green]")
+    except Exception as e:
+        console.print(f"[bold red]Error:[/bold red] {e}")
+
+@secret_set.command(name="remove")
+@click.option("--name",required=True,help='Secret name (lowercase, no spaces)')
+def secret_set_remove_key(name):
+    try:
+        asyncio.run(
+            remove_secret_set_key(name)
+        )
+    except Exception as e:
+        console.print(f"[bold red]Error:[/bold red] {e}")

videosdk_cli/templates.py

@@ -0,0 +1,168 @@
+import click
+import asyncio
+from pathlib import Path
+from rich.console import Console
+from rich.table import Table
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.prompt import Prompt
+
+from videosdk_cli.utils import template_options, template_helper, videosdk_yaml_helper
+from videosdk_cli.utils.videosdk_yaml_helper import AgentConfig
+
+console = Console()
+
+@click.group()
+def template_cli():
+    """Manage, download, and create projects from official VideoSDK templates."""
+    pass
+
+
+@template_cli.command(name="list")
+@click.option(
+    "--refresh", "-r",
+    is_flag=True,
+    help="Force refresh template metadata from server"
+)
+def list_templates(refresh: bool):
+    """List all available templates."""
+    asyncio.run(list_templates_async(refresh))
+
+
+async def list_templates_async(force_refresh: bool = False):
+    """Fetch and display templates from server/cache."""
+    await template_helper.fetch_template_cache(force_refresh=force_refresh)
+
+    kv = template_options.KeyValuePair()
+    templates = kv.templates
+
+    if not templates:
+        console.print("[yellow]No templates found in template metadata.[/yellow]")
+        return
+
+    table = Table(title="Available VideoSDK Templates", show_lines=True)
+    table.add_column("Template id", style="cyan", no_wrap=True)
+    table.add_column("File Name", style="green", no_wrap=True)
+    table.add_column("Description", style="white")
+    # table.add_column("Mode", style="magenta")
+    # table.add_column("Pipeline Type", style="blue")
+
+    for name, tpl in templates.items():
+        table.add_row(
+            name,
+            tpl.file_name,
+            tpl.description
+            # tpl.mode,
+            # tpl.pipe_type
+        )
+
+    console.print(table)
+@template_cli.command(name="get")
+@click.option(
+    "--template", "-t",
+    required=True,
+    help="Template name to create project from"
+)
+@click.argument("app_name")
+def create_project(template: str, app_name: str):
+    """Create a new project from a template."""
+    asyncio.run(create_project_async(template, app_name))
+
+
+async def create_project_async(template_id: str, app_name: str):
+    """Create project, fetch template code from server, prompt providers if needed."""
+    await template_helper.fetch_template_cache()
+
+    kv = template_options.KeyValuePair()
+    tpl = kv.get_template(template_id)
+
+    if not tpl:
+        console.print(f"[bold red]Error:[/bold red] Template '[cyan]{template_id}[/cyan]' not found in cache.")
+        return
+
+    app_dir = Path(app_name)
+    if app_dir.exists():
+        console.print(f"[bold red]Error:[/bold red] Directory '[cyan]{app_name}[/cyan]' already exists.")
+        return
+
+    console.print(f"[cyan]→ Mode:[/cyan] {tpl.mode}")
+    console.print(f"[cyan]→ Pipeline type:[/cyan] {tpl.pipe_type}")
+
+    providers_dict = {}
+    imports = []
+    provider_modules = []
+
+    if tpl.mode == "preconfig":
+        if tpl.pipe_type == "cascading":
+            STT, LLM, TTS = tpl.STT_options, tpl.LLM_options, tpl.TTS_options
+            providers_dict = {"STT": STT, "LLM": LLM, "TTS": TTS}
+        elif tpl.pipe_type == "realtime":
+            [RealtimeProvider] = tpl.provider_options
+            providers_dict = {"Realtime": RealtimeProvider}
+
+        for provider in providers_dict.values():
+            if isinstance(provider, list):
+                for p in provider:
+                    module, *_ = template_helper.PROVIDER_IMPORTS[p]
+                    provider_modules.append(module)
+            else:
+                module, *_ = template_helper.PROVIDER_IMPORTS[provider]
+                provider_modules.append(module)
+
+    elif tpl.mode == "custom" and tpl.pipe_type == "cascading":
+        STT = await template_helper.select_provider_arrow("Select STT provider:", tpl.STT_options)
+        LLM = await template_helper.select_provider_arrow("Select LLM provider:", tpl.LLM_options)
+        TTS = await template_helper.select_provider_arrow("Select TTS provider:", tpl.TTS_options)
+        providers_dict = {"STT": STT, "LLM": LLM, "TTS": TTS}
+        imports, provider_modules = template_helper.generate_cascading_providers(providers_dict)
+
+    api_keys = await template_helper.prompt_provider_api_keys(providers_dict)
+
+    env_path = await template_helper.prompt_existing_env()
+    if env_path and not env_path.exists():
+        console.print("[red]Provided environment path does not exist. A new venv will be created.[/red]")
+        env_path = None
+
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        transient=True,
+    ) as progress:
+        progress.add_task(description=f"Creating project [cyan]{app_name}[/cyan]...", total=None)
+        try:
+            app_dir.mkdir(parents=True, exist_ok=True)
+            template_helper.write_env_file(app_dir, providers_dict, api_keys)
+            template_helper.write_requirements(app_dir, template_helper.STATIC_REQUIREMENTS + provider_modules)
+            videosdk_yaml_helper.update_agent_config(app_dir, AgentConfig(templateId=template_id))
+        except Exception as e:
+            console.print(f"[bold red]Error creating project files: {e}[/bold red]")
+            return
+
+    try:
+        import aiohttp
+        async with aiohttp.ClientSession() as session:
+            url = f"{template_helper.CDN_BASE_URL}/{tpl.file_name}"
+            async with session.get(url) as resp:
+                if resp.status == 404:
+                    console.print(f"[bold red]Template '{template_id}' not found on server[/bold red]")
+                    return
+                resp.raise_for_status()
+                template_code = await resp.text()
+    except Exception as e:
+        console.print(f"[bold red]Error fetching template code: {e}[/bold red]")
+        return
+
+    imports_str = "\n".join(imports) if imports else ""
+    template_helper.write_template_file(app_dir, tpl.file_name, imports_str, template_code)
+
+    template_helper.write_config(
+        app_dir=app_dir,
+        template_id=template_id,
+        file_name=tpl.file_name,
+        description=tpl.description,
+        providers=providers_dict,
+        env_path=str(env_path) if env_path else None,
+        auto_configured=(tpl.mode=="preconfig"),
+        requirements_installed=False
+    )
+
+    console.print(f"[green]✅ Project '[bold cyan]{app_name}[/bold cyan]' created successfully![/green]")

videosdk_cli/utils/analytics.py

@@ -0,0 +1,61 @@
+import json
+from pathlib import Path
+from datetime import datetime
+import click
+from videosdk_cli.utils.config_manager import get_config_value
+
+CONFIG_DIR = Path(click.get_app_dir("videosdk_config"))
+CONFIG_DIR.mkdir(exist_ok=True)
+ANALYTICS_FILE = CONFIG_DIR / "analytics.json"
+
+_pending_analytics = []
+
+async def log_command(command: str):
+    """
+    Log a CLI command for analytics.
+    Send to server every 5 commands.
+    """
+    user_id = get_config_value("user_id") or "unknown"
+    username = get_config_value("username") or "unknown"
+    api_key = get_config_value("selected_project_api_key") or "unknown"
+
+    entry = {
+        "timestamp": datetime.now().isoformat(),
+        "user_id": user_id,
+        "username": username,
+        "api_key": api_key,
+        "command": command
+    }
+
+    if ANALYTICS_FILE.exists():
+        data = json.loads(ANALYTICS_FILE.read_text(encoding="utf-8"))
+    else:
+        data = {"count": 0, "entries": []}
+
+    data["entries"].append(entry)
+    data["count"] += 1
+
+    ANALYTICS_FILE.write_text(json.dumps(data, indent=4), encoding="utf-8")
+
+    if data["count"] >= 5:
+        await send_analytics_to_server(data)
+        ANALYTICS_FILE.write_text(json.dumps({"count": 0, "entries": []}, indent=4))
+
+
+async def send_analytics_to_server(data):
+    """
+    Send analytics to your server endpoint.
+    """
+    import aiohttp
+    from videosdk_cli.utils.template_helper import CDN_BASE_URL
+
+    url = f"{CDN_BASE_URL}/analytics/collect/"
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.post(url, json=data) as resp:
+                if resp.status == 200:
+                    print("[green]Analytics sent successfully[/green]")
+                else:
+                    print(f"[red]Failed to send analytics: {resp.status}[/red]")
+    except Exception as e:
+        print(f"[red]Error sending analytics: {e}[/red]")

videosdk_cli/utils/api_client.py

@@ -0,0 +1,107 @@
+import aiohttp
+import logging
+from videosdk_cli.utils.config_manager import load_config, save_config, set_config_value
+from InquirerPy import inquirer
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+
+
+
+class AuthenticationError(Exception):
+    """Raised when the stored authentication is invalid or expired."""
+    pass
+
+
+
+class VideoSDKClient:
+    def __init__(self, auth_token):
+        self.auth_token = auth_token
+        self.url = "https://api.videosdk.live/v1/apikeys"
+        self.headers = {
+            "Authorization": self.auth_token,
+            "Content-Type": "application/json"
+        }
+        self.res_data = None
+
+    
+    async def fetch_projects(self):
+        async with aiohttp.ClientSession() as session:
+            async with session.get(self.url, headers=self.headers) as resp:
+                text = await resp.text()
+                if 400 <= resp.status < 500:
+                    logger.warning("Session expired or invalid credentials.")
+                    reset = ask_reset_credentials()
+                    if reset:
+                        self._reset_credentials()
+                    raise AuthenticationError(
+                        f"Authentication failed ({resp.status}): {text}"
+                    )
+                resp.raise_for_status()
+                self.res_data = await resp.json()
+                return self.res_data
+
+    
+    def _reset_credentials(self):
+        """Clear stored auth_token."""
+        logger.info("Resetting stored credentials...")
+        try:
+            save_config(None)
+        
+        except Exception:
+            config = load_config()
+            config = None
+            save_config(config)
+
+
+
+class VideoSDKTokenClient:
+    def __init__(self, auth_token, api_key, expiresIn):
+        self.url = f"https://api.videosdk.live/v1/apikeys/{api_key}/token"
+        self.headers = {
+            "Authorization": auth_token,
+            "Content-Type": "application/json"
+        }
+        self.payload = {
+            "apiKey": api_key,
+            "permissions": ["allow_join"],
+            "expiresIn": expiresIn
+        }
+        self.res_data = None
+
+    
+    async def fetch_token(self):
+        async with aiohttp.ClientSession() as session:
+            async with session.post(self.url, headers=self.headers, json=self.payload) as resp:
+                text = await resp.text()
+                if 400 <= resp.status < 500:
+                    logger.warning("Session expired or invalid credentials.")
+                    reset = ask_reset_credentials()
+                    if reset:
+                        self._reset_credentials()
+                    raise AuthenticationError(f"Authentication failed ({resp.status}): {text}")
+                resp.raise_for_status()
+                self.res_data = await resp.json()
+                return self.res_data
+
+    
+    def _reset_credentials(self):
+        """Clear stored auth_token."""
+        logger.info("Resetting stored credentials...")
+        try:
+            save_config(None)
+        except Exception:
+            config = load_config()
+            config = None
+            save_config(config)
+
+
+
+def ask_reset_credentials():
+    """Prompt user before clearing saved auth token."""
+    result = inquirer.confirm(
+        message="Request failed. Do you want to reset your stored authentication token?",
+        default=False
+    ).execute()
+    return result
+    

videosdk_cli/utils/apis/deployment_client.py

@@ -0,0 +1,172 @@
+from videosdk_cli.utils.apis.videosdk_auth_api_client import VideoSDKAsyncClient
+from typing import Optional
+
+class DeploymentClient(VideoSDKAsyncClient):
+    def __init__(self):
+        super().__init__()
+    
+    async def agent_deployment(self, 
+        agent_id: str, 
+        image_url: str,
+        min_replica: int = 1,
+        max_replica: int = 5,
+        profile: str = "cpu-small",
+        image_type: str = "public",
+        image_cr: str = "docker_hub",
+        image_pull_secret: Optional[str] = None,
+        env_secret: Optional[str] = None
+    ):
+        payload = {
+            "agentId": agent_id,
+            "image": {
+                "imageType": image_type,
+                "imageCR": image_cr,
+                "imageUrl": image_url
+            },
+            "minReplica": min_replica,
+            "maxReplica": max_replica,
+            "profile": profile
+        }
+        if image_pull_secret is not None:
+            payload.setdefault("image", {})["imagePullSecret"]= image_pull_secret
+        if env_secret is not None:
+            payload["envSecret"] = env_secret
+        return await self._request("POST", "/ai/v1/cloud/deployments", json=payload)
+    
+    async def agent_deployment_update(self,
+        deployment_id: str,
+        agent_id: str, 
+        image_url: Optional[str] = None,
+        min_replica: Optional[int] = None,
+        max_replica: Optional[int] = None,
+        profile: Optional[str] = None,
+        image_type: Optional[str] = None,
+        image_cr: Optional[str] = None,
+        image_pull_secret: Optional[str] = None,
+        env_secret: Optional[str] = None
+    ):
+        # payload = {
+        #     "agentId": agent_id,
+        #     "image": {
+        #         "imageType": image_type,
+        #         "imageCR": image_cr,
+        #         "imageUrl": image_url
+        #     },
+        #     "minReplica": min_replica,
+        #     "maxReplica": max_replica,
+        #     "profile": profile
+        # }
+        payload = {
+            "agentId": agent_id
+        }
+
+        if min_replica is not None:
+            payload["minReplica"] = min_replica
+
+        if max_replica is not None:
+            payload["maxReplica"] = max_replica
+
+        if profile is not None:
+            payload["profile"] = profile
+        
+        
+        if env_secret is not None:
+            payload["envSecret"] = env_secret
+        
+        image = {}
+
+        if image_url is not None:
+            image["imageUrl"] = image_url
+
+        if image_type is not None:
+            image["imageType"] = image_type
+
+        if image_cr is not None:
+            image["imageCR"] = image_cr
+
+        if image_pull_secret is not None:
+            image["imagePullSecret"] = image_pull_secret
+
+        if image:
+            payload["image"] = image
+        return await self._request("PUT", f"/ai/v1/cloud/deployments/{agent_id}/{deployment_id}", json=payload)
+    
+    async def agent_deactivate(self, agent_id: str, deployment_id: str,force:bool = False):
+        return await self._request("PUT", f"/ai/v1/cloud/deployments/{agent_id}/{deployment_id}/activate",json={"activate": False,"force": force})
+    
+    async def agent_activate(self, agent_id: str, deployment_id: str):
+        return await self._request("PUT", f"/ai/v1/cloud/deployments/{agent_id}/{deployment_id}/activate",json={"activate": True})
+
+    async def agent_init(self, name: Optional[str] = None):
+        """
+        Initialize an agent.
+
+        If name is provided, it will be used.
+        Otherwise, the backend will generate one.
+        """
+
+        payload = {}
+
+        if name:
+            payload["name"] = name
+
+        return await self._request(
+            "POST",
+            "/ai/v1/cloud/agents",
+            json=payload if payload else None,
+        )
+    
+    async def agent_list(self,agent_id:str,head:Optional[int] = None,tail:Optional[int] = None):
+        if head is None and tail is None:
+            return await self._request("GET", f"/ai/v1/cloud/deployments/{agent_id}?perPage=5&sort=-1")
+        if head is None:
+            return await self._request("GET", f"/ai/v1/cloud/deployments/{agent_id}?perPage={tail}&sort=-1")
+        if tail is None:
+            return await self._request("GET", f"/ai/v1/cloud/deployments/{agent_id}?perPage={head}&sort=1")
+            
+        return await self._request("GET", f"/ai/v1/cloud/deployments/{agent_id}")
+
+    async def agent_describe(self,agent_id:str,deployment_id:Optional[str] = None):
+        if deployment_id is None:
+            return await self._request("GET", f"/ai/v1/cloud/deployments/{agent_id}/latest")
+        return await self._request("GET", f"/ai/v1/cloud/deployments/{agent_id}/{deployment_id}")
+
+    async def secret_set(self,name:str,secrets:dict,type:Optional[str] = "NORMAL"):
+        payload = {
+            "name": name,
+            "keys": secrets,
+            "type": type
+        }
+        return await self._request("POST", "/ai/v1/cloud/secrets", json=payload)
+
+    async def secret_list(self):
+        return await self._request("GET", "/ai/v1/cloud/secrets")
+    
+    async def secret_remove(self,name:str):
+        return await self._request("DELETE", f"/ai/v1/cloud/secrets/name/{name}")
+    
+    async def secret_get(self,name:str):
+        return await self._request("GET", f"/ai/v1/cloud/secrets/name/{name}")
+    
+    async def secret_add_key(self,name:str,secrets:dict):
+        print(secrets)
+        payload = secrets
+        return await self._request("PATCH", f"/ai/v1/cloud/secrets/keys/{name}", json=payload)
+
+    async def secret_remove_key(self,name:str,keys:list[str]):
+        payload = {
+            "keys": keys
+        }
+        return await self._request("DELETE", f"/ai/v1/cloud/secrets/keys/{name}", json=payload)
+    
+
+    async def agent_start(self,agent_id:str,deployment_id:str,meeting_id:Optional[str] = None):
+        if meeting_id is None:
+            response = await self._request("POST", f"/v2/rooms")
+            meeting_id = response.get("roomId")
+            print("Meeting ID: ", meeting_id)
+        return await self._request("POST", f"/v2/agent/dispatch", json={"agentId": agent_id,"versionId": deployment_id,"meetingId": meeting_id})
+    
+    async def agent_stop(self,meeting_id:str):
+        return await self._request("POST", f"/v2/sessions/end", json={"meetingId": meeting_id})
+        

videosdk_cli/utils/apis/error.py

@@ -0,0 +1,10 @@
+class VideoSDKError(Exception):
+    """Base VideoSDK exception"""
+
+
+class AuthenticationError(VideoSDKError):
+    """Raised when auth token is invalid or expired"""
+
+
+class APIRequestError(VideoSDKError):
+    """Raised for non-auth API failures"""