Update app.py

app.py

@@ -1,11 +1,37 @@
 import os
 import json
 import httpx
-from fastapi import FastAPI, Request
+from fastapi import FastAPI, Request, Form, HTTPException, APIRouter
+from fastapi.middleware.cors import CORSMiddleware
+from typing import Optional
+from fastapi.responses import JSONResponse
 from openai import OpenAI
 
+# Create a router for our API endpoints
+router = APIRouter()
+
+# Create the FastAPI app
 app = FastAPI()
 
+# Add CORS middleware to allow requests from any origin
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Root endpoint for health checks
+@app.get("/")
+async def root():
+    return {"status": "ok", "message": "Server is running"}
+
+# Slack configuration
+SLACK_VERIFICATION_TOKEN = os.getenv("SLACK_VERIFICATION_TOKEN")
+# Add your Slack user ID (you can find this in your Slack profile)
+ALLOWED_SLACK_USER_ID = os.getenv("YOUR_SLACK_USER_ID")
+
 # Load KB
 with open("kb.json") as f:
     kb = json.load(f)
@@ -165,6 +191,172 @@ async def send_to_slack(message: str):
     except Exception as e:
         print("❌ Slack Send Error:", e)
 
+async def get_chatwoot_conversation(conversation_id: str):
+    """Fetch conversation details from Chatwoot"""
+    try:
+        async with httpx.AsyncClient() as http:
+            # Get conversation details
+            conv_url = f"{CHATWOOT_BASE_URL}/api/v1/accounts/{CHATWOOT_ACCOUNT_ID}/conversations/{conversation_id}"
+            conv_resp = await http.get(
+                conv_url,
+                headers={"api_access_token": CHATWOOT_API_KEY}
+            )
+            conv_resp.raise_for_status()
+            conversation = conv_resp.json()
+            
+            # Get conversation messages
+            msgs_url = f"{CHATWOOT_BASE_URL}/api/v1/accounts/{CHATWOOT_ACCOUNT_ID}/conversations/{conversation_id}/messages"
+            msgs_resp = await http.get(
+                msgs_url,
+                headers={"api_access_token": CHATWOOT_API_KEY}
+            )
+            msgs_resp.raise_for_status()
+            messages = msgs_resp.json()
+            
+            return {
+                "conversation": conversation,
+                "messages": messages
+            }
+    except Exception as e:
+        print(f"❌ Error fetching Chatwoot conversation: {e}")
+        return None
+
+def format_slack_message(conversation_data):
+    """Format conversation data into Slack blocks"""
+    if not conversation_data:
+        return {"text": "Error fetching conversation"}
+    
+    conv = conversation_data["conversation"]
+    messages = conversation_data["messages"]
+    
+    # Create blocks for the message
+    blocks = [
+        {
+            "type": "header",
+            "text": {
+                "type": "plain_text",
+                "text": f"💬 Conversation #{conv['id']}",
+                "emoji": True
+            }
+        },
+        {
+            "type": "section",
+            "fields": [
+                {
+                    "type": "mrkdwn",
+                    "text": f"*Status:* {conv['status']}"
+                },
+                {
+                    "type": "mrkdwn",
+                    "text": f"*Inbox:* {conv['inbox']['name']}"
+                },
+                {
+                    "type": "mrkdwn",
+                    "text": f"*Assignee:* {conv['meta']['assignee']['name'] if conv['meta']['assignee'] else 'Unassigned'}"
+                },
+                {
+                    "type": "mrkdwn",
+                    "text": f"*Created:* {conv['created_at']}"
+                }
+            ]
+        },
+        {
+            "type": "divider"
+        }
+    ]
+    
+    # Add messages
+    for msg in sorted(messages, key=lambda x: x['created_at']):
+        if msg["message_type"] in ["incoming", "outgoing"] and msg["content"].strip():
+            sender = "👤" if msg["message_type"] == "incoming" else "🤖"
+            blocks.append({
+                "type": "section",
+                "text": {
+                    "type": "mrkdwn",
+                    "text": f"{sender} *{msg['sender']['available_name']}*\n{msg['content']}"
+                }
+            })
+            blocks.append({"type": "divider"})
+    
+    return {
+        "response_type": "in_channel",
+        "blocks": blocks
+    }
+
+@router.post("/slack/command")
+async def slack_command(
+    token: str = Form(...),
+    command: str = Form(...),
+    text: str = Form(...),
+    response_url: str = Form(...),
+    user_id: str = Form(...)
+):
+    """Handle Slack slash command to fetch Chatwoot conversation"""
+    # Verify the Slack token and user
+    if token != SLACK_VERIFICATION_TOKEN:
+        raise HTTPException(status_code=401, detail="Invalid token")
+    
+    # Check if the user is authorized
+    if user_id != ALLOWED_SLACK_USER_ID:
+        return {
+            "response_type": "ephemeral",
+            "text": "⛔ This command is restricted to authorized users only."
+        }
+    
+    # Extract conversation ID from command text
+    conversation_id = text.strip()
+    if not conversation_id.isdigit():
+        return {
+            "response_type": "ephemeral",
+            "text": "❌ Please provide a valid conversation ID. Usage: `/conversation <conversation_id>`"
+        }
+    
+    # Send immediate response (Slack requires response within 3 seconds)
+    response = {
+        "response_type": "ephemeral",
+        "text": f"Fetching conversation {conversation_id}..."
+    }
+    
+    # Fetch conversation data in the background
+    import asyncio
+    asyncio.create_task(_process_slack_command(conversation_id, response_url))
+    
+    return response
+
+async def _process_slack_command(conversation_id: str, response_url: str):
+    """Process the Slack command asynchronously"""
+    try:
+        # Fetch conversation data
+        conversation_data = await get_chatwoot_conversation(conversation_id)
+        
+        if not conversation_data:
+            raise Exception("Failed to fetch conversation data")
+        
+        # Format the response
+        formatted_response = format_slack_message(conversation_data)
+        
+        # Send the formatted response to Slack
+        async with httpx.AsyncClient() as http:
+            await http.post(
+                response_url,
+                json=formatted_response,
+                headers={"Content-Type": "application/json"}
+            )
+    except Exception as e:
+        error_msg = {
+            "response_type": "ephemeral",
+            "text": f"❌ Error fetching conversation: {str(e)}"
+        }
+        async with httpx.AsyncClient() as http:
+            await http.post(
+                response_url,
+                json=error_msg,
+                headers={"Content-Type": "application/json"}
+            )
+
+# Include the router with the base path
+app.include_router(router, prefix="/api" if os.getenv('HF_SPACE') else "")
+
 async def send_chatwoot_message(conversation_id: str, content: str):
     message_payload = {
         "content": content,