diff --git a/README.md b/README.md
deleted file mode 100644
index 65b658a..0000000
--- a/README.md
+++ /dev/null
@@ -1,44 +0,0 @@
-# ari's stream tools
-
-handy, custom-built tools and utilities for my livestreams!
-
-## learning
-
-endpoints and views for "ari is learning!" streams.
-
-- **`GET /learning/sse`**: server-sent events:
-    - `title-update`: emits when the stream title is updated
-- **`POST /learning/title`**: update the current stream title
-- **`GET /learning/hello`**: intro view
-- **`GET /learning/brb`**: "be right back!" view
-- **`GET /learning/bye`**: stream ending view
-
-## music
-
-endpoints for a music status indicator.
-
-- **`GET /music/sse`**: server-sent events:
-    - `music`: emits when the currently playing track changes
-        - example: `{"title":"Untitled Track","artist":"Unknown Artist"}`
-    - `music-state`: emits when the playing state changes
-        - example: `{"playing":true}`
-- **`GET /music/artwork`**: serves the currently playing track artwork
-- **`GET /music`**: music status indicator
-
-## twitch
-
-endpoints for twitch events and labels.
-
-- **`GET /login`**: redirects to twitch login
-- **`GET /auth`**: twitch auth callback
-- **`GET /sse/*`**: server-sent events:
-    - **labels**: emits once at start, and every time an update occurs.
-        - `update` events contain a plain text username.
-        - `/sse/labels/latest-follower`
-        - `/sse/labels/latest-subscriber`
-        - `/sse/labels/latest-cheer`
-- **`GET /labels/<label>`**: serves a twitch label view.
-    - supported `label`s:
-        - `latest-follower`
-        - `latest-subscriber`
-        - `latest-cheer`
diff --git a/cmd/satellite/main.go b/cmd/satellite/main.go
index 1646bbb..a67212e 100644
--- a/cmd/satellite/main.go
+++ b/cmd/satellite/main.go
@@ -1,74 +1,19 @@
 package main
 
-import (
-	"context"
-	"fmt"
-	"log"
-	"net/http"
-	"os/signal"
-	"syscall"
-
-	"codeberg.org/arimelody/ari-stream-tools/config"
-	"codeberg.org/arimelody/ari-stream-tools/twitch"
-	"github.com/gin-gonic/gin"
-)
-
 /*
  * -=[ SATELLITE ]=-
  *
  * a high-uptime companion service for stream-tools, tracking information that
  * would be unwieldy to track all the time on an end device.
- *
+ *                                                                                  
  * current use-case: fetching and storing the latest twitch subscribers and
  * cheers.
- *
+ * 
  * should be able to utilise a bunch of existing code under /twitch, then just
  * poke out an API for querying the information. SSE and websockets are
  * unnecessary; stream-tools already has this. we just need a "kick-start" payload.
  */
 
 func main() {
-	failed := make(chan error)
-	ctx, cancel := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
-	defer cancel()
-
-	gin.SetMode(gin.ReleaseMode)
-
-	cfg, err := config.LoadConfig()
-	if err != nil { log.Fatalf("Failed to load config: %v", err) }
-
-	srv := gin.New()
-	// srv.Use(gin.Logger())
-	srv.SetTrustedProxies([]string{"127.0.0.1", "::1"})
-
-	twitchService, err := twitch.New(ctx, twitch.ServiceOptions{
-		Host: cfg.Host,
-		Port: cfg.Port,
-		ChannelName: cfg.Twitch.ChannelName,
-		ClientID: cfg.Twitch.ClientID,
-		ClientSecret: cfg.Twitch.ClientSecret,
-	})
-	if err != nil {
-		log.Printf("Failed to create Twitch service: %v", err)
-		srv.Group("twitch").Any("/*any", func(ctx *gin.Context) {
-			ctx.String(http.StatusServiceUnavailable, http.StatusText(http.StatusServiceUnavailable))
-		})
-	} else {
-		// satellite should work fine with the existing twitch service, though
-		// local stream-tools will need some kind of API override.
-		twitchService.BindRoutes(srv.Group("twitch"))
-		go twitchService.Run(ctx)
-	}
-
-	go func() {
-		log.Printf("Now serving at http://%s:%d\n", cfg.Host, cfg.Port)
-		failed <- srv.Run(fmt.Sprintf("%s:%d", cfg.Host, cfg.Port))
-	}()
-
-	select {
-	case err := <-failed:
-		log.Fatal(err)
-	case <-ctx.Done():
-		log.Print("Shutting down...")
-	}
+	// TODO: build satellite service
 }
diff --git a/cmd/stream-tools/main.go b/cmd/stream-tools/main.go
index 9b5ce96..3b8345f 100644
--- a/cmd/stream-tools/main.go
+++ b/cmd/stream-tools/main.go
@@ -4,12 +4,14 @@ import (
 	"context"
 	"fmt"
 	"log"
+	"math"
 	"net/http"
+	"os"
 	"os/signal"
+	"strconv"
 	"strings"
 	"syscall"
 
-	"codeberg.org/arimelody/ari-stream-tools/config"
 	"codeberg.org/arimelody/ari-stream-tools/learning"
 	"codeberg.org/arimelody/ari-stream-tools/music"
 	"codeberg.org/arimelody/ari-stream-tools/static"
@@ -17,6 +19,9 @@ import (
 	"github.com/gin-gonic/gin"
 )
 
+var DEFAULT_HOST string = "0.0.0.0"
+var DEFAULT_PORT int16 = 8080
+
 func main() {
 	failed := make(chan error)
 	ctx, cancel := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
@@ -24,8 +29,19 @@ func main() {
 
 	gin.SetMode(gin.ReleaseMode)
 
-	cfg, err := config.LoadConfig()
-	if err != nil { log.Fatalf("Failed to load config: %v", err) }
+	host := DEFAULT_HOST
+	port := DEFAULT_PORT
+
+	if len(os.Args) > 1 {
+		_port, err := strconv.Atoi(os.Args[1])
+		if _port > math.MaxUint16 {
+			log.Fatalf("Port must be between 1 and 65535: %d", _port)
+		}
+		port = int16(_port)
+		if err != nil {
+			log.Fatalf("Failed to parse port: %v", err)
+		}
+	}
 
 	srv := gin.New()
 	// srv.Use(gin.Logger())
@@ -54,13 +70,7 @@ func main() {
 		go musicService.Run(ctx)
 	}
 
-	twitchService, err := twitch.New(ctx, twitch.ServiceOptions{
-		Host: cfg.Host,
-		Port: cfg.Port,
-		ChannelName: cfg.Twitch.ChannelName,
-		ClientID: cfg.Twitch.ClientID,
-		ClientSecret: cfg.Twitch.ClientSecret,
-	})
+	twitchService, err := twitch.New(ctx, twitch.ServiceOptions{ Port: port })
 	if err != nil {
 		log.Printf("Failed to create Twitch service: %v", err)
 		srv.Group("twitch").Any("/*any", func(ctx *gin.Context) {
@@ -78,8 +88,8 @@ func main() {
 	})
 
 	go func() {
-		log.Printf("Now serving at http://%s:%d\n", cfg.Host, cfg.Port)
-		failed <- srv.Run(fmt.Sprintf("%s:%d", cfg.Host, cfg.Port))
+		log.Printf("Now serving at http://%s:%d\n", host, port)
+		failed <- srv.Run(fmt.Sprintf("%s:%d", host, port))
 	}()
 
 	select {
diff --git a/config/config.go b/config/config.go
index e4af5da..4178135 100644
--- a/config/config.go
+++ b/config/config.go
@@ -1,25 +1,8 @@
 package config
 
 import (
-	"fmt"
 	"os"
 	"path"
-
-	"github.com/pelletier/go-toml/v2"
-)
-
-type (
-	TwitchConfig struct {
-		ChannelName string `toml:"channel_name"`
-		ClientID string `toml:"client_id"`
-		ClientSecret string `toml:"client_secret"`
-	}
-
-	Config struct {
-		Host string `toml:"host"`
-		Port int16 `toml:"port"`
-		Twitch TwitchConfig `toml:"twitch"`
-	}
 )
 
 var CONFIG_DIR = func() string {
@@ -28,40 +11,3 @@ var CONFIG_DIR = func() string {
 	if err := os.MkdirAll(dir, 0750); err != nil { panic(err) }
 	return dir
 }()
-var configFilePath = path.Join(CONFIG_DIR, "config.toml")
-
-var DEFAULT_HOST string = "127.0.0.1"
-var DEFAULT_PORT int16 = 8080
-
-func DefaultConfig() *Config {
-	return &Config{
-		Host: DEFAULT_HOST,
-		Port: DEFAULT_PORT,
-		Twitch: TwitchConfig{
-			ChannelName: "",
-			ClientID: "",
-			ClientSecret: "",
-		},
-	}
-}
-
-func LoadConfig() (*Config, error) {
-	configFile, err := os.OpenFile(configFilePath, os.O_CREATE | os.O_RDWR, 0600)
-	if err != nil { return nil, fmt.Errorf("open %s: %v", configFilePath, err) }
-	defer configFile.Close()
-
-	config := DefaultConfig()
-	if stat, err := configFile.Stat(); err != nil {
-		return nil, fmt.Errorf("stat %s: %v", configFilePath, err)
-	} else if stat.Size() == 0 {
-		if err := toml.NewEncoder(configFile).Encode(config); err != nil {
-			return nil, fmt.Errorf("write %s: %v", configFilePath, err)
-		}
-		return config, nil
-	}
-
-	if err := toml.NewDecoder(configFile).Decode(config); err != nil {
-		return nil, fmt.Errorf("read %s: %v", configFilePath, err)
-	}
-	return config, nil
-}
diff --git a/twitch/oauth/oauth.go b/twitch/oauth/oauth.go
new file mode 100644
index 0000000..af1234e
--- /dev/null
+++ b/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
+}
diff --git a/twitch/public/labels.js b/twitch/public/labels.js
index d762f21..07bb8e1 100644
--- a/twitch/public/labels.js
+++ b/twitch/public/labels.js
@@ -1,6 +1,6 @@
 const labelEl = document.getElementById("label");
 
-const label = location.pathname.split("/twitch/labels/")[1];
+const selectedLabel = new URLSearchParams(location.search).get("l");
 const labelLatestFollower   = "latest-follower"
 const labelLatestSubscriber = "latest-subscriber"
 const labelLatestCheer      = "latest-cheer"
@@ -11,11 +11,14 @@ const allowedLabels = [
 ]
 
 /**
- * @param {string} label
+ * @param {string} selectedLabel
  */
 async function sync() {
-    if (label == null) {
-        const exampleUrl = `${location.protocol}//${location.host}/twitch/labels/${labelLatestFollower}`;
+    if (selectedLabel == null) {
+        const exampleUrl = 
+            location.pathname +
+            "?l=" +
+            labelLatestFollower;
 
         labelEl.innerHTML =
             "Needs label to listen to, " +
@@ -26,7 +29,7 @@ async function sync() {
 
     let eventSource;
     try {
-        eventSource = new EventSource("/twitch/sse/" + label);
+        eventSource = new EventSource("/twitch/sse?l=" + selectedLabel);
     } catch (err) {
         console.error("Failed to connect to event source", err);
         return;
@@ -43,7 +46,7 @@ async function sync() {
     });
 
     eventSource.addEventListener("update", event => {
-        console.log(`[${label}] ${event.data}`);
+        console.log(event.data);
         labelEl.innerText = event.data;
     });
 
diff --git a/twitch/twitch.go b/twitch/twitch.go
index 10c2d59..25080d0 100644
--- a/twitch/twitch.go
+++ b/twitch/twitch.go
@@ -40,16 +40,16 @@ type (
 	}
 
 	ServiceOptions struct {
-		Host string
 		Port int16
+	}
 
-		ChannelName string
-		ClientID string
-		ClientSecret string
+	serviceConfig struct {
+		ChannelName string `json:"channel_name"`
+		ClientID string `json:"client_id"`
+		ClientSecret string `json:"client_secret"`
 	}
 
 	Service struct {
-		host string
 		port int16
 
 		channelName string
@@ -85,9 +85,30 @@ func New(ctx context.Context, opts ServiceOptions) (*Service, error) {
 	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) }
 
-	if len(opts.ChannelName) == 0 { return nil, errors.New("config: channel_name cannot be empty") }
-	if len(opts.ClientID) == 0 { return nil, errors.New("config: client_id cannot be empty") }
-	if len(opts.ClientSecret) == 0 { return nil, errors.New("config: client_secret cannot be empty") }
+	config := serviceConfig{}
+	if configFile, err := os.OpenFile(CONFIG_FILEPATH, os.O_CREATE | os.O_RDWR, 0600); err != nil {
+		return nil, fmt.Errorf("open %s: %v", CONFIG_FILEPATH, err)
+	} else {
+		defer configFile.Close()
+
+		stat, err := configFile.Stat()
+		if err != nil { return nil, fmt.Errorf("stat %s: %v", CONFIG_FILEPATH, err) }
+
+		if stat.Size() == 0 {
+			enc := json.NewEncoder(configFile)
+			enc.SetIndent("", "\t")
+			if err := enc.Encode(&config); err != nil {
+				return nil, fmt.Errorf("write %s: %v", CONFIG_FILEPATH, err)
+			}
+			return nil, fmt.Errorf("Config file is empty: %s", CONFIG_FILEPATH)
+		} else if err := json.NewDecoder(configFile).Decode(&config); err != nil {
+			return nil, fmt.Errorf("read %s: %v", CONFIG_FILEPATH, err)
+		}
+	}
+
+	if len(config.ChannelName) == 0 { return nil, errors.New("config: channel_name cannot be empty") }
+	if len(config.ClientID) == 0 { return nil, errors.New("config: client_id cannot be empty") }
+	if len(config.ClientSecret) == 0 { return nil, errors.New("config: client_secret cannot be empty") }
 
 	latestFollowerC := make(chan string)
 	latestFollowerBroadcast := broadcast.NewBroadcastChannel(
@@ -100,7 +121,6 @@ func New(ctx context.Context, opts ServiceOptions) (*Service, error) {
 		ctx, latestCheerC)
 
 	srv := &Service{
-		host: opts.Host,
 		port: opts.Port,
 		labels: &twitchLabels{
 			LatestFollower: &twitchLabel{
@@ -116,12 +136,12 @@ func New(ctx context.Context, opts ServiceOptions) (*Service, error) {
 				Broadcast: latestCheerBroadcast,
 			},
 		},
-		channelName: opts.ChannelName,
-		clientID: opts.ClientID,
-		clientSecret: opts.ClientSecret,
+		channelName: config.ChannelName,
+		clientID: config.ClientID,
+		clientSecret: config.ClientSecret,
 		oauthConfig: &oauth2.Config{
-			ClientID: opts.ClientID,
-			ClientSecret: opts.ClientSecret,
+			ClientID: config.ClientID,
+			ClientSecret: config.ClientSecret,
 			Endpoint: twitch.Endpoint,
 			Scopes: []string{
 				"moderator:read:followers",
@@ -136,7 +156,7 @@ func New(ctx context.Context, opts ServiceOptions) (*Service, error) {
 				"channel:read:hype_train",
 				"moderator:read:shoutouts",
 			},
-			RedirectURL: fmt.Sprintf("http://%s:%d/twitch/auth", opts.Host, opts.Port),
+			RedirectURL: fmt.Sprintf("http://localhost:%d/twitch/auth", opts.Port),
 		},
 	}
 
@@ -203,13 +223,13 @@ func (srv *Service) BindRoutes(group *gin.RouterGroup) {
 		go srv.start(ctx)
 	})
 
-	group.GET("/sse/:label", func(ctx *gin.Context) {
+	group.GET("/sse", func(ctx *gin.Context) {
 		ctx.Header("connection", "keep-alive")
 
-		labelParam := ctx.Param("label")
+		listeningTo := ctx.Query("l")
 
 		var label *twitchLabel
-		switch labelParam {
+		switch listeningTo {
 		case LABEL_LATEST_FOLLOWER:
 			label = srv.labels.LatestFollower
 		case LABEL_LATEST_SUBSCRIBER:
@@ -217,7 +237,7 @@ func (srv *Service) BindRoutes(group *gin.RouterGroup) {
 		case LABEL_LATEST_CHEER:
 			label = srv.labels.LatestCheer
 		default:
-			ctx.String(http.StatusBadRequest, "Unknown label %s", labelParam)
+			ctx.String(http.StatusBadRequest, "Unknown label %s", listeningTo)
 			return
 		}
 
@@ -237,24 +257,14 @@ func (srv *Service) BindRoutes(group *gin.RouterGroup) {
 		})
 	})
 
-	group.GET("/labels/:label", func(ctx *gin.Context) {
-		labelParam := ctx.Param("label")
-		switch labelParam {
-		case LABEL_LATEST_FOLLOWER:
-		case LABEL_LATEST_SUBSCRIBER:
-		case LABEL_LATEST_CHEER:
-		default:
-			http.NotFound(ctx.Writer, ctx.Request)
-			return
-		}
-
+	group.GET("/label", 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.oauthToken.Valid() {
-		log.Printf("Log in with Twitch: http://%s:%d/twitch/login", srv.host, srv.port)
+		log.Printf("Log in with Twitch: http://localhost:%d/twitch/login", srv.port)
 	} else {
 		if err := srv.start(ctx); err != nil {
 			log.Printf("Failed to start Twitch service: %v", err)