discord_bot.py

import json
import os
import aiohttp
import asyncio
from pathlib import Path

public_description = "Manage Discord token and handle message operations (fetch and send)"

# Constants
TOKEN_FILE = os.path.join(os.path.expanduser("~"), ".discord_token.json")
API_BASE = "https://discord.com/api/v10"

async def save_token(token):
 """Save Discord token to file"""
 try:
 data = {"token": token}
 with open(TOKEN_FILE, "w") as f:
 json.dump(data, f)
 return True
 except Exception as e:
 return False

async def get_token():
 """Retrieve token from file"""
 try:
 if os.path.exists(TOKEN_FILE):
 with open(TOKEN_FILE, "r") as f:
 data = json.load(f)
 return data.get("token")
 return None
 except Exception:
 return None

async def validate_token(token):
 """Validate Discord token by making a test API call"""
 headers = {"Authorization": f"Bot {token}" if token.startswith("Bot ") else token}
 
 try:
 async with aiohttp.ClientSession() as session:
 async with session.get(f"{API_BASE}/users/@me", headers=headers) as resp:
 if resp.status == 200:
 return True
 return False
 except Exception:
 return False

async def fetch_messages(token, channel_id, limit=50):
 """Fetch messages from a channel"""
 headers = {"Authorization": f"Bot {token}" if token.startswith("Bot ") else token}
 
 try:
 async with aiohttp.ClientSession() as session:
 async with session.get(f"{API_BASE}/channels/{channel_id}/messages?limit={limit}", headers=headers) as resp:
 if resp.status == 200:
 messages = await resp.json()
 # Format messages to simpler format with just name and content
 simplified_messages = [
 {
 "name": msg["author"].get("global_name", msg["author"]["username"]),
 "content": msg["content"],
 "timestamp": msg["timestamp"],
 "has_attachments": len(msg.get("attachments", [])) > 0
 }
 for msg in messages
 ]
 return simplified_messages
 return None
 except Exception as e:
 return None

async def send_message(token, channel_id, content):
 """Send a message to a channel"""
 headers = {
 "Authorization": f"Bot {token}" if token.startswith("Bot ") else token,
 "Content-Type": "application/json"
 }
 payload = {"content": content}
 
 try:
 async with aiohttp.ClientSession() as session:
 async with session.post(f"{API_BASE}/channels/{channel_id}/messages", 
 headers=headers, 
 json=payload) as resp:
 if resp.status in (200, 201):
 return await resp.json()
 return None
 except Exception as e:
 return None

async def function(args):
 try:
 action = args.get("action")
 token = args.get("token")
 channel_id = args.get("channel_id")
 content = args.get("content")
 message_limit = int(args.get("limit", 50))
 
 # Automatically save token if provided
 if token:
 await save_token(token)
 else:
 # Try to load from file
 token = await get_token()
 if not token:
 return json.dumps({
 "success": False,
 "error": "No token provided or saved"
 })
 
 # Validate token
 if action == "validate":
 is_valid = await validate_token(token)
 return json.dumps({
 "success": True,
 "valid": is_valid
 })
 
 # Fetch messages
 if action == "fetch":
 if not channel_id:
 return json.dumps({
 "success": False,
 "error": "Channel ID is required"
 })
 
 messages = await fetch_messages(token, channel_id, message_limit)
 if messages is None:
 return json.dumps({
 "success": False,
 "error": "Failed to fetch messages"
 })
 
 return json.dumps({
 "success": True,
 "message": messages
 })
 
 # Send message
 if action == "send":
 if not channel_id:
 return json.dumps({
 "success": False,
 "error": "Channel ID is required"
 })
 
 if not content:
 return json.dumps({
 "success": False,
 "error": "Message content is required"
 })
 
 result = await send_message(token, channel_id, content)
 if result is None:
 return json.dumps({
 "success": False,
 "error": "Failed to send message"
 })
 
 return json.dumps({
 "success": True,
 "message": "Message sent successfully",
 "data": result
 })
 
 return json.dumps({
 "success": False,
 "error": "Invalid action"
 })
 
 except Exception as e:
 return json.dumps({
 "success": False,
 "error": str(e)
 })

object = {
 "name": "discord_bot",
 "description": "Manage Discord token and handle message operations (fetch and send)",
 "parameters": {
 "type": "object",
 "properties": {
 "action": {
 "type": "string",
 "enum": ["validate", "fetch", "send"],
 "description": "Action to perform with Discord"
 },
 "token": {
 "type": "string",
 "description": "Discord token (optional if previously saved)"
 },
 "channel_id": {
 "type": "string",
 "description": "Discord channel ID for message operations"
 },
 "content": {
 "type": "string",
 "description": "Content for sending messages"
 },
 "limit": {
 "type": "integer",
 "description": "Maximum number of messages to fetch (default: 50)"
 }
 },
 "required": ["action"]
 }
}