debug1

app.py

@@ -17,6 +17,7 @@ from slack_bolt.oauth.async_oauth_settings import AsyncOAuthSettings
 from slack_sdk.oauth.installation_store.async_installation_store import AsyncInstallationStore
 from slack_sdk.oauth import AuthorizeUrlGenerator
 from slack_sdk.oauth.installation_store.models import Installation
+from slack_bolt.authorization import AsyncAuthorizeResult  # Added for custom authorize
 
 # RAG/ML Libraries
 from sentence_transformers import SentenceTransformer
@@ -51,6 +52,10 @@ if not all(required_vars):
     missing = [var for var in required_vars if not var]
     raise ValueError(f"Missing required environment variables: {', '.join(missing)}")
 
+# For single-team mode, require SLACK_BOT_TOKEN
+if not SLACK_BOT_TOKEN:
+    raise ValueError("SLACK_BOT_TOKEN is required for single-team mode.")
+
 # Set HF_TOKEN if provided (helps with authentication for Hub access)
 if HF_TOKEN:
     try:
@@ -62,7 +67,7 @@ if HF_TOKEN:
 # Initialize Supabase client
 supabase: Client = create_client(SUPABASE_URL, SUPABASE_KEY)
 
-# --- Supabase Async Installation Store ---
+# --- Supabase Async Installation Store (for multi-team; optional) ---
 class SupabaseAsyncInstallationStore(AsyncInstallationStore):
     def __init__(self, supabase_client):
         self.supabase = supabase_client
@@ -85,14 +90,14 @@ class SupabaseAsyncInstallationStore(AsyncInstallationStore):
             raise
 
     async def fetch_installation(self, team_id: str, *, enterprise_id: str | None = None, user_id: str | None = None) -> Installation | None:
-        logger.info(f"Fetching installation for team_id: {team_id}, enterprise_id: {enterprise_id}, user_id: {user_id}")  # DEBUG LOG
+        logger.info(f"Fetching installation for team_id: {team_id}, enterprise_id: {enterprise_id}, user_id: {user_id}")
         try:
             result = await asyncio.to_thread(
                 lambda: self.supabase.table("installations").select("*").eq("team_id", team_id).execute()
             )
-            logger.info(f"Fetch result for {team_id}: {len(result.data)} rows")  # DEBUG LOG
+            logger.info(f"Fetch result for {team_id}: {len(result.data)} rows")
             if not result.data:
-                logger.warning(f"No installation found for team {team_id}")  # Instead of error here
+                logger.warning(f"No installation found for team {team_id}")
                 return None
             
             data = result.data[0]
@@ -120,20 +125,44 @@ class SupabaseAsyncInstallationStore(AsyncInstallationStore):
             logger.error(f"Failed to delete installation for team {team_id}: {e}")
             raise
 
-# Initialize installation store
-installation_store = SupabaseAsyncInstallationStore(supabase)
+# Initialize installation store (only if multi-team)
+installation_store = None
+USE_MULTI_TEAM = os.environ.get("USE_MULTI_TEAM", "false").lower() == "true"  # Set env to 'true' for multi-team
+if USE_MULTI_TEAM:
+    installation_store = SupabaseAsyncInstallationStore(supabase)
+    logger.info("Using multi-team mode with Supabase store.")
+else:
+    logger.info("Using single-team mode with SLACK_BOT_TOKEN.")
+
+# Custom authorize for multi-team (falls back to store)
+async def async_authorize(enterprise_id, team_id, user_id):
+    logger.info(f"Custom authorize called for enterprise: {enterprise_id}, team: {team_id}, user: {user_id}")
+    if not USE_MULTI_TEAM:
+        return None  # Single-team doesn't need this
+    installation = await installation_store.fetch_installation(team_id=team_id, enterprise_id=enterprise_id)
+    if installation:
+        return AsyncAuthorizeResult(
+            enterprise_id=enterprise_id or installation.enterprise_id,
+            team_id=team_id,
+            user_id=user_id or installation.user_id,
+            bot_token=installation.bot_token,
+            bot_user_id=installation.bot_user_id,
+        )
+    logger.error(f"No authorization found for team {team_id}")
+    return None
 
 # Initialize Bolt Async App
 app = AsyncApp(
     signing_secret=SLACK_SIGNING_SECRET,
+    token=SLACK_BOT_TOKEN if not USE_MULTI_TEAM else None,  # Single-team: use token
     installation_store=installation_store,
+    authorize=async_authorize if USE_MULTI_TEAM else None,  # Multi-team: custom authorize
     oauth_settings=AsyncOAuthSettings(
         client_id=SLACK_CLIENT_ID,
         client_secret=SLACK_CLIENT_SECRET,
         scopes=["app_mentions:read", "files:read", "chat:write", "im:read", "im:write", "channels:read"],
         redirect_uri_path="/slack/oauth/callback",
     ),
-    # Removed token for multi-workspace support; add back if single-workspace only
 )
 
 api = FastAPI()
@@ -364,6 +393,7 @@ handler = AsyncSlackRequestHandler(app)
 async def slack_events(request: Request):
     """Endpoint for all Slack event subscriptions."""
     try:
+        logger.info("Received Slack event request")
         return await handler.handle(request)
     except Exception as e:
         logger.error(f"Error handling Slack events: {e}")
@@ -397,9 +427,8 @@ async def install_url():
             client_id=SLACK_CLIENT_ID,
             scopes=["app_mentions:read", "files:read", "chat:write", "im:read", "im:write", "channels:read"]
         )
-        # NOTE: The redirect_uri should match your Slack App config (e.g., https://yourspace.hf.space/slack/oauth/callback)
-        # If needed, add: redirect_uri=os.environ.get("SLACK_REDIRECT_URI")
         url = generator.generate(state="state")
+        logger.info(f"Generated install URL: {url}")
         return {"install_url": url}
     except Exception as e:
         logger.error(f"Error generating install URL: {e}")
@@ -409,19 +438,22 @@ async def install_url():
 async def oauth_callback(request: Request):
     """Handles the OAuth callback from Slack to complete installation."""
     try:
+        logger.info("OAuth callback received")
         response = await handler.handle(request)
-        logger.info(f"OAuth callback response: {response.status_code if hasattr(response, 'status_code') else 'No status'}")  # DEBUG
-        # For successful OAuth, return a simple HTML response
+        logger.info(f"OAuth callback response: {response.status_code if hasattr(response, 'status_code') else 'No status'}")
         if hasattr(response, 'status_code') and response.status_code == 200:
+            # In single-team, no need to save; for multi, it should auto-save via store
+            if USE_MULTI_TEAM:
+                logger.info("Multi-team install: Check Supabase for new data.")
             return HTMLResponse(
-                content="<html><body><h1>Installation successful!</h1><p>You can now use the bot in your Slack workspace.</p><p>Check Supabase for new installation data.</p></body></html>",
+                content=f"<html><body><h1>Installation successful!</h1><p>You can now use the bot in your Slack workspace.</p><p>Mode: {'Single-team (no store needed)' if not USE_MULTI_TEAM else 'Multi-team (check Supabase)'}</p><p><a href='/debug/installations'>Debug Installations</a></p></body></html>",
                 status_code=200
             )
         return response
     except Exception as e:
         logger.error(f"OAuth Callback Error: {e}")
         return HTMLResponse(
-            content=f"<html><body><h1>Installation Failed!</h1><p>Error: {str(e)}</p><p>Check logs and Supabase.</p></body></html>",
+            content=f"<html><body><h1>Installation Failed!</h1><p>Error: {str(e)}</p><p>Check logs. If multi-team, ensure Supabase table exists.</p></body></html>",
             status_code=500
         )
 
@@ -433,7 +465,7 @@ async def debug_installations():
         result = await asyncio.to_thread(
             lambda: supabase.table("installations").select("*").execute()
         )
-        return {"installations": result.data}
+        return {"installations": result.data, "mode": "multi-team" if USE_MULTI_TEAM else "single-team"}
     except Exception as e:
         return {"error": str(e)}