import { OpenAI } from "https://esm.town/v/std/openai"; import { sqlite } from "https://esm.town/v/stevekrouse/sqlite"; import { blob } from "https://esm.town/v/std/blob"; const KEY = new URL(import.meta.url).pathname.split("/").at(-1); const SCHEMA_VERSION = 11; const API_VERSION = "v10"; const BASE_URL = `https://discord.com/api/v${API_VERSION}`; const CLIENT_ID = "1334805187482882068"; const CLIENT_SECRET = Deno.env.get("DISCORD_CLIENT_SECRET"); const REDIRECT_URI = `https://${KEY}.web.val.run/callback`; const CHANNEL_ID = "1319682697878175795"; // ValTown beta testers channel ID interface Thread { id: string; name: string; message_count: number; created_timestamp: string; last_message_id: string | null; archived: boolean; } interface Message { id: string; content: string; author: { username: string; }; timestamp: string; } interface ThreadSummary { thread_id: string; name: string; message_count: number; created_timestamp: string; last_message_timestamp: string | null; archived: boolean; summary: string | null; last_summarized_timestamp: string | null; } interface UserToken { access_token: string; token_type: string; expires_in: number; refresh_token: string; scope: string; } async function initDatabase() { await sqlite.execute(` CREATE TABLE IF NOT EXISTS ${KEY}_thread_activity_${SCHEMA_VERSION} ( user_id TEXT, thread_id TEXT, name TEXT NOT NULL, message_count INTEGER NOT NULL, created_timestamp TEXT NOT NULL, last_message_timestamp TEXT, archived BOOLEAN NOT NULL, PRIMARY KEY (user_id, thread_id) ) `); await sqlite.execute(` CREATE TABLE IF NOT EXISTS ${KEY}_thread_summaries_${SCHEMA_VERSION} ( user_id TEXT, thread_id TEXT, summary TEXT NOT NULL, last_summarized_timestamp TEXT NOT NULL, PRIMARY KEY (user_id, thread_id) ) `); } async function fetchWithRetry(url: string, options: RequestInit, retries = 3): Promise { let lastResponse: Response | null = null; for (let i = 0; i < retries; i++) { try { const response = await fetch(url, options); lastResponse = response; if (response.status === 429) { const retryAfter = parseInt(response.headers.get("Retry-After") || "1", 10); await new Promise(resolve => setTimeout(resolve, retryAfter * 1000)); continue; } if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`); return await response.json(); } catch (error) { if (i === retries - 1) throw error; await new Promise(resolve => setTimeout(resolve, 1000 * Math.pow(2, i))); } } throw new Error(`Max retries reached. Last response: ${lastResponse?.status}`); } async function fetchThreads(userId: string): Promise { const userToken = await getUserToken(userId); if (!userToken) throw new Error("User not authenticated"); const headers = { Authorization: `Bearer ${userToken.access_token}`, "User-Agent": "DiscordBot (https://val.town, 1.0.0)", }; const activeThreads = await fetchWithRetry( `${BASE_URL}/channels/${CHANNEL_ID}/threads/active`, { headers }, ); const archivedThreads = await fetchWithRetry( `${BASE_URL}/channels/${CHANNEL_ID}/threads/archived/public`, { headers }, ); return [ ...activeThreads.threads.map((thread: Thread) => ({ ...thread, archived: false })), ...archivedThreads.threads.map((thread: Thread) => ({ ...thread, archived: true })), ]; } async function fetchAllMessages(userId: string, threadId: string): Promise { const userToken = await getUserToken(userId); if (!userToken) throw new Error("User not authenticated"); const headers = { Authorization: `Bearer ${userToken.access_token}`, "User-Agent": "DiscordBot (https://val.town, 1.0.0)", }; let allMessages: Message[] = []; let lastId: string | undefined; while (true) { const url = new URL(`${BASE_URL}/channels/${threadId}/messages`); url.searchParams.set("limit", "100"); if (lastId) url.searchParams.set("before", lastId); const messages: Message[] = await fetchWithRetry(url.toString(), { headers }); if (messages.length === 0) break; allMessages = [...allMessages, ...messages]; lastId = messages[messages.length - 1].id; if (messages.length < 100) break; } return allMessages.reverse(); } async function summarizeMessages(messages: Message[]): Promise { const openai = new OpenAI(); const messageContent = messages.map(m => `${m.author.username}: ${m.content}`).join("\n"); const completion = await openai.chat.completions.create({ messages: [ { role: "system", content: "You are a helpful assistant that summarizes Discord conversations. Provide a concise summary that captures the main points and any decisions or action items.", }, { role: "user", content: `Please summarize the following Discord conversation:\n\n${messageContent}` }, ], model: "gpt-4o-mini", max_tokens: 250, }); return completion.choices[0].message.content.trim(); } async function updateThreadActivity(userId: string) { await initDatabase(); const threads = await fetchThreads(userId); for (const thread of threads) { await sqlite.execute( ` INSERT OR REPLACE INTO ${KEY}_thread_activity_${SCHEMA_VERSION} (user_id, thread_id, name, message_count, created_timestamp, last_message_timestamp, archived) VALUES (?, ?, ?, ?, ?, ?, ?) `, [ userId, thread.id, thread.name, thread.message_count, new Date(thread.created_timestamp).toISOString(), thread.last_message_id ? new Date(parseInt(thread.last_message_id) / 4194304 + 1420070400000).toISOString() : null, thread.archived ? 1 : 0, ], ); } } async function summarizeThread(userId: string, threadId: string): Promise { const messages = await fetchAllMessages(userId, threadId); const summary = await summarizeMessages(messages); await sqlite.execute( ` INSERT OR REPLACE INTO ${KEY}_thread_summaries_${SCHEMA_VERSION} (user_id, thread_id, summary, last_summarized_timestamp) VALUES (?, ?, ?, ?) `, [ userId, threadId, summary, new Date().toISOString(), ], ); return summary; } async function summarizeAllThreads(userId: string) { const threads = await getThreadActivity(userId); for (const thread of threads) { await summarizeThread(userId, thread.thread_id); } } async function getThreadActivity(userId: string): Promise { const result = await sqlite.execute(` SELECT * FROM ${KEY}_thread_activity_${SCHEMA_VERSION} WHERE user_id = ? ORDER BY last_message_timestamp DESC `, [userId]); return result.rows; } async function getThreadSummaries(userId: string): Promise { const result = await sqlite.execute(` SELECT t.thread_id, t.name, t.message_count, t.created_timestamp, t.last_message_timestamp, t.archived, s.summary, s.last_summarized_timestamp FROM ${KEY}_thread_activity_${SCHEMA_VERSION} t LEFT JOIN ${KEY}_thread_summaries_${SCHEMA_VERSION} s ON t.user_id = s.user_id AND t.thread_id = s.thread_id WHERE t.user_id = ? ORDER BY t.last_message_timestamp DESC `, [userId]); return result.rows; } async function getUserToken(userId: string): Promise { const token = await blob.getJSON(`user_token_${userId}`); if (!token) return null; if (Date.now() >= token.expires_at) { return await refreshToken(userId, token.refresh_token); } return token; } async function setUserToken(userId: string, token: UserToken) { const expiresAt = Date.now() + token.expires_in * 1000; await blob.setJSON(`user_token_${userId}`, { ...token, expires_at: expiresAt }); } async function refreshToken(userId: string, refreshToken: string): Promise { const response = await fetch(`${BASE_URL}/oauth2/token`, { method: 'POST', headers: { 'Content-Type': 'application/x-www-form-urlencoded', }, body: new URLSearchParams({ client_id: CLIENT_ID, client_secret: CLIENT_SECRET, grant_type: 'refresh_token', refresh_token: refreshToken, }), }); if (!response.ok) { throw new Error('Failed to refresh token'); } const newToken: UserToken = await response.json(); await setUserToken(userId, newToken); return newToken; } export default async function(req: Request): Promise { await initDatabase(); const url = new URL(req.url); const path = url.pathname; if (path === '/callback') { const code = url.searchParams.get('code'); const state = url.searchParams.get('state'); if (!code || !state) { return new Response('Missing authorization code or state', { status: 400 }); } try { const tokenResponse = await fetch(`${BASE_URL}/oauth2/token`, { method: 'POST', headers: { 'Content-Type': 'application/x-www-form-urlencoded', }, body: new URLSearchParams({ client_id: CLIENT_ID, client_secret: CLIENT_SECRET, grant_type: 'authorization_code', code: code, redirect_uri: REDIRECT_URI, }), }); if (!tokenResponse.ok) { throw new Error('Failed to obtain access token'); } const token: UserToken = await tokenResponse.json(); const userResponse = await fetch(`${BASE_URL}/users/@me`, { headers: { Authorization: `Bearer ${token.access_token}`, }, }); if (!userResponse.ok) { throw new Error('Failed to fetch user information'); } const user = await userResponse.json(); await setUserToken(user.id, token); return new Response(` Authentication Successful

Authentication Successful

You can now close this window and return to the app.

`, { headers: { 'Content-Type': 'text/html' }, }); } catch (error) { console.error('Error in OAuth callback:', error); return new Response(` Authentication Failed

Authentication Failed

An error occurred during authentication. Please try again.

`, { status: 500, headers: { 'Content-Type': 'text/html' } }); } } let userId = url.searchParams.get('userId'); let message = ""; let threadSummaries: ThreadSummary[] = []; if (!userId) { return new Response(` Discord Thread Summarizer

Discord Thread Summarizer

Click the button below to authenticate with Discord and start summarizing threads.

`, { headers: { 'Content-Type': 'text/html' }, }); } try { const userToken = await getUserToken(userId); if (!userToken) { return new Response('User not authenticated. Please authenticate with Discord first.', { status: 401 }); } if (req.method === "POST") { if (url.searchParams.get("action") === "summarize") { const threadId = url.searchParams.get("threadId"); if (threadId) { await summarizeThread(userId, threadId); message = "Thread summarized successfully"; } else { await summarizeAllThreads(userId); message = "All threads summarized successfully"; } } else { await updateThreadActivity(userId); message = "Thread activity updated successfully"; } } await updateThreadActivity(userId); threadSummaries = await getThreadSummaries(userId); } catch (error) { console.error("Error in main function:", error); message = `An error occurred: ${error instanceof Error ? error.message : String(error)}`; } const html = ` Discord Thread Activity and Summaries

Discord Thread Activity and Summaries

${message ? `

${message}

` : ""}

Thread Summaries

${ threadSummaries.length > 0 ? threadSummaries.map(thread => `

${thread.name} ${thread.archived ? "(Archived)" : ""}

Messages: ${thread.message_count}

Created: ${new Date(thread.created_timestamp).toLocaleString()}

Last Message: ${thread.last_message_timestamp ? new Date(thread.last_message_timestamp).toLocaleString() : "N/A"}

Summary: ${thread.summary || "Not yet summarized"}

${thread.last_summarized_timestamp ? `

Last summarized: ${new Date(thread.last_summarized_timestamp).toLocaleString()}

` : ""}

`).join("") : "

No thread summaries available.

" }

View source

`; return new Response(html, { headers: { "Content-Type": "text/html", }, }); }

valtown_bot

Version 26