agentic-fabriq-sdk 0.1.13__py3-none-any.whl → 0.1.15__py3-none-any.whl

af_cli/commands/agents.py

@@ -14,10 +14,10 @@ app = typer.Typer(help="Agent management commands")
 
 @app.command()
 def list(
-    page: int = typer.Option(1, "--page", "-p", help="Page number"),
-    page_size: int = typer.Option(20, "--page-size", "-s", help="Page size"),
-    search: Optional[str] = typer.Option(None, "--search", "-q", help="Search query"),
-    format: str = typer.Option("table", "--format", "-f", help="Output format"),
+    page: int = typer.Option(1, "--page", help="Page number"),
+    page_size: int = typer.Option(20, "--page-size", help="Page size"),
+    search: Optional[str] = typer.Option(None, "--search", help="Search query"),
+    format: str = typer.Option("table", "--format", help="Output format"),
 ):
     """List agents."""
     try:
@@ -82,7 +82,7 @@ def list(
 @app.command()
 def get(
     agent_id: str = typer.Argument(..., help="Agent ID"),
-    format: str = typer.Option("table", "--format", "-f", help="Output format"),
+    format: str = typer.Option("table", "--format", help="Output format"),
 ):
     """Get agent details."""
     try:
@@ -102,12 +102,12 @@ def get(
 
 @app.command()
 def create(
-    name: str = typer.Option(..., "--name", "-n", help="Agent name"),
-    description: Optional[str] = typer.Option(None, "--description", "-d", help="Agent description"),
-    version: str = typer.Option("1.0.0", "--version", "-v", help="Agent version"),
+    name: str = typer.Option(..., "--name", help="Agent name"),
+    description: Optional[str] = typer.Option(None, "--description", help="Agent description"),
+    version: str = typer.Option("1.0.0", "--version", help="Agent version"),
     protocol: str = typer.Option("HTTP", "--protocol", help="Agent protocol"),
-    endpoint_url: str = typer.Option(..., "--endpoint-url", "-u", help="Agent endpoint URL"),
-    auth_method: str = typer.Option("OAUTH2", "--auth-method", "-a", help="Authentication method"),
+    endpoint_url: str = typer.Option(..., "--endpoint-url", help="Agent endpoint URL"),
+    auth_method: str = typer.Option("OAUTH2", "--auth-method", help="Authentication method"),
 ):
     """Create a new agent."""
     try:
@@ -135,12 +135,12 @@ def create(
 @app.command()
 def update(
     agent_id: str = typer.Argument(..., help="Agent ID"),
-    name: Optional[str] = typer.Option(None, "--name", "-n", help="Agent name"),
-    description: Optional[str] = typer.Option(None, "--description", "-d", help="Agent description"),
-    version: Optional[str] = typer.Option(None, "--version", "-v", help="Agent version"),
+    name: Optional[str] = typer.Option(None, "--name", help="Agent name"),
+    description: Optional[str] = typer.Option(None, "--description", help="Agent description"),
+    version: Optional[str] = typer.Option(None, "--version", help="Agent version"),
     protocol: Optional[str] = typer.Option(None, "--protocol", help="Agent protocol"),
-    endpoint_url: Optional[str] = typer.Option(None, "--endpoint-url", "-u", help="Agent endpoint URL"),
-    auth_method: Optional[str] = typer.Option(None, "--auth-method", "-a", help="Authentication method"),
+    endpoint_url: Optional[str] = typer.Option(None, "--endpoint-url", help="Agent endpoint URL"),
+    auth_method: Optional[str] = typer.Option(None, "--auth-method", help="Authentication method"),
 ):
     """Update an agent."""
     try:
@@ -178,7 +178,7 @@ def update(
 @app.command()
 def delete(
     agent_id: str = typer.Argument(..., help="Agent ID"),
-    force: bool = typer.Option(False, "--force", "-f", help="Force deletion without confirmation"),
+    force: bool = typer.Option(False, "--force", help="Force deletion without confirmation"),
 ):
     """Delete an agent."""
     try:
@@ -200,8 +200,8 @@ def delete(
 @app.command()
 def invoke(
     agent_id: str = typer.Argument(..., help="Agent ID"),
-    input_text: str = typer.Option(..., "--input", "-i", help="Input message for the agent"),
-    format: str = typer.Option("table", "--format", "-f", help="Output format"),
+    input_text: str = typer.Option(..., "--input", help="Input message for the agent"),
+    format: str = typer.Option("table", "--format", help="Output format"),
 ):
     """Invoke an agent."""
     try:

af_cli/commands/applications.py

@@ -0,0 +1,323 @@
+"""
+CLI commands for managing registered applications.
+"""
+
+import json
+from pathlib import Path
+from typing import Optional
+
+import httpx
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from af_cli.core.config import get_config
+from af_cli.core.output import print_output
+
+app = typer.Typer(help="Manage registered applications")
+console = Console()
+
+
+@app.command("create")
+def create_application(
+    app_id: str = typer.Option(..., "--app-id", help="Application identifier (no spaces)"),
+    connections: str = typer.Option(..., "--connections", help="Tool connections (format: 'tool1:conn-id,tool2:conn-id')"),
+    scopes: Optional[str] = typer.Option(None, "--scopes", help="Scopes (format: 'scope1,scope2,scope3')"),
+):
+    """
+    Register a new application.
+    
+    Example:
+        afctl applications create \\
+            --app-id my-slack-bot \\
+            --connections slack:my-slack-conn,github:my-github-conn \\
+            --scopes slack:read,slack:write,github:repo:read
+    """
+    config = get_config()
+    
+    if not config.is_authenticated():
+        console.print("❌ Not authenticated. Run 'afctl auth login' first.", style="red")
+        raise typer.Exit(1)
+    
+    # Parse connections
+    tool_connections = {}
+    if connections:
+        for conn_pair in connections.split(","):
+            try:
+                tool, conn_id = conn_pair.split(":")
+                tool_connections[conn_id] = []  # Will add scopes below
+            except ValueError:
+                console.print(f"❌ Invalid connection format: '{conn_pair}'. Use 'tool:conn-id'", style="red")
+                raise typer.Exit(1)
+    
+    # Parse scopes and assign to connections
+    if scopes:
+        scope_list = [s.strip() for s in scopes.split(",")]
+        # For simplicity, assign all scopes to all connections
+        # In production, you might want per-connection scopes
+        for conn_id in tool_connections:
+            tool_connections[conn_id] = scope_list
+    
+    # Make API request
+    try:
+        response = httpx.post(
+            f"{config.gateway_url}/api/v1/applications",
+            headers={"Authorization": f"Bearer {config.access_token}"},
+            json={
+                "app_id": app_id,
+                "tool_connections": tool_connections
+            },
+            timeout=30.0
+        )
+        
+        if response.status_code != 201:
+            error_detail = response.text
+            try:
+                error_json = response.json()
+                error_detail = error_json.get("detail", response.text)
+            except:
+                pass
+            
+            console.print(f"❌ Failed to register application: {error_detail}", style="red")
+            raise typer.Exit(1)
+        
+        data = response.json()
+        
+        # Save credentials locally
+        from af_sdk import save_application_config
+        
+        app_config = {
+            "app_id": data["app_id"],
+            "secret_key": data["secret_key"],
+            "user_id": data["user_id"],
+            "tenant_id": data["tenant_id"],
+            "tool_connections": data["tool_connections"],
+            "created_at": data["created_at"],
+            "gateway_url": config.gateway_url
+        }
+        
+        app_file = save_application_config(data["app_id"], app_config)
+        
+        # Display success
+        console.print("\n✅ Application registered successfully!", style="green bold")
+        console.print(f"\n📋 App ID: {data['app_id']}", style="cyan")
+        console.print(f"🔑 Secret Key: {data['secret_key']}", style="yellow")
+        console.print(f"\n💾 Credentials saved to: {app_file}", style="green")
+        console.print("\n⚠️  Save the secret key securely! It won't be shown again.", style="yellow bold")
+        console.print("\n🚀 Your agent can now authenticate with:", style="cyan")
+        console.print(f"   from af_sdk import get_application_client", style="white")
+        console.print(f"   client = await get_application_client('{data['app_id']}')", style="white")
+        
+    except httpx.HTTPError as e:
+        console.print(f"❌ Network error: {e}", style="red")
+        raise typer.Exit(1)
+
+
+@app.command("list")
+def list_applications(
+    format: str = typer.Option("table", "--format", help="Output format (table, json, yaml)"),
+):
+    """
+    List all registered applications.
+    
+    Shows applications from both:
+    - Local config files (~/.af/applications/)
+    - Server (via API)
+    """
+    config = get_config()
+    
+    # Load from local config first
+    from af_sdk import list_applications as list_local_apps
+    
+    local_apps = list_local_apps()
+    
+    if format == "table":
+        if not local_apps:
+            console.print("No applications registered locally.", style="yellow")
+            return
+        
+        table = Table(title="Registered Applications")
+        table.add_column("App ID", style="cyan")
+        table.add_column("Created", style="green")
+        table.add_column("Tool Connections", style="magenta")
+        table.add_column("Config File", style="white")
+        
+        for app in local_apps:
+            conn_count = len(app.get("tool_connections", {}))
+            conn_str = f"{conn_count} connection(s)"
+            config_file = f"~/.af/applications/{app['app_id']}.json"
+            
+            table.add_row(
+                app["app_id"],
+                app.get("created_at", "N/A")[:10],  # Just date
+                conn_str,
+                config_file
+            )
+        
+        console.print(table)
+        console.print(f"\n📊 Total: {len(local_apps)} application(s)")
+    else:
+        print_output(
+            {"applications": local_apps, "total": len(local_apps)},
+            format_type=format,
+            title="Registered Applications"
+        )
+
+
+@app.command("show")
+def show_application(
+    app_id: str = typer.Argument(..., help="Application identifier"),
+    reveal_secret: bool = typer.Option(False, "--reveal-secret", help="Reveal the secret key"),
+):
+    """
+    Show details of a registered application.
+    
+    Example:
+        afctl applications show my-slack-bot
+        afctl applications show my-slack-bot --reveal-secret
+    """
+    from af_sdk import load_application_config, ApplicationNotFoundError
+    
+    try:
+        app_config = load_application_config(app_id)
+    except ApplicationNotFoundError as e:
+        console.print(f"❌ {e}", style="red")
+        raise typer.Exit(1)
+    
+    console.print(f"\n📋 Application: {app_config['app_id']}", style="cyan bold")
+    console.print(f"👤 User ID: {app_config.get('user_id', 'N/A')}", style="white")
+    console.print(f"🏢 Tenant ID: {app_config.get('tenant_id', 'N/A')}", style="white")
+    console.print(f"📅 Created: {app_config.get('created_at', 'N/A')}", style="white")
+    console.print(f"🌐 Gateway: {app_config.get('gateway_url', 'N/A')}", style="white")
+    
+    if reveal_secret:
+        console.print(f"\n🔑 Secret Key: {app_config['secret_key']}", style="yellow bold")
+        console.print("⚠️  Keep this secret secure!", style="yellow")
+    else:
+        console.print(f"\n🔑 Secret Key: ••••••••", style="white")
+        console.print("   Use --reveal-secret to show", style="dim")
+    
+    console.print("\n🔌 Tool Connections:", style="cyan bold")
+    tool_conns = app_config.get("tool_connections", {})
+    if tool_conns:
+        for conn_id, scopes in tool_conns.items():
+            console.print(f"  • {conn_id}", style="white")
+            if scopes:
+                console.print(f"    Scopes: {', '.join(scopes)}", style="dim")
+    else:
+        console.print("  (none)", style="dim")
+    
+    config_file = Path.home() / ".af" / "applications" / f"{app_id}.json"
+    console.print(f"\n💾 Config file: {config_file}", style="green")
+
+
+@app.command("delete")
+def delete_application(
+    app_id: str = typer.Argument(..., help="Application identifier"),
+    yes: bool = typer.Option(False, "--yes", help="Skip confirmation"),
+):
+    """
+    Delete a registered application.
+    
+    This will:
+    - Delete the application registration on the server
+    - Remove local credentials
+    - Invalidate all active tokens
+    
+    Example:
+        afctl applications delete my-slack-bot
+        afctl applications delete my-slack-bot --yes
+    """
+    config = get_config()
+    
+    if not config.is_authenticated():
+        console.print("❌ Not authenticated. Run 'afctl auth login' first.", style="red")
+        raise typer.Exit(1)
+    
+    # Confirm deletion
+    if not yes:
+        console.print(f"\n⚠️  This will:", style="yellow bold")
+        console.print(f"  • Delete the application registration on the server", style="white")
+        console.print(f"  • Remove local credentials from ~/.af/applications/{app_id}.json", style="white")
+        console.print(f"  • Invalidate all active tokens for this application", style="white")
+        
+        confirm = typer.confirm(f"\nAre you sure you want to delete '{app_id}'?", default=False)
+        if not confirm:
+            console.print("❌ Cancelled", style="yellow")
+            raise typer.Exit(0)
+    
+    # Delete from server
+    try:
+        response = httpx.delete(
+            f"{config.gateway_url}/api/v1/applications/{app_id}",
+            headers={"Authorization": f"Bearer {config.access_token}"},
+            timeout=30.0
+        )
+        
+        if response.status_code == 404:
+            console.print(f"⚠️  Application '{app_id}' not found on server", style="yellow")
+        elif response.status_code != 204:
+            error_detail = response.text
+            try:
+                error_json = response.json()
+                error_detail = error_json.get("detail", response.text)
+            except:
+                pass
+            
+            console.print(f"❌ Failed to delete from server: {error_detail}", style="red")
+            raise typer.Exit(1)
+        else:
+            console.print(f"✅ Deleted from server", style="green")
+        
+    except httpx.HTTPError as e:
+        console.print(f"❌ Network error: {e}", style="red")
+        raise typer.Exit(1)
+    
+    # Delete local config
+    from af_sdk import delete_application_config
+    
+    deleted = delete_application_config(app_id)
+    if deleted:
+        console.print(f"✅ Deleted local credentials", style="green")
+    else:
+        console.print(f"⚠️  Local credentials not found", style="yellow")
+    
+    console.print(f"\n🎉 Application '{app_id}' deleted successfully", style="green bold")
+
+
+@app.command("test")
+def test_application(
+    app_id: str = typer.Argument(..., help="Application identifier"),
+):
+    """
+    Test application authentication.
+    
+    Attempts to exchange credentials for a token to verify the application
+    is properly registered and can authenticate.
+    
+    Example:
+        afctl applications test my-slack-bot
+    """
+    import asyncio
+    from af_sdk import get_application_client, ApplicationNotFoundError, AuthenticationError
+    
+    async def _test():
+        try:
+            console.print(f"🔄 Testing authentication for '{app_id}'...", style="cyan")
+            
+            client = await get_application_client(app_id)
+            
+            console.print(f"✅ Authentication successful!", style="green bold")
+            console.print(f"\n📋 Application: {client._app_id}", style="cyan")
+            console.print(f"⏱️  Token expires in: {client._expires_in} seconds", style="white")
+            console.print(f"\n🎉 Your application can authenticate and make API calls!", style="green")
+            
+        except ApplicationNotFoundError as e:
+            console.print(f"❌ {e}", style="red")
+            raise typer.Exit(1)
+        except AuthenticationError as e:
+            console.print(f"❌ {e}", style="red")
+            raise typer.Exit(1)
+    
+    asyncio.run(_test())
+

af_cli/commands/auth.py

@@ -51,18 +51,15 @@ def login(
     tenant_id: Optional[str] = typer.Option(
         None,
         "--tenant-id",
-        "-t",
         help="Tenant ID (optional, can be extracted from JWT)"
     ),
     browser: bool = typer.Option(
         True,
-        "--browser/--no-browser",
         help="Open browser for authentication"
     ),
     keycloak_url: Optional[str] = typer.Option(
         None,
         "--keycloak-url",
-        "-k",
         help="Keycloak URL (default: https://auth.agenticfabriq.com or from config)"
     ),
 ):
@@ -142,7 +139,6 @@ def logout(
     keycloak_url: Optional[str] = typer.Option(
         None,
         "--keycloak-url",
-        "-k",
         help="Keycloak URL (default: https://auth.agenticfabriq.com or from config)"
     ),
 ):
@@ -254,7 +250,6 @@ def refresh(
     keycloak_url: Optional[str] = typer.Option(
         None,
         "--keycloak-url",
-        "-k",
         help="Keycloak URL (default: https://auth.agenticfabriq.com or from config)"
     ),
 ):
@@ -320,7 +315,6 @@ def token(
     show_full: bool = typer.Option(
         False,
         "--full",
-        "-f",
         help="Show full token (warning: sensitive information)"
     ),
 ):

af_cli/commands/config.py

@@ -12,7 +12,7 @@ app = typer.Typer(help="Configuration commands")
 
 @app.command()
 def show(
-    format: str = typer.Option("table", "--format", "-f", help="Output format"),
+    format: str = typer.Option("table", "--format", help="Output format"),
 ):
     """Show current configuration."""
     import os

af_cli/commands/mcp_servers.py

@@ -12,7 +12,7 @@ app = typer.Typer(help="MCP server management commands")
 
 @app.command()
 def list(
-    format: str = typer.Option("table", "--format", "-f", help="Output format"),
+    format: str = typer.Option("table", "--format", help="Output format"),
 ):
     """List MCP servers."""
     try:
@@ -38,7 +38,7 @@ def list(
 @app.command()
 def get(
     server_id: str = typer.Argument(..., help="MCP server ID"),
-    format: str = typer.Option("table", "--format", "-f", help="Output format"),
+    format: str = typer.Option("table", "--format", help="Output format"),
 ):
     """Get MCP server details."""
     try:
@@ -58,9 +58,9 @@ def get(
 
 @app.command()
 def create(
-    name: str = typer.Option(..., "--name", "-n", help="MCP server name"),
-    base_url: str = typer.Option(..., "--base-url", "-u", help="Base URL"),
-    auth_type: str = typer.Option("API_KEY", "--auth-type", "-a", help="Authentication type"),
+    name: str = typer.Option(..., "--name", help="MCP server name"),
+    base_url: str = typer.Option(..., "--base-url", help="Base URL"),
+    auth_type: str = typer.Option("API_KEY", "--auth-type", help="Authentication type"),
 ):
     """Create a new MCP server."""
     try:

af_cli/commands/secrets.py

@@ -13,7 +13,7 @@ app = typer.Typer(help="Secret management commands")
 @app.command()
 def get(
     path: str = typer.Argument(..., help="Secret path"),
-    format: str = typer.Option("table", "--format", "-f", help="Output format"),
+    format: str = typer.Option("table", "--format", help="Output format"),
 ):
     """Get a secret."""
     try:
@@ -42,8 +42,8 @@ def get(
 @app.command()
 def create(
     path: str = typer.Argument(..., help="Secret path"),
-    value: str = typer.Option(..., "--value", "-v", help="Secret value"),
-    description: str = typer.Option("", "--description", "-d", help="Secret description"),
+    value: str = typer.Option(..., "--value", help="Secret value"),
+    description: str = typer.Option("", "--description", help="Secret description"),
 ):
     """Create a new secret."""
     try:
@@ -66,8 +66,8 @@ def create(
 @app.command()
 def update(
     path: str = typer.Argument(..., help="Secret path"),
-    value: str = typer.Option(..., "--value", "-v", help="Secret value"),
-    description: str = typer.Option("", "--description", "-d", help="Secret description"),
+    value: str = typer.Option(..., "--value", help="Secret value"),
+    description: str = typer.Option("", "--description", help="Secret description"),
 ):
     """Update a secret."""
     try:
@@ -90,7 +90,7 @@ def update(
 @app.command()
 def delete(
     path: str = typer.Argument(..., help="Secret path"),
-    force: bool = typer.Option(False, "--force", "-f", help="Force deletion"),
+    force: bool = typer.Option(False, "--force", help="Force deletion"),
 ):
     """Delete a secret."""
     try:

af_cli/commands/tools.py

@@ -13,7 +13,7 @@ app = typer.Typer(help="Tool management commands")
 
 @app.command()
 def list(
-    format: str = typer.Option("table", "--format", "-f", help="Output format"),
+    format: str = typer.Option("table", "--format", help="Output format"),
 ):
     """List your tool connections (configured and connected tools)."""
     try:
@@ -56,7 +56,7 @@ def list(
 @app.command()
 def get(
     connection_id: str = typer.Argument(..., help="Connection ID (e.g., 'google', 'slack')"),
-    format: str = typer.Option("table", "--format", "-f", help="Output format"),
+    format: str = typer.Option("table", "--format", help="Output format"),
 ):
     """Get tool connection details."""
     try:
@@ -121,24 +121,98 @@ def get(
 
 @app.command()
 def invoke(
-    tool_id: str = typer.Argument(..., help="Tool ID"),
-    method: str = typer.Option(..., "--method", "-m", help="Tool method to invoke"),
-    format: str = typer.Option("table", "--format", "-f", help="Output format"),
+    tool_identifier: str = typer.Argument(..., help="Tool name (e.g., 'slack') or UUID"),
+    method: str = typer.Option(..., "--method", help="Tool method to invoke"),
+    params: str = typer.Option(None, "--params", help="JSON string of method parameters (e.g., '{\"channel\": \"test\", \"text\": \"Hello\"}')"),
+    format: str = typer.Option("json", "--format", help="Output format (json, table, yaml)"),
 ):
-    """Invoke a tool."""
+    """Invoke a tool by name or UUID.
+    
+    Examples:
+        afctl tools invoke slack --method get_channels
+        afctl tools invoke slack --method post_message --params '{"channel": "test", "text": "Hello!"}'
+        afctl tools invoke c17b55af-18f8-49be-b9e9-44b1d1be429e --method get_channels
+    """
     try:
+        # Parse parameters if provided
+        parameters = {}
+        if params:
+            import json as json_lib
+            try:
+                parameters = json_lib.loads(params)
+            except json_lib.JSONDecodeError as e:
+                error(f"Invalid JSON in --params: {e}")
+                raise typer.Exit(1)
+        
         with get_client() as client:
+            # Try to resolve tool name to UUID if not already a UUID
+            tool_id = tool_identifier
+            try:
+                from uuid import UUID
+                UUID(tool_identifier)
+                # It's already a UUID, use it directly
+            except ValueError:
+                # Not a UUID, try to look up by name
+                info(f"Looking up tool '{tool_identifier}'...")
+                try:
+                    tools_response = client.get("/api/v1/tools")
+                    
+                    # Handle different response formats
+                    if isinstance(tools_response, dict) and "tools" in tools_response:
+                        tools = tools_response["tools"]
+                    elif isinstance(tools_response, dict) and "items" in tools_response:
+                        tools = tools_response["items"]
+                    elif hasattr(tools_response, '__iter__') and not isinstance(tools_response, (str, dict)):
+                        tools = list(tools_response)
+                    else:
+                        tools = []
+                    
+                    # Find tool by name (case-insensitive)
+                    matching_tools = [t for t in tools if isinstance(t, dict) and t.get("name", "").lower() == tool_identifier.lower()]
+                    
+                    if not matching_tools:
+                        error(f"Tool '{tool_identifier}' not found. Available tools:")
+                        for t in tools:
+                            if isinstance(t, dict):
+                                print(f"  - {t.get('name')} (ID: {t.get('id')})")
+                        raise typer.Exit(1)
+                    
+                    if len(matching_tools) > 1:
+                        error(f"Multiple tools found with name '{tool_identifier}':")
+                        for t in matching_tools:
+                            print(f"  - {t.get('name')} (ID: {t.get('id')})")
+                        error("Please use the UUID instead.")
+                        raise typer.Exit(1)
+                    
+                    tool_id = matching_tools[0].get("id")
+                    info(f"Resolved '{tool_identifier}' to tool ID: {tool_id}")
+                except Exception as lookup_error:
+                    error(f"Failed to look up tool: {lookup_error}")
+                    raise typer.Exit(1)
+            
             data = {
                 "method": method,
-                "parameters": {},
+                "parameters": parameters,
                 "context": {},
             }
             
-            info(f"Invoking tool {tool_id} method {method}...")
+            info(f"Invoking tool {tool_identifier} method {method}...")
             response = client.post(f"/api/v1/tools/{tool_id}/invoke", data)
             
             success("Tool invoked successfully")
-            print_output(response, format_type=format)
+            
+            # For tool invocations, show the result in a more readable format
+            if format == "json":
+                import json as json_lib
+                print(json_lib.dumps(response, indent=2))
+            elif format == "yaml":
+                import yaml
+                print(yaml.dump(response, default_flow_style=False))
+            else:
+                # For table format, show just the result field nicely
+                result = response.get("result", {})
+                print("\n📊 Result:")
+                print_output(result, format_type="json")
             
     except Exception as e:
         error(f"Failed to invoke tool: {e}")
@@ -413,7 +487,7 @@ def connect(
 @app.command()
 def disconnect(
     connection_id: str = typer.Argument(..., help="Connection ID to disconnect"),
-    force: bool = typer.Option(False, "--force", "-f", help="Skip confirmation"),
+    force: bool = typer.Option(False, "--force", help="Skip confirmation"),
 ):
     """Disconnect a tool (remove credentials but keep connection entry)."""
     try:
@@ -466,7 +540,7 @@ def disconnect(
 @app.command()
 def remove(
     connection_id: str = typer.Argument(..., help="Connection ID to remove"),
-    force: bool = typer.Option(False, "--force", "-f", help="Skip confirmation"),
+    force: bool = typer.Option(False, "--force", help="Skip confirmation"),
 ):
     """Remove a tool connection completely (delete entry and credentials)."""
     try: