Val Town Code SearchReturn to Val Town

15- **AI Integration**: Leverages Anthropic's Claude API for analysis
16- **Discord Integration**:
17  - Bot token for fetching messages
18  - Slash commands for user interactions
19  - Webhook endpoint for Discord interactions
502. Copy the contents of the backend directory
513. Set up the required environment variables
524. Create a cron schedule for periodically fetching messages and processing links
53
54## Usage
58- `GET /health`: Check if the service is running
59- `POST /api/interactions`: Discord interactions endpoint
60- `POST /api/fetch-dms`: Manually trigger DM fetching
61- `POST /api/process-links`: Manually trigger link processing
62- `POST /api/query`: Process a query about your messages
63- `POST /api/commands/search`: Endpoint for search commands
64- `POST /api/register-commands`: Register Discord slash commands
65- `GET /api/cron/fetch-dms`: Cron endpoint for fetching DMs
66- `GET /api/cron/process-links`: Cron endpoint for processing links
67

142export async function extractLinkMetadata(url: string): Promise<MetadataResult> {
143  try {
144    // In a production system, you'd want to actually fetch the page content
145    // For simplicity, we'll make an educated guess based on the URL
146    

3import { cors } from "https://esm.sh/@hono/cors@0.0.8";
4import { initializeDatabase } from "./database.ts";
5import { fetchAndStoreDMs } from "./discord-client.ts";
6import { handleDiscordInteractionRequest } from "./discord-interactions.ts";
7import { batchProcessLinks } from "./link-analyzer.ts";
85});
86
87// Manual trigger for fetching DMs
88app.post("/api/fetch-dms", async c => {
89  try {
90    log("Manually triggering DM fetch...", "info");
91    const messages = await fetchAndStoreDMs();
92    return c.json({ 
93      success: true, 
94      message: "DM fetch completed successfully", 
95      count: messages.length,
96      timestamp: new Date().toISOString()
97    });
98  } catch (error) {
99    log(`Error fetching DMs: ${error instanceof Error ? error.message : String(error)}`, "error");
100    return c.json({ 
101      success: false, 
247
248/**
249 * Handles the scheduled DM fetch cron job
250 */
251export async function cronFetchDMs() {
252  try {
253    log("Running scheduled DM fetch...", "info");
254    await initializeServices(); // Ensure services are initialized
255    const messages = await fetchAndStoreDMs();
256    
257    log(`Scheduled DM fetch completed successfully. Fetched ${messages.length} messages.`, "info");
258    return { 
259      success: true, 
260      message: "Scheduled DM fetch completed successfully", 
261      count: messages.length,
262      timestamp: new Date().toISOString()
263    };
264  } catch (error) {
265    log(`Error in DM fetch cron job: ${error instanceof Error ? error.message : String(error)}`, "error");
266    return { 
267      success: false, 
297
298// Expose cron endpoints via HTTP as well
299app.get("/api/cron/fetch-dms", async c => {
300  const result = await cronFetchDMs();
301  return c.json(result, result.success ? 200 : 500);
302});
313});
314
315// Export the fetch handler for Val.town HTTP vals
316export default app.fetch;

53  
54  try {
55    const response = await fetch(endpoint, {
56      method: 'PUT',
57      headers: {

6
7/**
8 * Handle fetching DMs between users using Discord's API
9 */
10export class DiscordClient {
16  
17  /**
18   * Fetch DMs between the user and their partner
19   * @returns {Promise<Array>} - Array of message objects
20   */
21  async fetchDMsBetweenUsers() {
22    try {
23      const myUserId = Deno.env.get("DISCORD_USER_ID");
31      const dmChannel = await this.getDMChannel(spouseUserId);
32      
33      // Fetch messages from the DM channel
34      const messages = await this.fetchMessagesFromChannel(dmChannel.id, myUserId, spouseUserId);
35      
36      console.log(`Fetched ${messages.length} messages`);
37      
38      // Save messages to database
41      return messages;
42    } catch (error) {
43      console.error("Error fetching DMs:", error);
44      throw error;
45    }
53  async getDMChannel(userId: string) {
54    try {
55      const response = await fetch(`${API_BASE}/users/@me/channels`, {
56        method: "POST",
57        headers: {
77  
78  /**
79   * Fetch messages from a channel
80   * @param channelId - The channel ID to fetch messages from
81   * @param myUserId - The user's ID
82   * @param spouseUserId - The spouse's ID
83   * @returns - Array of message objects
84   */
85  async fetchMessagesFromChannel(channelId: string, myUserId: string, spouseUserId: string) {
86    const messages = [];
87    let lastId;
88    let keepFetching = true;
89    
90    // Fetch messages in batches of 100 (Discord API limit)
91    while (keepFetching) {
92      let url = `${API_BASE}/channels/${channelId}/messages?limit=100`;
93      if (lastId) {
95      }
96      
97      const response = await fetch(url, {
98        headers: {
99          "Authorization": `Bot ${this.token}`
103      if (!response.ok) {
104        const error = await response.text();
105        throw new Error(`Failed to fetch messages: ${error}`);
106      }
107      
108      const fetchedMessages = await response.json();
109      
110      if (fetchedMessages.length === 0) {
111        keepFetching = false;
112        break;
113      }
114      
115      // Process and store fetched messages
116      for (const msg of fetchedMessages) {
117        // Only store messages from the two users we care about
118        if (msg.author.id === myUserId || msg.author.id === spouseUserId) {
129      
130      // Get the ID of the last message for pagination
131      lastId = fetchedMessages[fetchedMessages.length - 1].id;
132      
133      // If we got fewer messages than requested, we've reached the end
134      if (fetchedMessages.length < 100) {
135        keepFetching = false;
136      }
137    }
142
143/**
144 * Function to run the message fetching process
145 */
146export async function fetchAndStoreDMs() {
147  const token = Deno.env.get("DISCORD_TOKEN");
148  if (!token) {
151  
152  const client = new DiscordClient(token);
153  return await client.fetchDMsBetweenUsers();
154}

23    name: 'discordDMBotCron',
24    isPublic: false,
25    description: 'Cron job to fetch Discord DMs periodically'
26  },
27  {

21  const [error, setError] = useState<string | null>(null);
22  
23  // Fetch server health status on component mount
24  useEffect(() => {
25    async function checkHealth() {
26      try {
27        setStatus('loading');
28        const response = await fetch('/health');
29        if (!response.ok) {
30          throw new Error(`Health check failed: ${response.status}`);
116                </tr>
117                <tr>
118                  <td className="px-6 py-4 whitespace-nowrap font-mono text-sm">/api/fetch-dms</td>
119                  <td className="px-6 py-4 whitespace-nowrap text-sm">POST</td>
120                  <td className="px-6 py-4 text-sm">Manually trigger DM fetching</td>
121                </tr>
122                <tr>

112   - Find your deployed functions
113   - Add the same environment variables from your `.env` file
1145. Set up a scheduled task for periodic DM fetching:
115   - Create a new scheduled task in Val.town
116   - Use the `discordDMBotCron` function
129   - `/analyze Summarize our furniture discussions`
130
1313. You can also manually trigger a DM fetch:
132   ```
133   node val-town-cron.js
141- Verify that the bot has proper permissions
142
143### Cannot fetch DMs
144- Ensure both you and your spouse have DMed each other at least once
145- Verify that all tokens and IDs in the `.env` file are correct

21});
22
23// HTTP vals expect an exported "fetch handler"
24// This is how you "run the server" in Val Town with Hono
25export default app.fetch;

375}
376
377async function fetchClubProfileFromApi(
378  transfermarktId: string | null | undefined,
379): Promise<ClubProfile | null> {
382  }
383  try {
384    const response = await fetch(`/api/clubProfile/${transfermarktId}`);
385    if (!response.ok) {
386      console.error(
387        `Failed to fetch profile from API for ${transfermarktId}: ${response.status}`,
388      );
389      return null;
401  } catch (error) {
402    console.error(
403      `Error fetching profile from API for ${transfermarktId}:`,
404      error,
405    );
635    setIsLoading(true);
636    setErrorMessage(null);
637    fetch("/api/standings")
638      .then((response) => response.json())
639      .then((data: Standings) => {
648        } else {
649          console.error(
650            "Fetched standings data is not in the expected format:",
651            data,
652          );
653          setStandings([]);
654          setLastUpdated("Error fetching base standings");
655          setErrorMessage(
656            "Failed to load standings data. Invalid format received.",
660        if (data.error) {
661          console.warn(
662            "Server reported an error fetching standings:",
663            data.error,
664          );
667      })
668      .catch((error) => {
669        console.error("Error fetching base standings:", error);
670        setLastUpdated("Error fetching base standings");
671        setErrorMessage(
672          `Failed to load standings data: ${(error as Error).message}`,
681    setIsLoading(true);
682
683    const fetchAllProfiles = async () => {
684      const allEntries = standings.flatMap((conf) => conf.entries);
685      const uniqueTmIds = [
695      setClubValues((prev) => ({ ...prev, ...initialValues }));
696
697      const profilePromises = uniqueTmIds.map((tmId) => fetchClubProfileFromApi(tmId));
698      const results = await Promise.allSettled(profilePromises);
699
707            if (result.status === "rejected") {
708              console.error(
709                `Failed to fetch profile for ID ${tmId}:`,
710                result.reason,
711              );
719    };
720
721    fetchAllProfiles();
722  }, [standings]);
723
876}
877
878async function fetchAndCacheClubProfile_SERVER(
879  transfermarktId: string,
880): Promise<ClubProfile | null> {
904  const options = { method: "GET", headers: { accept: "application/json" } };
905  try {
906    const response = await fetch(url, options);
907    let result: ClubProfile | null = null;
908    let errorMsg: string | null = null;
915      }
916    } else {
917      errorMsg = `Club profile fetch failed for ${transfermarktId}: ${response.status} ${await response.text().catch(
918        () => ""
919      )}`;
936  } catch (error) {
937    console.error(
938      `Error during fetch/process profile for ${transfermarktId}:`,
939      error,
940    );
944}
945
946async function fetchMLSStandings(): Promise<Standings> {
947  const KEY = "MLSpointsPerMillion_mls_standings_v2";
948  let storedData: Standings | null = null;
962    || now - storedData.timestamp > STANDINGS_CACHE_DURATION
963  ) {
964    console.log("Fetching fresh MLS standings data...");
965    const url = "https://major-league-soccer-standings.p.rapidapi.com/";
966    const apiKey = Deno.env.get("RAPIDAPI_KEY")
980    };
981    try {
982      const response = await fetch(url, options);
983      if (!response.ok) {
984        throw new Error(
996      storedData = { timestamp: now, standings: result };
997      await blob.setJSON(KEY, storedData);
998      console.log("Successfully fetched and cached new standings data.");
999      return storedData;
1000    } catch (error) {
1001      console.error("Error fetching or processing MLS standings:", error);
1002      if (storedData) {
1003        console.warn("Returning stale standings data due to fetch error.");
1004        return {
1005          ...storedData,
1006          error: `Failed to fetch fresh standings: ${(error as Error).message}. Displaying cached data.`,
1007        };
1008      } else {
1010          timestamp: now,
1011          standings: [],
1012          error: `Failed to fetch MLS standings: ${(error as Error).message}`,
1013        };
1014      }
1030  // API endpoint for standings data
1031  if (url.pathname === "/api/standings") {
1032    const standingsData = await fetchMLSStandings();
1033    return new Response(JSON.stringify(standingsData), {
1034      headers: headers_json,
1047      });
1048    try {
1049      const profileData = await fetchAndCacheClubProfile_SERVER(transfermarktId);
1050      if (profileData)
1051        return new Response(JSON.stringify(profileData), {
1054        }); else
1055        return new Response(
1056          JSON.stringify({ error: "Profile not found or fetch failed" }),
1057          { headers: headers_json, status: 404 },
1058        );
1059    } catch (error) {
1060      console.error(`Server error fetching profile ${transfermarktId}:`, error);
1061      return new Response(
1062        JSON.stringify({