add twitch API stuff, add follow/sub/cheer labels

.env.example

@@ -0,0 +1,3 @@
+TWITCH_CHANNEL_NAME=""
+TWITCH_CLIENT_ID=""
+TWITCH_CLIENT_SECRET=""

.gitignore

@@ -1,2 +1,4 @@
 tmp/
 learning-title.txt
+.env
+twitch-auth.json

config/config.go

@@ -0,0 +1,13 @@
+package config
+
+import (
+	"os"
+	"path"
+)
+
+var CONFIG_DIR = func() string {
+	baseDir, _ := os.UserConfigDir()
+	dir := path.Join(baseDir, "ari-stream-tools")
+	if err := os.MkdirAll(dir, 0750); err != nil { panic(err) }
+	return dir
+}()

go.mod

@@ -17,6 +17,7 @@ require (
 	github.com/goccy/go-json v0.10.5 // indirect
 	github.com/goccy/go-yaml v1.19.2 // indirect
 	github.com/godbus/dbus/v5 v5.2.2 // indirect
+	github.com/gorilla/websocket v1.5.3 // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
 	github.com/klauspost/cpuid/v2 v2.3.0 // indirect
 	github.com/leodido/go-urn v1.4.0 // indirect
@@ -32,6 +33,7 @@ require (
 	golang.org/x/arch v0.22.0 // indirect
 	golang.org/x/crypto v0.48.0 // indirect
 	golang.org/x/net v0.51.0 // indirect
+	golang.org/x/oauth2 v0.36.0 // indirect
 	golang.org/x/sys v0.41.0 // indirect
 	golang.org/x/text v0.34.0 // indirect
 	google.golang.org/protobuf v1.36.10 // indirect

go.sum

@@ -27,6 +27,8 @@ github.com/goccy/go-yaml v1.19.2/go.mod h1:XBurs7gK8ATbW4ZPGKgcbrY1Br56PdM69F7Lk
 github.com/godbus/dbus/v5 v5.2.2 h1:TUR3TgtSVDmjiXOgAAyaZbYmIeP3DPkld3jgKGV8mXQ=
 github.com/godbus/dbus/v5 v5.2.2/go.mod h1:3AAv2+hPq5rdnr5txxxRwiGjPXamgoIHgz9FPBfOp3c=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
+github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
 github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
 github.com/klauspost/cpuid/v2 v2.3.0 h1:S4CRMLnYUhGeDFDqkGriYKdfoFlDnMtqTiI/sFzhA9Y=
@@ -68,6 +70,8 @@ golang.org/x/crypto v0.48.0 h1:/VRzVqiRSggnhY7gNRxPauEQ5Drw9haKdM0jqfcCFts=
 golang.org/x/crypto v0.48.0/go.mod h1:r0kV5h3qnFPlQnBSrULhlsRfryS2pmewsg+XfMgkVos=
 golang.org/x/net v0.51.0 h1:94R/GTO7mt3/4wIKpcR5gkGmRLOuE/2hNGeWq/GBIFo=
 golang.org/x/net v0.51.0/go.mod h1:aamm+2QF5ogm02fjy5Bb7CQ0WMt1/WVM7FtyaTLlA9Y=
+golang.org/x/oauth2 v0.36.0 h1:peZ/1z27fi9hUOFCAZaHyrpWG5lwe0RJEEEeH0ThlIs=
+golang.org/x/oauth2 v0.36.0/go.mod h1:YDBUJMTkDnJS+A4BP4eZBjCqtokkg1hODuPjwiGPO7Q=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.41.0 h1:Ivj+2Cp/ylzLiEU89QhWblYnOE9zerudt9Ftecq2C6k=
 golang.org/x/sys v0.41.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=

main.go

@@ -12,6 +12,8 @@ import (
 
 	"codeberg.org/arimelody/ari-stream-tools/learning"
 	"codeberg.org/arimelody/ari-stream-tools/music"
+	"codeberg.org/arimelody/ari-stream-tools/twitch"
+	"codeberg.org/arimelody/ari-stream-tools/utils/dotenv"
 	"github.com/gin-gonic/gin"
 )
 
@@ -23,6 +25,13 @@ func main() {
 	ctx, cancel := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
 	defer cancel()
 
+	envars, err := dotenv.LoadEnv()
+	if err != nil {
+		if !os.IsNotExist(err) {
+			log.Fatalf("Failed to read .env: %v", err)
+		}
+	}
+
 	gin.SetMode(gin.ReleaseMode)
 
 	host := DEFAULT_HOST
@@ -43,12 +52,30 @@ func main() {
 		TitleFilePath: "learning-title.txt",
 	})
 	musicService := music.New(ctx)
+	twitchService, err := twitch.New(ctx, twitch.ServiceOptions{
+		Port: port,
+		ChannelName: dotenv.SafeGet(envars, "TWITCH_CHANNEL_NAME"),
+		ClientID: dotenv.SafeGet(envars, "TWITCH_CLIENT_ID"),
+		ClientSecret: dotenv.SafeGet(envars, "TWITCH_CLIENT_SECRET"),
+	})
+	if err != nil {
+		log.Fatalf("Failed to create Twitch service: %v", err)
+	}
 
 	srv := gin.Default()
+	srv.Use(gin.LoggerWithConfig(gin.LoggerConfig{
+		SkipPaths: []string{
+			"/twitch/public",
+			"/music/public",
+			"/learning/public",
+		},
+	}))
 	learningService.BindRoutes(srv.Group("/learning"))
 	musicService.BindRoutes(srv.Group("/music"))
+	twitchService.BindRoutes(srv.Group("/twitch"))
 
 	go musicService.Run(ctx)
+	go twitchService.Run(ctx)
 	go func() {
 		log.Printf("Now serving at http://%s:%d\n", host, port)
 		failed <- srv.Run(fmt.Sprintf("%s:%d", host, port))

music/music.go

@@ -106,7 +106,7 @@ func (srv *Service) BindRoutes(group *gin.RouterGroup) {
 	})
 
 	group.GET("/artwork", func(ctx *gin.Context) {
-		ctx.Header("cache-control", "no-cache")
+		ctx.Header("cache-control", "no-store")
 
 		if srv.track == nil || srv.track.ArtworkURL == "" {
 			http.ServeFileFS(ctx.Writer, ctx.Request, publicFS, "public/default-cover-art.png")

music/pages/music.html

@@ -26,6 +26,5 @@
             </div>
         </div>
         <script type="module" src="/music/public/music.js"></script>
-        <div id="cover"></div>
     </body>
 </html>

music/public/music.css

@@ -65,6 +65,7 @@ p {
     left: 0;
     bottom: 0;
     width: min-content;
+    max-width: calc(100% - 4em);
     padding: 2em;
 }
 
@@ -87,7 +88,7 @@ p {
 }
 
 .title-artist {
-    max-width: calc(100vw - 2em - 80px);
+    max-width: calc(100vw - 4em - 80px);
 }
 
 .title {
@@ -118,3 +119,9 @@ p {
         opacity: 0;
     }
 }
+
+#music.switching {
+    .artwork {
+        filter: blur(4px);
+    }
+}

twitch/api/api.go

@@ -0,0 +1,52 @@
+package api
+
+type (
+	EventSubMetadata struct {
+		MessageID string `json:"message_id"`
+		MessageType string `json:"message_type"`
+		MessageTimestamp string `json:"message_timestamp"`
+	}
+
+	EventSubSession struct {
+		ID string `json:"id"`
+		Status string `json:"status"`
+		KeepaliveTimeoutSeconds int `json:"keepalive_timeout_seconds"`
+		ReconnectURL string `json:"reconnect_url"`
+		ConnectedAt string `json:"connected_at"`
+	}
+
+	EventSubSubscriptionTransport struct {
+		Method string `json:"method"`
+		SessionID string `json:"session_id"`
+	}
+	EventSubSubscription struct {
+		ID string `json:"id"`
+		Status string `json:"status"`
+		Type string `json:"type"`
+		Version string `json:"version"`
+		Cost int `json:"cost"`
+		Condition any `json:"condition"`
+		Transport EventSubSubscriptionTransport `json:"transport"`
+		CreatedAt string `json:"connected_at"`
+	}
+
+	EventSubPayload struct {
+		Session *EventSubSession `json:"session"`
+		Subscription *EventSubSubscription `json:"subscription"`
+		Event any `json:"event"`
+	}
+
+	EventSubMessage struct {
+		Metadata EventSubMetadata `json:"metadata"`
+		Payload EventSubPayload `json:"payload"`
+	}
+)
+
+type MessageType string
+const (
+	SESSION_WELCOME MessageType = "session_welcome"
+	SESSION_KEEPALIVE MessageType = "session_keepalive"
+	NOTIFICATION MessageType = "notification"
+	SESSION_RECONNECT MessageType = "session_reconnect"
+	SESSION_RECOVATION MessageType = "session_revocation"
+)

twitch/api/event.go

@@ -0,0 +1,177 @@
+package api
+
+type (
+	ChannelEvent struct {
+		UserID string `json:"user_id"`
+		UserLogin string `json:"user_login"`
+		UserName string `json:"user_name"`
+
+		BroadcasterID string `json:"broadcaster_user_id"`
+		BroadcasterLogin string `json:"broadcaster_user_login"`
+		BroadcasterName string `json:"broadcaster_user_name"`
+	}
+
+	FollowEvent struct {
+		ChannelEvent
+		FollowedAt string `json:"followed_at"`
+	}
+
+	SubscribeEvent struct {
+		ChannelEvent
+		Tier string `json:"tier"`
+		IsGift bool `json:"is_gift"`
+	}
+
+	CheerEvent struct {
+		ChannelEvent
+		Message string `json:"message"`
+		Bits int `json:"bits"`
+		IsAnonymous bool `json:"is_anonymous"`
+	}
+
+	RaidEvent struct {
+		FromUserID string `json:"from_broadcaster_user_id"`
+		FromUserLogin string `json:"from_broadcaster_user_login"`
+		FromUserName string `json:"from_broadcaster_user_name"`
+
+		ToUserID string `json:"to_broadcaster_user_id"`
+		ToUserLogin string `json:"to_broadcaster_user_login"`
+		ToUserName string `json:"to_broadcaster_user_name"`
+
+		Viewers int `json:"viewers"`
+	}
+
+	Reward struct {
+		ID string `json:"id"`
+		Title string `json:"title"`
+		Cost int `json:"cost"`
+		Prompt string `json:"prompt"`
+	}
+	ChannelPointCustomRewardRedeemEvent struct {
+		ChannelEvent
+		ID string `json:"id"`
+		UserInput string `json:"user_input"`
+		Status string `json:"status"`
+		RedeemedAt string `json:"redeemed_at"`
+		Reward Reward `json:"reward"`
+	}
+
+	ShoutoutCreate struct {
+		FromUserID string `json:"broadcaster_user_id"`
+		FromUserLogin string `json:"broadcaster_user_login"`
+		FromUserName string `json:"broadcaster_user_name"`
+
+		ToUserID string `json:"to_broadcaster_user_id"`
+		ToUserLogin string `json:"to_broadcaster_user_login"`
+		ToUserName string `json:"to_broadcaster_user_name"`
+
+		ModeratorID string `json:"moderator_broadcaster_user_id"`
+		ModeratorLogin string `json:"moderator_broadcaster_user_login"`
+		ModeratorName string `json:"moderator_broadcaster_user_name"`
+
+		ViewerCount int `json:"viewer_count"`
+		StartedAt string `json:"started_at"`
+		CooldownEndsAt string `json:"cooldown_ends_at"`
+		TargetCooldownEndsAt string `json:"target_cooldown_ends_at"`
+	}
+
+	ChatMessageCheermote struct {
+		Prefix string `json:"prefix"`
+		Bits int `json:"bits"`
+		Tier int `json:"tier"`
+	}
+	ChatMessageEmote struct {
+		ID string `json:"id"`
+		EmoteSetID string `json:"emote_set_id"`
+		OwnerID string `json:"owner_id"`
+		Format []string `json:"format"`
+	}
+	ChatMessageMention struct {
+		UserID string `json:"user_id"`
+		UserLogin string `json:"user_login"`
+		UserName string `json:"user_name"`
+	}
+	ChatMessageGif struct {
+		GifID string `json:"gif_id"`
+		Url string `json:"url"`
+	}
+	ChatMessageFragment struct {
+		Type string `json:"type"`
+		Text string `json:"text"`
+		Cheermote *ChatMessageCheermote `json:"cheermote"`
+		Emote *ChatMessageEmote `json:"emote"`
+		Mention *ChatMessageMention `json:"mention"`
+		Gif *ChatMessageGif `json:"gif"`
+	}
+	ChatMessage struct {
+		Text string `json:"text"`
+		Fragments []ChatMessageFragment `json:"fragments"`
+	}
+	ChatBadge struct {
+		SetID string `json:"set_id"`
+		ID string `json:"id"`
+		Info string `json:"info"`
+	}
+	ChatCheer struct {
+		Bits int `json:"bits"`
+	}
+	ChatReply struct {
+		ParentMessageID string `json:"parent_message_id"`
+		ParentMessageBody string `json:"parent_message_body"`
+		ParentUserID string `json:"parent_user_id"`
+		ParentUserLogin string `json:"parent_user_login"`
+		ParentUserName string `json:"parent_user_name"`
+
+		ThreadMessageID string `json:"thread_message_id"`
+		ThreadUserID string `json:"thread_user_id"`
+		ThreadUserLogin string `json:"thread_user_login"`
+		ThreadUserName string `json:"thread_user_name"`
+	}
+	SourceBadges struct {
+		SetID string `json:"set_id"`
+		ID string `json:"id"`
+		Info string `json:"info"`
+	}
+	ChatEvent struct {
+		BroadcasterID string `json:"broadcaster_user_id"`
+		BroadcasterLogin string `json:"broadcaster_user_login"`
+		BroadcasterName string `json:"broadcaster_user_name"`
+
+		ChatterID string `json:"chatter_user_id"`
+		ChatterLogin string `json:"chatter_user_login"`
+		ChatterName string `json:"chatter_user_name"`
+
+		MessageID string `json:"message_id"`
+		Message ChatMessage `json:"message"`
+		MessageType string `json:"message_type"`
+
+		Badges []ChatBadge `json:"badges"`
+		Cheer *ChatCheer `json:"cheer"`
+		Color string `json:"color"`
+		Reply *ChatReply `json:"reply"`
+
+		ChannelPointsCustomRewardID string `json:"channel_points_custom_reward_id"`
+
+		SourceBroadcasterUserID string `json:"source_broadcaster_user_id"`
+		SourceBroadcasterUserName string `json:"source_broadcaster_user_name"`
+		SourceBroadcasterUserLogin string `json:"source_broadcaster_user_login"`
+
+		SourceMessageID string `json:"source_message_id"`
+
+		SourceBadges *SourceBadges `json:"source_badges"`
+
+		IsSourceOnly bool `json:"is_source_only"`
+	}
+
+	ChatDeleteEvent struct {
+		BroadcasterID string `json:"broadcaster_user_id"`
+		BroadcasterLogin string `json:"broadcaster_user_login"`
+		BroadcasterName string `json:"broadcaster_user_name"`
+
+		TargetID string `json:"target_user_id"`
+		TargetLogin string `json:"target_user_login"`
+		TargetName string `json:"target_user_name"`
+
+		MessageID string `json:"message_id"`
+	}
+)

twitch/oauth/oauth.go

@@ -0,0 +1,77 @@
+package oauth
+
+import (
+	"context"
+	"crypto/rand"
+	"fmt"
+	"log"
+	"net/http"
+	"sync"
+
+	"golang.org/x/oauth2"
+)
+
+func GenerateToken(
+	ctx *context.Context,
+	oauth2Config *oauth2.Config,
+) (*oauth2.Token, error) {
+	verifier := oauth2.GenerateVerifier()
+
+	state := rand.Text()
+
+	var token *oauth2.Token
+	wg := sync.WaitGroup{}
+
+	var server http.Server
+	server.Addr = "127.0.0.1"
+	server.Handler = http.HandlerFunc(
+		func(w http.ResponseWriter, r *http.Request) {
+			code := r.URL.Query().Get("code")
+			scope := r.URL.Query().Get("scope")
+			resState := r.URL.Query().Get("state")
+
+			if len(code) == 0 || len(scope) == 0 || resState != state {
+				http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
+				return
+			}
+
+			t, err := oauth2Config.Exchange(*ctx, code, oauth2.VerifierOption(verifier))
+			if err != nil {
+				log.Fatalf("Could not exchange OAuth2 code: %v", err)
+				http.Error( w,
+					fmt.Sprintf("Could not exchange OAuth2 code: %v", err),
+					http.StatusBadRequest,
+				)
+				return
+			}
+
+			token = t
+			http.Error(
+				w,
+				"Authentication successful! You may now close this tab.",
+				http.StatusOK,
+			)
+			if f, ok := w.(http.Flusher); ok {
+				f.Flush()
+			}
+
+			wg.Done()
+			server.Close()
+		},
+	)
+
+	url := oauth2Config.AuthCodeURL(
+		state,
+		oauth2.AccessTypeOffline,
+		oauth2.S256ChallengeOption(verifier),
+	)
+	log.Printf("Log in with Twitch: %s\n\n", url)
+
+	wg.Add(1)
+	if err := server.ListenAndServe(); err != http.ErrServerClosed {
+		return nil, fmt.Errorf("http: %v", err)
+	}
+	wg.Wait()
+
+	return token, nil
+}

twitch/pages/labels.html

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html lang="en">
+    <head>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1">
+        <title>Twitch Labels</title>
+        <link rel="stylesheet" href="/music/public/fonts/inter/inter.css">
+        <link rel="stylesheet" href="/twitch/public/labels.css">
+    </head>
+    <body>
+        <p id="label"></p>
+        <script type="module" src="/twitch/public/labels.js" defer></script>
+    </body>
+</html>

twitch/public/labels.css

@@ -0,0 +1,10 @@
+body {
+    margin: 0;
+}
+
+#label {
+    margin: 16px;
+    font-family: "Inter", sans-serif;
+    font-size: 64px;
+    font-weight: bold;
+}

twitch/public/labels.js

@@ -0,0 +1,60 @@
+const labelEl = document.getElementById("label");
+
+const selectedLabel = new URLSearchParams(location.search).get("l");
+const labelLatestFollower   = "latest-follower"
+const labelLatestSubscriber = "latest-subscriber"
+const labelLatestCheer      = "latest-cheer"
+const allowedLabels = [
+    labelLatestFollower,
+    labelLatestSubscriber,
+    labelLatestCheer,
+]
+
+/**
+ * @param {string} selectedLabel
+ */
+async function sync() {
+    if (selectedLabel == null) {
+        const exampleUrl = 
+            location.pathname +
+            "?l=" +
+            labelLatestFollower;
+
+        labelEl.innerHTML =
+            "Needs label to listen to, " +
+            `such as <a href="${exampleUrl}">${labelLatestFollower}</a>`;
+        console.error("Needs label to listen to, such as " + exampleUrl);
+        return;
+    }
+
+    let eventSource;
+    try {
+        eventSource = new EventSource("/twitch/sse?l=" + selectedLabel);
+    } catch (err) {
+        console.error("Failed to connect to event source", err);
+        return;
+    }
+
+    eventSource.addEventListener("error", () => {
+        eventSource.close();
+        console.error("Connection lost, or an error has occurred.");
+        console.log("Attempting to reconnect...");
+
+        // TODO: stop reconnecting after 10 failed attempts
+
+        setTimeout(() => {
+            sync();
+        }, 1000);
+    });
+
+    eventSource.addEventListener("update", event => {
+        console.log(event.data);
+        labelEl.innerText = event.data;
+    });
+
+    eventSource.addEventListener("open", () => {
+        console.log("Connected.");
+    });
+}
+
+sync();

twitch/twitch.go

@@ -0,0 +1,657 @@
+package twitch
+
+import (
+	"bytes"
+	"context"
+	"crypto/rand"
+	"embed"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"net/url"
+	"os"
+	"os/signal"
+	"path"
+	"strings"
+	"time"
+
+	"codeberg.org/arimelody/ari-stream-tools/broadcast"
+	"codeberg.org/arimelody/ari-stream-tools/config"
+	"codeberg.org/arimelody/ari-stream-tools/twitch/api"
+	"github.com/gin-gonic/gin"
+	"github.com/gorilla/websocket"
+	"golang.org/x/oauth2"
+)
+
+type (
+	twitchLabel struct {
+		Text		string
+		C			chan string
+		Broadcast	broadcast.BroadcastChannel[string]
+	}
+
+	twitchLabels struct {
+		LatestFollower		*twitchLabel
+		LatestSubscriber	*twitchLabel
+		LatestCheer			*twitchLabel
+	}
+
+	ServiceOptions struct {
+		Port int16
+		ChannelName string
+		ClientID string
+		ClientSecret string
+	}
+
+	Service struct {
+		port int16
+		labels	*twitchLabels
+		channelName string
+		channelID string
+		clientID string
+		clientSecret string
+		oauthConfig *oauth2.Config
+		oauthState string
+		oauthToken *oauth2.Token
+		eventSubSession *api.EventSubSession
+	}
+)
+
+const (
+	TWITCH_EVENTSUB_URL string	= "wss://eventsub.wss.twitch.tv/ws"
+	TWITCH_API_BASE string		= "https://api.twitch.tv/helix"
+	TWITCH_OAUTH2_URL string	= "https://id.twitch.tv/oauth2/token"
+
+	LABEL_LATEST_FOLLOWER string	= "latest-follower"
+	LABEL_LATEST_SUBSCRIBER string	= "latest-subscriber"
+	LABEL_LATEST_CHEER string		= "latest-cheer"
+)
+
+var DATA_PATH string = path.Join(config.CONFIG_DIR, "twitch")
+
+//go:embed public
+var publicFS embed.FS
+//go:embed pages
+var pagesFS embed.FS
+
+func New(ctx context.Context, opts ServiceOptions) (*Service, error) {
+	latestFollowerC := make(chan string)
+	latestFollowerBroadcast := broadcast.NewBroadcastChannel(
+		ctx, latestFollowerC)
+	latestSubscriberC := make(chan string)
+	latestSubscriberBroadcast := broadcast.NewBroadcastChannel(
+		ctx, latestSubscriberC)
+	latestCheerC := make(chan string)
+	latestCheerBroadcast := broadcast.NewBroadcastChannel(
+		ctx, latestCheerC)
+
+	srv := &Service{
+		labels: &twitchLabels{
+			LatestFollower: &twitchLabel{
+				Text: "some_follower",
+				C: latestFollowerC,
+				Broadcast: latestFollowerBroadcast,
+			},
+			LatestSubscriber: &twitchLabel{
+				Text: "some_subscriber",
+				C: latestSubscriberC,
+				Broadcast: latestSubscriberBroadcast,
+			},
+			LatestCheer: &twitchLabel{
+				Text: "some_cheer",
+				C: latestCheerC,
+				Broadcast: latestCheerBroadcast,
+			},
+		},
+		channelName: opts.ChannelName,
+		clientID: opts.ClientID,
+		clientSecret: opts.ClientSecret,
+		oauthConfig: &oauth2.Config{
+			ClientID: opts.ClientID,
+			ClientSecret: opts.ClientSecret,
+			Endpoint: oauth2.Endpoint{
+				AuthURL: "https://id.twitch.tv/oauth2/authorize",
+				TokenURL: "https://id.twitch.tv/oauth2/token",
+			},
+			Scopes: []string{
+				"moderator:read:followers",
+				"user:read:chat",
+				"user:bot",
+				"channel:bot",
+				"channel:read:subscriptions",
+				"bits:read",
+				"channel:read:redemptions",
+				"channel:read:polls",
+				"channel:read:predictions",
+				"channel:read:hype_train",
+				"moderator:read:shoutouts",
+			},
+			RedirectURL: fmt.Sprintf("http://localhost:%d/twitch/auth", opts.Port),
+		},
+	}
+
+	if err := os.MkdirAll(DATA_PATH, 0750); err != nil { panic(err) }
+	if err := os.MkdirAll(path.Join(DATA_PATH, "state"), 0750); err != nil { panic(err) }
+
+	authFile, err := os.OpenFile(path.Join(DATA_PATH, "twitch-auth.json"), os.O_RDONLY, 0600)
+	if err != nil {
+		if !os.IsNotExist(err) {
+			log.Fatalf("Failed to open twitch-auth.json: %v", err)
+		}
+	} else {
+		srv.oauthToken = &oauth2.Token{}
+		err = json.NewDecoder(authFile).Decode(srv.oauthToken)
+		if err != nil {
+			log.Printf("Failed to read twitch-auth.json: %v", err)
+		}
+	}
+	authFile.Close()
+
+	if data, err := os.ReadFile(path.Join(DATA_PATH, "state", LABEL_LATEST_FOLLOWER)); err == nil {
+		srv.labels.LatestFollower.Text = string(data)
+		log.Printf("Loaded latest follower: %s", string(data))
+	}
+	if data, err := os.ReadFile(path.Join(DATA_PATH, "state", LABEL_LATEST_SUBSCRIBER)); err == nil {
+		srv.labels.LatestSubscriber.Text = string(data)
+		log.Printf("Loaded latest subscriber: %s", string(data))
+	}
+	if data, err := os.ReadFile(path.Join(DATA_PATH, "state", LABEL_LATEST_CHEER)); err == nil {
+		srv.labels.LatestCheer.Text = string(data)
+		log.Printf("Loaded latest cheer: %s", string(data))
+	}
+
+	return srv, nil
+}
+
+func (srv *Service) BindRoutes(group *gin.RouterGroup) {
+	group.GET("/public/*path", func(ctx *gin.Context) {
+		path := strings.TrimPrefix(ctx.Request.URL.Path, "/twitch/")
+		http.ServeFileFS(ctx.Writer, ctx.Request, publicFS, path)
+	})
+
+	group.GET("/auth", func(ctx *gin.Context) {
+		code := ctx.Query("code")
+		scope := ctx.Query("scope")
+		resState := ctx.Query("state")
+
+		if len(code) == 0 || len(scope) == 0 || resState != srv.oauthState {
+			ctx.String(http.StatusBadRequest, http.StatusText(http.StatusBadRequest))
+			return
+		}
+
+		token, err := srv.oauthConfig.Exchange(ctx, code)
+		if err != nil {
+			log.Printf("Could not exchange OAuth2 code: %v", err)
+			ctx.String(http.StatusBadRequest, "Could not exchange OAuth2 code.")
+			return
+		}
+
+		srv.oauthToken = token
+		authFile, err := os.OpenFile(path.Join(DATA_PATH, "twitch-auth.json"), os.O_CREATE | os.O_RDWR, 0600)
+		if err != nil {
+			log.Printf("Failed to open twitch-auth.json: %v", err)
+			ctx.String(http.StatusInternalServerError, http.StatusText(http.StatusInternalServerError))
+			return
+		}
+		defer authFile.Close()
+		authFile.Truncate(0)
+		json.NewEncoder(authFile).Encode(srv.oauthToken)
+
+		ctx.String(
+			http.StatusOK,
+			"Authentication successful! You may now close this tab.",
+		)
+
+		go srv.start(ctx)
+	})
+
+	group.GET("/sse", func(ctx *gin.Context) {
+		ctx.Header("connection", "keep-alive")
+
+		listeningTo := ctx.Query("l")
+
+		var label *twitchLabel
+		switch listeningTo {
+		case LABEL_LATEST_FOLLOWER:
+			label = srv.labels.LatestFollower
+		case LABEL_LATEST_SUBSCRIBER:
+			label = srv.labels.LatestSubscriber
+		case LABEL_LATEST_CHEER:
+			label = srv.labels.LatestCheer
+		default:
+			ctx.String(http.StatusBadRequest, "Unknown label %s", listeningTo)
+			return
+		}
+
+		labelUpdate := label.Broadcast.Subscribe()
+		defer label.Broadcast.Cancel(labelUpdate)
+
+		ctx.SSEvent("update", label.Text)
+
+		ticker := time.NewTicker(10 * time.Millisecond)
+		ctx.Stream(func(w io.Writer) bool {
+			select {
+			case text := <-labelUpdate:
+				ctx.SSEvent("update", text)
+			case <-ticker.C:
+			}
+			return true
+		})
+	})
+
+	group.GET("/labels", func(ctx *gin.Context) {
+		http.ServeFileFS(ctx.Writer, ctx.Request, pagesFS, "pages/labels.html")
+	})
+}
+
+func (srv *Service) Run(ctx context.Context) {
+	if srv.oauthToken == nil {
+		srv.oauthState = rand.Text()
+		authCodeURL := srv.oauthConfig.AuthCodeURL(srv.oauthState)
+		log.Printf("Log in with Twitch: %s", authCodeURL)
+	} else {
+		srv.start(ctx)
+	}
+}
+
+func (srv *Service) start(ctx context.Context) {
+	userIDs, err := srv.userIDsFromNames([]string{ srv.channelName })
+	if err != nil {
+		log.Printf(
+			"Failed to resolve Twitch username \"%s\": %v",
+			srv.channelName,
+			err,
+		)
+		return
+	}
+	if len(userIDs) == 0 {
+		fmt.Printf("Failed to resolve username \"%s\", it may not exist?", srv.channelName)
+		return
+	}
+	srv.channelID = userIDs[0]
+
+	log.Printf("Connecting to Twitch as %s...", srv.channelName)
+	
+
+
+	interrupt := make(chan os.Signal, 1)
+	signal.Notify(interrupt, os.Interrupt)
+
+	u, err := url.Parse(TWITCH_EVENTSUB_URL + "?keepalive_timeout_seconds=600")
+	if err != nil { panic(err) }
+
+	c, _, err := websocket.DefaultDialer.Dial(u.String(), http.Header{
+		"Authorization": []string{ "Bearer " + srv.clientSecret },
+	})
+	if err != nil {
+		log.Printf("Failed to connect to Twitch: %v", err)
+	}
+	defer c.Close()
+
+	failed := make(chan error)
+	go func() {
+		for {
+			_, rawData, err := c.ReadMessage()
+			if err != nil { failed <- err; return }
+
+			var message api.EventSubMessage
+			err = json.Unmarshal(rawData, &message)
+			if err != nil {
+				failed <- fmt.Errorf("parse JSON: %v", err)
+				return
+			}
+
+			if message.Payload.Session != nil {
+				if err := srv.registerEventSubSession(message.Payload.Session); err != nil {
+					failed <- fmt.Errorf("register eventsub session: %v", err)
+					return
+				}
+
+				srv.subscribeToDefaultEvents()
+			}
+
+			if message.Metadata.MessageType == string(api.NOTIFICATION) {
+				if message.Payload.Subscription == nil { continue }
+
+				if err := srv.handleNotification(&message.Payload); err != nil {
+					log.Printf("Failed to handle %s event: %v", message.Payload.Subscription.Type, err)
+				}
+				continue
+			}
+		}
+	}()
+
+	select {
+	case err := <-failed:
+		log.Fatalf("Twitch error: %v", err)
+	case <-ctx.Done():
+	}
+}
+
+func (srv *Service) registerEventSubSession(session *api.EventSubSession) error {
+	srv.eventSubSession = session
+	return nil
+}
+
+func (srv *Service) handleNotification(payload *api.EventSubPayload) error {
+	var err error
+	jsonData, err := json.Marshal(payload.Event)
+	if err != nil { return err }
+
+	switch payload.Subscription.Type {
+
+	case "channel.follow":
+		var event api.FollowEvent
+		err := json.Unmarshal(jsonData, &event)
+		if err != nil { return fmt.Errorf("Failed to cast to api.FollowEvent: %v", err) }
+		log.Printf("New follow: %s", event.UserLogin)
+		srv.labels.LatestFollower.Text = event.UserLogin
+		srv.labels.LatestFollower.C <- event.UserLogin
+
+		if err := os.WriteFile(
+			path.Join(DATA_PATH, "state", LABEL_LATEST_FOLLOWER),
+			[]byte(event.UserLogin), 0640,
+		); err != nil {
+			return fmt.Errorf("Failed to write %s state: %v", LABEL_LATEST_FOLLOWER, err)
+		}
+
+	case "channel.subscribe":
+		var event api.SubscribeEvent
+		err := json.Unmarshal(jsonData, &event)
+		if err != nil { return fmt.Errorf("Failed to cast to api.SubscribeEvent: %v", err) }
+		log.Printf("New subscription: %s", event.UserLogin)
+		srv.labels.LatestSubscriber.Text = event.UserLogin
+		srv.labels.LatestSubscriber.C <- event.UserLogin
+
+		if err := os.WriteFile(
+			path.Join(DATA_PATH, "state", LABEL_LATEST_SUBSCRIBER),
+			[]byte(event.UserLogin), 0640,
+		); err != nil {
+			return fmt.Errorf("Failed to write %s state: %v", LABEL_LATEST_SUBSCRIBER, err)
+		}
+
+	case "channel.cheer":
+		var event api.CheerEvent
+		err := json.Unmarshal(jsonData, &event)
+		if err != nil { return fmt.Errorf("Failed to cast to api.CheerEvent: %v", err) }
+		log.Printf("%s cheered x%d bits: %s", event.UserLogin, event.Bits, event.Message)
+		srv.labels.LatestCheer.Text = event.UserLogin
+		srv.labels.LatestCheer.C <- event.UserLogin
+
+		if err := os.WriteFile(
+			path.Join(DATA_PATH, "state", LABEL_LATEST_CHEER),
+			[]byte(event.UserLogin), 0640,
+		); err != nil {
+			return fmt.Errorf("Failed to write %s state: %v", LABEL_LATEST_CHEER, err)
+		}
+
+	case "channel.raid":
+		var event api.RaidEvent
+		err := json.Unmarshal(jsonData, &event)
+		if err != nil { return fmt.Errorf("Failed to cast to api.RaidEvent: %v", err) }
+		log.Printf("%s is now raiding with %d viewers!", event.FromUserLogin, event.Viewers)
+
+	case "channel.channel_points_custom_reward_redemption.add":
+		var event api.ChannelPointCustomRewardRedeemEvent
+		err := json.Unmarshal(jsonData, &event)
+		if err != nil { return fmt.Errorf("Failed to cast to api.ChannelPointCustomRewardRedeemEvent: %v", err) }
+		log.Printf(
+			"%s just redeemed %s for %d channel points.",
+			event.UserLogin,
+			event.Reward.Title,
+			event.Reward.Cost,
+		)
+
+	case "channel.shoutout.create":
+		var event api.ShoutoutCreate
+		err := json.Unmarshal(jsonData, &event)
+		if err != nil { return fmt.Errorf("Failed to cast to api.ShoutoutCreate: %v", err) }
+		log.Printf(
+			"%s gave a shoutout to %s.",
+			event.FromUserLogin,
+			event.ToUserLogin,
+		)
+
+	case "channel.chat.message":
+		var event api.ChatEvent
+		err := json.Unmarshal(jsonData, &event)
+		if err != nil { return fmt.Errorf("Failed to cast to api.ChatEvent: %v", err) }
+		if event.Cheer != nil { return nil }
+		log.Printf(
+			"[%s] %s: %s",
+			event.MessageID,
+			event.ChatterLogin,
+			event.Message.Text,
+		)
+
+	case "channel.chat.message_delete":
+		var event api.ChatDeleteEvent
+		err := json.Unmarshal(jsonData, &event)
+		if err != nil { return fmt.Errorf("Failed to cast to api.ChatDeleteEvent: %v", err) }
+		log.Printf(
+			"Message %s by %s deleted.",
+			event.MessageID,
+			event.TargetLogin,
+		)
+
+	}
+
+	return nil
+}
+
+func (srv *Service) subscribeToEvent(
+	subscriptionType string,
+	version string,
+	condition map[string]string,
+	sessionID string,
+) error {
+	type (
+		Transport struct {
+			Method string `json:"method"`
+			SessionID string `json:"session_id"`
+		}
+
+		Request struct {
+			Type string `json:"type"`
+			Version string `json:"version"`
+			Condition map[string]string `json:"condition"`
+			Transport Transport `json:"transport"`
+		}
+
+		ResponseData struct {
+			ID string `json:"id"`
+			Status string `json:"status"`
+			Type string `json:"type"`
+			Version string `json:"version"`
+			Condition map[string]string `json:"condition"`
+			CreatedAt string `json:"created_at"`
+			Transport Transport `json:"transport"`
+			Cost int `json:"cost"`
+		}
+		Response struct {
+			Data []ResponseData `json:"data"`
+			Total int `json:"total"`
+			TotalCost int `json:"total_cost"`
+			MaxTotalCost int `json:"max_total_cost"`
+		}
+	)
+
+	bodyBytes, err := json.Marshal(Request{
+		Type: subscriptionType,
+		Version: version,
+		Condition: condition,
+		Transport: Transport{
+			Method: "websocket",
+			SessionID: sessionID,
+		},
+	})
+	body := bytes.NewBuffer(bodyBytes)
+
+	client := http.DefaultClient
+	req, err := http.NewRequest(
+		"POST",
+		TWITCH_API_BASE + "/eventsub/subscriptions",
+		body,
+	)
+	if err != nil { return err }
+
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Client-Id", srv.clientID)
+	req.Header.Set("Authorization", "Bearer " + srv.oauthToken.AccessToken)
+
+	res, err := client.Do(req)
+	if err != nil { return err }
+
+	if res.StatusCode != http.StatusAccepted {
+		body, _ := io.ReadAll(res.Body)
+		return fmt.Errorf("%s: %s", res.Status, string(body))
+	}
+
+	return nil
+}
+
+func (srv *Service) subscribeToDefaultEvents() {
+	// channel.follow
+	if err := srv.subscribeToEvent(
+		"channel.follow", "2",
+		map[string]string{
+			"broadcaster_user_id": srv.channelID,
+			"moderator_user_id": srv.channelID,
+		},
+		srv.eventSubSession.ID,
+	); err != nil {
+		log.Printf("Failed to subscribe to channel.follow: %v", err)
+	}
+
+	// channel.subscribe
+	if err := srv.subscribeToEvent(
+		"channel.subscribe", "1",
+		map[string]string{ "broadcaster_user_id": srv.channelID },
+		srv.eventSubSession.ID,
+	); err != nil {
+		log.Printf("Failed to subscribe to channel.subscribe: %v", err)
+	}
+
+	// channel.cheer
+	if err := srv.subscribeToEvent(
+		"channel.cheer", "1",
+		map[string]string{ "broadcaster_user_id": srv.channelID },
+		srv.eventSubSession.ID,
+	); err != nil {
+		log.Printf("Failed to subscribe to channel.cheer: %v", err)
+	}
+
+	// channel.raid
+	if err := srv.subscribeToEvent(
+		"channel.raid", "1",
+		map[string]string{ "to_broadcaster_user_id": srv.channelID },
+		srv.eventSubSession.ID,
+	); err != nil {
+		log.Printf("Failed to subscribe to channel.raid: %v", err)
+	}
+
+	// channel.channel_points_custom_reward_redemption.add
+	if err := srv.subscribeToEvent(
+		"channel.channel_points_custom_reward_redemption.add", "1",
+		map[string]string{ "broadcaster_user_id": srv.channelID },
+		srv.eventSubSession.ID,
+	); err != nil {
+		log.Printf("Failed to subscribe to channel.channel_points_custom_reward_redemption.add: %v", err)
+	}
+
+	// channel.shoutout.create
+	if err := srv.subscribeToEvent(
+		"channel.shoutout.create", "1",
+		map[string]string{
+			"broadcaster_user_id": srv.channelID,
+			"moderator_user_id": srv.channelID,
+		},
+		srv.eventSubSession.ID,
+	); err != nil {
+		log.Printf("Failed to subscribe to channel.shoutout.create: %v", err)
+	}
+
+	// channel.chat.message
+	if err := srv.subscribeToEvent(
+		"channel.chat.message", "1",
+		map[string]string{
+			"broadcaster_user_id": srv.channelID,
+			"user_id": srv.channelID,
+		},
+		srv.eventSubSession.ID,
+	); err != nil {
+		log.Printf("Failed to subscribe to channel.chat.message: %v", err)
+	}
+
+	// channel.chat.message_delete
+	if err := srv.subscribeToEvent(
+		"channel.chat.message_delete", "1",
+		map[string]string{
+			"broadcaster_user_id": srv.channelID,
+			"user_id": srv.channelID,
+		},
+		srv.eventSubSession.ID,
+	); err != nil {
+		log.Printf("Failed to subscribe to channel.chat.message_delete: %v", err)
+	}
+}
+
+func (srv *Service) userIDsFromNames(usernames []string) ([]string, error) {
+	if len(usernames) == 0 { return []string{}, nil }
+
+	url := strings.Builder{}
+	url.WriteString(TWITCH_API_BASE)
+	url.WriteString("/users?login=")
+	url.WriteString(usernames[0])
+	for _, username := range usernames {
+		url.WriteString("&login=")
+		url.WriteString(username)
+	}
+
+	req, err := http.NewRequest("GET", url.String(), nil)
+	if err != nil { return nil, err }
+
+	req.Header.Set("Client-Id", srv.clientID)
+	req.Header.Set("Authorization", "Bearer " + srv.oauthToken.AccessToken)
+
+	res, err := http.DefaultClient.Do(req)
+	if err != nil { return nil, err }
+
+	if res.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(res.Body)
+		return nil, fmt.Errorf("%s: %s", res.Status, string(body))
+	}
+
+	type (
+		UserData struct {
+			ID string `json:"id"`
+			Login string `json:"login"`
+			DisplayName string `json:"display_name"`
+			Type string `json:"type"`
+			BroadcasterType string `json:"broadcaster_type"`
+			Description string `json:"description"`
+			ProfileImageURL string `json:"profile_image_url"`
+			OfflineImageURL string `json:"offline_image_url"`
+			ViewCount int `json:"view_count"`
+			Email string `json:"email"`
+			CreatedAt string `json:"created_at"`
+		}
+
+		Response struct {
+			Users []UserData `json:"data"`
+		}
+	)
+	data := Response{}
+	if err := json.NewDecoder(res.Body).Decode(&data); err != nil {
+		return nil, err
+	}
+
+	userIDs := []string{}
+	for _, user := range data.Users {
+		userIDs = append(userIDs, user.ID)
+	}
+
+	return userIDs, nil
+}

utils/dotenv/dotenv.go

@@ -0,0 +1,36 @@
+package dotenv
+
+import (
+	"os"
+	"strings"
+)
+
+func LoadEnv() (map[string]string, error) {
+	data, err := os.ReadFile(".env")
+	if err != nil { return nil, err }
+
+	dataString := string(data)
+	lines := strings.Split(dataString, "\n")
+
+	envars := map[string]string{}
+	for _, line := range lines {
+		splits := strings.Split(line, "=")
+		if len(splits) < 2 { continue }
+
+		key := splits[0]
+		value := splits[1]
+
+		if len(value) > 2 && value[0] == '"' && value[len(value) - 1] == '"' {
+			value = value[1:len(value)-1]
+		}
+
+		envars[key] = value
+	}
+
+	return envars, nil
+}
+
+func SafeGet(m map[string]string, k string) string {
+	value, _ := m[k]
+	return value
+}