410 lines
12 KiB
Python
410 lines
12 KiB
Python
"""
|
|
bot.py - Discord bot client with session management and command routing
|
|
|
|
Features:
|
|
- Login flow with username/password
|
|
- Session management with JWT tokens
|
|
- AI-powered command parsing via registry
|
|
- Background task loop for polling
|
|
"""
|
|
|
|
import discord
|
|
from discord.ext import tasks
|
|
import os
|
|
import sys
|
|
import json
|
|
import base64
|
|
import requests
|
|
import bcrypt
|
|
import pickle
|
|
|
|
from bot.command_registry import get_handler, list_registered
|
|
import ai.parser as ai_parser
|
|
import bot.commands.routines # noqa: F401 - registers handler
|
|
import bot.commands.medications # noqa: F401 - registers handler
|
|
import bot.commands.knowledge # noqa: F401 - registers handler
|
|
|
|
DISCORD_BOT_TOKEN = os.getenv("DISCORD_BOT_TOKEN")
|
|
API_URL = os.getenv("API_URL", "http://app:5000")
|
|
|
|
user_sessions = {}
|
|
login_state = {}
|
|
message_history = {}
|
|
user_cache = {}
|
|
CACHE_FILE = "/app/user_cache.pkl"
|
|
|
|
intents = discord.Intents.default()
|
|
intents.message_content = True
|
|
|
|
client = discord.Client(intents=intents)
|
|
|
|
|
|
def decodeJwtPayload(token):
|
|
payload = token.split(".")[1]
|
|
payload += "=" * (4 - len(payload) % 4)
|
|
return json.loads(base64.urlsafe_b64decode(payload))
|
|
|
|
|
|
def apiRequest(method, endpoint, token=None, data=None):
|
|
url = f"{API_URL}{endpoint}"
|
|
headers = {"Content-Type": "application/json"}
|
|
if token:
|
|
headers["Authorization"] = f"Bearer {token}"
|
|
try:
|
|
resp = getattr(requests, method)(url, headers=headers, json=data, timeout=10)
|
|
try:
|
|
return resp.json(), resp.status_code
|
|
except ValueError:
|
|
return {}, resp.status_code
|
|
except requests.RequestException:
|
|
return {"error": "API unavailable"}, 503
|
|
|
|
|
|
def loadCache():
|
|
try:
|
|
if os.path.exists(CACHE_FILE):
|
|
with open(CACHE_FILE, "rb") as f:
|
|
global user_cache
|
|
user_cache = pickle.load(f)
|
|
print(f"Loaded cache for {len(user_cache)} users")
|
|
except Exception as e:
|
|
print(f"Error loading cache: {e}")
|
|
|
|
|
|
def saveCache():
|
|
try:
|
|
with open(CACHE_FILE, "wb") as f:
|
|
pickle.dump(user_cache, f)
|
|
except Exception as e:
|
|
print(f"Error saving cache: {e}")
|
|
|
|
|
|
def hashPassword(password):
|
|
return bcrypt.hashpw(password.encode("utf-8"), bcrypt.gensalt()).decode("utf-8")
|
|
|
|
|
|
def verifyPassword(password, hashed):
|
|
return bcrypt.checkpw(password.encode("utf-8"), hashed.encode("utf-8"))
|
|
|
|
|
|
def getCachedUser(discord_id):
|
|
return user_cache.get(discord_id)
|
|
|
|
|
|
def setCachedUser(discord_id, user_data):
|
|
user_cache[discord_id] = user_data
|
|
saveCache()
|
|
|
|
|
|
def negotiateToken(discord_id, username, password):
|
|
cached = getCachedUser(discord_id)
|
|
if (
|
|
cached
|
|
and cached.get("username") == username
|
|
and verifyPassword(password, cached.get("hashed_password"))
|
|
):
|
|
result, status = apiRequest(
|
|
"post", "/api/login", data={"username": username, "password": password}
|
|
)
|
|
if status == 200 and "token" in result:
|
|
token = result["token"]
|
|
payload = decodeJwtPayload(token)
|
|
user_uuid = payload["sub"]
|
|
setCachedUser(
|
|
discord_id,
|
|
{
|
|
"hashed_password": cached["hashed_password"],
|
|
"user_uuid": user_uuid,
|
|
"username": username,
|
|
},
|
|
)
|
|
return token, user_uuid
|
|
return None, None
|
|
|
|
result, status = apiRequest(
|
|
"post", "/api/login", data={"username": username, "password": password}
|
|
)
|
|
if status == 200 and "token" in result:
|
|
token = result["token"]
|
|
payload = decodeJwtPayload(token)
|
|
user_uuid = payload["sub"]
|
|
setCachedUser(
|
|
discord_id,
|
|
{
|
|
"hashed_password": hashPassword(password),
|
|
"user_uuid": user_uuid,
|
|
"username": username,
|
|
},
|
|
)
|
|
return token, user_uuid
|
|
return None, None
|
|
|
|
|
|
async def handleAuthFailure(message):
|
|
discord_id = message.author.id
|
|
user_sessions.pop(discord_id, None)
|
|
await message.channel.send(
|
|
"Your session has expired. Send any message to log in again."
|
|
)
|
|
|
|
|
|
async def handleLoginStep(message):
|
|
discord_id = message.author.id
|
|
state = login_state[discord_id]
|
|
|
|
if state["step"] == "username":
|
|
state["username"] = message.content.strip()
|
|
state["step"] = "password"
|
|
await message.channel.send("Password?")
|
|
|
|
elif state["step"] == "password":
|
|
username = state["username"]
|
|
password = message.content.strip()
|
|
del login_state[discord_id]
|
|
|
|
token, user_uuid = negotiateToken(discord_id, username, password)
|
|
|
|
if token and user_uuid:
|
|
user_sessions[discord_id] = {
|
|
"token": token,
|
|
"user_uuid": user_uuid,
|
|
"username": username,
|
|
}
|
|
registered = ", ".join(list_registered()) or "none"
|
|
await message.channel.send(
|
|
f"Welcome back **{username}**!\n\n"
|
|
f"Registered modules: {registered}\n\n"
|
|
f"Send 'help' for available commands."
|
|
)
|
|
else:
|
|
await message.channel.send(
|
|
"Invalid credentials. Send any message to try again."
|
|
)
|
|
|
|
|
|
async def sendHelpMessage(message):
|
|
help_msg = """**🤖 Synculous Bot - Natural Language Commands**
|
|
|
|
Just talk to me naturally! Here are some examples:
|
|
|
|
**💊 Medications:**
|
|
• "add lsd 50 mcg every tuesday at 4:20pm"
|
|
• "take my wellbutrin"
|
|
• "what meds do i have today?"
|
|
• "show my refills"
|
|
• "snooze my reminder for 30 minutes"
|
|
• "check adherence"
|
|
|
|
**📋 Routines:**
|
|
• "create morning routine with brush teeth, shower, eat"
|
|
• "start my morning routine"
|
|
• "done" (complete current step)
|
|
• "skip" (skip current step)
|
|
• "pause/resume" (pause or continue)
|
|
• "what steps are in my routine?"
|
|
• "schedule workout for monday wednesday friday at 7am"
|
|
• "show my stats"
|
|
|
|
**💡 Tips:**
|
|
• I understand natural language, typos, and slang
|
|
• If I'm unsure, I'll ask for clarification
|
|
• For important actions, I'll ask you to confirm with "yes" or "no"
|
|
• When you're in a routine, shortcuts like "done", "skip", "pause" work automatically"""
|
|
await message.channel.send(help_msg)
|
|
|
|
|
|
async def checkActiveSession(session):
|
|
"""Check if user has an active routine session and return details."""
|
|
token = session.get("token")
|
|
if not token:
|
|
return None
|
|
|
|
resp, status = apiRequest("get", "/api/sessions/active", token)
|
|
if status == 200 and "session" in resp:
|
|
return resp
|
|
return None
|
|
|
|
|
|
async def handleConfirmation(message, session):
|
|
"""Handle yes/no confirmation responses. Returns True if handled."""
|
|
discord_id = message.author.id
|
|
user_input = message.content.lower().strip()
|
|
|
|
if "pending_confirmations" not in session:
|
|
return False
|
|
|
|
# Check for any pending confirmations
|
|
pending = session["pending_confirmations"]
|
|
if not pending:
|
|
return False
|
|
|
|
# Get the most recent pending confirmation
|
|
confirmation_id = list(pending.keys())[-1]
|
|
confirmation_data = pending[confirmation_id]
|
|
|
|
if user_input in ("yes", "y", "yeah", "sure", "ok", "confirm"):
|
|
# Execute the confirmed action
|
|
del pending[confirmation_id]
|
|
|
|
interaction_type = confirmation_data.get("interaction_type")
|
|
handler = get_handler(interaction_type)
|
|
|
|
if handler:
|
|
# Create a fake parsed object for the handler
|
|
fake_parsed = confirmation_data.copy()
|
|
fake_parsed["needs_confirmation"] = False
|
|
await handler(message, session, fake_parsed)
|
|
return True
|
|
|
|
elif user_input in ("no", "n", "nah", "cancel", "abort"):
|
|
del pending[confirmation_id]
|
|
await message.channel.send("❌ Cancelled.")
|
|
return True
|
|
|
|
return False
|
|
|
|
|
|
async def handleActiveSessionShortcuts(message, session, active_session):
|
|
"""Handle shortcuts like 'done', 'skip', 'next' when in active session."""
|
|
user_input = message.content.lower().strip()
|
|
|
|
# Map common shortcuts to actions
|
|
shortcuts = {
|
|
"done": ("routine", "complete"),
|
|
"finished": ("routine", "complete"),
|
|
"complete": ("routine", "complete"),
|
|
"next": ("routine", "complete"),
|
|
"skip": ("routine", "skip"),
|
|
"pass": ("routine", "skip"),
|
|
"pause": ("routine", "pause"),
|
|
"hold": ("routine", "pause"),
|
|
"resume": ("routine", "resume"),
|
|
"continue": ("routine", "resume"),
|
|
"stop": ("routine", "cancel"),
|
|
"quit": ("routine", "cancel"),
|
|
"abort": ("routine", "abort"),
|
|
}
|
|
|
|
if user_input in shortcuts:
|
|
interaction_type, action = shortcuts[user_input]
|
|
handler = get_handler(interaction_type)
|
|
if handler:
|
|
fake_parsed = {"action": action}
|
|
await handler(message, session, fake_parsed)
|
|
return True
|
|
|
|
return False
|
|
|
|
|
|
async def routeCommand(message):
|
|
discord_id = message.author.id
|
|
session = user_sessions[discord_id]
|
|
user_input = message.content.lower()
|
|
|
|
if "help" in user_input or "what can i say" in user_input:
|
|
await sendHelpMessage(message)
|
|
return
|
|
|
|
# Check for active session first
|
|
active_session = await checkActiveSession(session)
|
|
|
|
# Handle confirmation responses
|
|
confirmation_handled = await handleConfirmation(message, session)
|
|
if confirmation_handled:
|
|
return
|
|
|
|
# Handle shortcuts when in active session
|
|
if active_session:
|
|
shortcut_handled = await handleActiveSessionShortcuts(
|
|
message, session, active_session
|
|
)
|
|
if shortcut_handled:
|
|
return
|
|
|
|
async with message.channel.typing():
|
|
history = message_history.get(discord_id, [])
|
|
|
|
# Add context about active session to help AI understand
|
|
context = ""
|
|
if active_session:
|
|
session_data = active_session.get("session", {})
|
|
routine_name = session_data.get("routine_name", "a routine")
|
|
current_step = session_data.get("current_step_index", 0) + 1
|
|
total_steps = active_session.get("total_steps", 0)
|
|
context = f"\n[Context: User is currently in active session for '{routine_name}', on step {current_step} of {total_steps}. They can say 'done', 'skip', 'pause', 'resume', or 'stop'.]"
|
|
|
|
parsed = await ai_parser.parse(
|
|
message.content + context, "command_parser", history=history
|
|
)
|
|
|
|
if discord_id not in message_history:
|
|
message_history[discord_id] = []
|
|
message_history[discord_id].append((message.content, parsed))
|
|
message_history[discord_id] = message_history[discord_id][-5:]
|
|
|
|
if "needs_clarification" in parsed:
|
|
await message.channel.send(
|
|
f"I'm not quite sure what you mean. {parsed['needs_clarification']}"
|
|
)
|
|
return
|
|
|
|
if "error" in parsed:
|
|
await message.channel.send(
|
|
f"I had trouble understanding that: {parsed['error']}"
|
|
)
|
|
return
|
|
|
|
interaction_type = parsed.get("interaction_type")
|
|
handler = get_handler(interaction_type)
|
|
|
|
if handler:
|
|
await handler(message, session, parsed)
|
|
else:
|
|
registered = ", ".join(list_registered()) or "none"
|
|
await message.channel.send(
|
|
f"Unknown command type '{interaction_type}'. Registered modules: {registered}"
|
|
)
|
|
|
|
|
|
@client.event
|
|
async def on_ready():
|
|
print(f"Bot logged in as {client.user}")
|
|
loadCache()
|
|
backgroundLoop.start()
|
|
|
|
|
|
@client.event
|
|
async def on_message(message):
|
|
if message.author == client.user:
|
|
return
|
|
if not isinstance(message.channel, discord.DMChannel):
|
|
return
|
|
|
|
discord_id = message.author.id
|
|
|
|
if discord_id in login_state:
|
|
await handleLoginStep(message)
|
|
return
|
|
|
|
if discord_id not in user_sessions:
|
|
login_state[discord_id] = {"step": "username"}
|
|
await message.channel.send("Welcome! Send your username to log in.")
|
|
return
|
|
|
|
await routeCommand(message)
|
|
|
|
|
|
@tasks.loop(seconds=60)
|
|
async def backgroundLoop():
|
|
"""Override this in your domain module or extend as needed."""
|
|
pass
|
|
|
|
|
|
@backgroundLoop.before_loop
|
|
async def beforeBackgroundLoop():
|
|
await client.wait_until_ready()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
client.run(DISCORD_BOT_TOKEN)
|