Fetching Advent of Code Inputs Dynamically in Go

Advent of Code is a fun way for programmers to test and improve their problem-solving skills. While solving the puzzles, you might want to automate the fetching of your personalized puzzle input directly using its URL instead of copying the input to a text file that will be available locally. However, trying to access the input URL using a simple HTTP request, results in the message below:

Puzzle inputs differ by user. Please log in to get your puzzle input.

This article explains why this happens and how to correctly fetch your inputs dynamically using Go programming language.

The Problem: Why Can’t We Fetch The Input Directly?

Advent of Code requires you to log in to access your personalized puzzle inputs. When you log in through the browser, Advent of Code sets a session cookie in your browser. This cookie is used to identify your account and provide your unique input.

If your HTTP requests don’t include this session cookie, the Advent of Code server cannot recognize you as a logged-in user, hence the error message.

Solution: Using the Session Cookie in HTTP Requests

We must include the session cookie in our HTTP requests to fetch the puzzle input. Here is a step-by-step guideline:

• Log in to Advent of Code.

• Open your browser’s Developer Tools (Press F12 key) and navigate to the Network tab.

• Refresh the Advent of Code page and look for the cookie header in the request headers.

• Extract the value of the session cookie.

NOTE: It’s important to keep your session cookie a secret since someone else can access your Advent of Code account if they get access to it.

Code To Fetch The Input

Below is a simple program we will use to fetch our puzzle input dynamically:

We start by defining the base URL for fetching inputs and creating a function to read the input for a specific day.

const baseURL = "https://adventofcode.com/2024/day/%s/input"

func readInput(day string) {
    url := fmt.Sprintf(baseURL, day)
    fmt.Println(url)
}

• Creating The HTTP Request

Next, we create an HTTP request and include the session cookie.

client := &http.Client{}
    req, err := http.NewRequest("GET", url, nil)
    if err != nil {
        fmt.Printf("Error creating HTTP request: %vn", err)
        return
    }

    // Add the session cookie
    req.Header.Add("Cookie", "session=[YOUR_SESSION_TOKEN]")

http.NewRequest: Creates an HTTP GET request for the input URL.

req.Header.Add: Adds a header to the request with the session token for authentication. (Replace [YOUR_SESSION_TOKEN] with your actual token).

• Sending The Request And Handling The Response

Now we send the HTTP request and read the server’s response.

resp, err := client.Do(req)
    if err != nil {
        fmt.Printf("Error making HTTP request: %vn", err)
        return
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        fmt.Printf("Unexpected HTTP status: %dn", resp.StatusCode)
        return
    }

client.Do(req): Sends the HTTP request and stores the response.

defer resp.Body.Close(): Ensures the response body is closed after reading.

resp.StatusCode: Checks the HTTP status code. A code other than 200 indicates an error.

• Reading And Printing The Input

Finally, we read the response body and print the puzzle input.

body, err := io.ReadAll(resp.Body)
    if err != nil {
        fmt.Printf("Error reading response body: %vn", err)
        return
    }

    fmt.Println(string(body))

io.ReadAll(resp.Body): Reads the response body.

string(body): Converts the body from a slice of bytes to a string for easy display.

• Defining The Main Function

We invoke the readInput function from the main function to fetch the input for day 1.

func main() {
    readInput("1") // Fetches input puzzle for day 1
}

Enhancing Security

Hardcoding the session token in our code isn’t safe. Instead, we should store it as an environment variable using the steps below:

1. Export the session token using the terminal:

export AOC_SESSION="[YOUR_SESSION_TOKEN]"

1. Modify the code to read the session token from the environment variable. (Ensure to have “os” among your imports):

req.Header.Add("Cookie", "session="+os.Getenv("AOC_SESSION"))

This helps, the session token stay outside the source code, reducing the risk of accidental exposure.

Here’s the complete program for reference:

package main

import (
    "fmt"
    "io"
    "net/http"
    "os"
)

const baseURL = "https://adventofcode.com/2024/day/%s/input"

func readInput(day string) {
    url := fmt.Sprintf(baseURL, day)

    client := &http.Client{}
    req, err := http.NewRequest("GET", url, nil)
    if err != nil {
        fmt.Printf("Error creating HTTP request: %vn", err)
        return
    }

    // Use session token from environment variable
    req.Header.Add("Cookie", "session="+os.Getenv("AOC_SESSION"))

    resp, err := client.Do(req)
    if err != nil {
        fmt.Printf("Error making HTTP request: %vn", err)
        return
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        fmt.Printf("Unexpected HTTP status: %dn", resp.StatusCode)
        return
    }

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        fmt.Printf("Error reading response body: %vn", err)
        return
    }

    fmt.Println(string(body))
}

func main() {
    readInput("1")
}

Things To Keep In Mind

• Session Expiry: Session tokens may expire after a while. If you encounter issues, log in again and retrieve a fresh token.

• Privacy: Never share your session token publicly, including in blog posts or GitHub repositories.

Conclusion

You can dynamically fetch your Advent of Code inputs by including your session cookie in HTTP requests.

Feel free to share your tips or ask questions in the comment section. Happy coding, and good luck with Advent of Code 2024!