fix Dockerfile

Reviewed-on: #42

.gitea/workflows/build-and-push.yaml

@@ -23,14 +23,14 @@ jobs:
 
       # Set up Docker Buildx for building the image
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
+        uses: docker/setup-buildx-action@v4
         with:
           driver: remote
           endpoint: 'tcp://buildkitd:1234'
 
       # Log in to the Gitea container registry
       - name: Log in to Gitea Container Registry
-        uses: docker/login-action@v3
+        uses: docker/login-action@v4
         with:
           registry: git.dubyatp.xyz
           username: williamp
@@ -38,7 +38,7 @@ jobs:
 
       # Build and push the Docker image
       - name: Build and Push Docker Image
-        uses: docker/build-push-action@v6
+        uses: docker/build-push-action@v7
         with:
           context: .                    # Build context (current directory)
           file: ./Dockerfile            # Path to Dockerfile
@@ -75,8 +75,13 @@ jobs:
           git config --local user.signingkey ~/.ssh/id_ed25519
           git config --local gpg.format ssh
           git config --local commit.gpgsign true
-          git commit -a -m "yt-dlp-bot: deploy update to ${{ needs.build-and-push.outputs.sha_short }}"
+          
-
+          if [ -n "$(git status --porcelain)" ]; then
+            git commit -a -m "yt-dlp-bot: deploy update to ${{ needs.build-and-push.outputs.sha_short }}"
+          else
+            echo "No changes to commit, skipping..."
+          fi
+          exit 0
       - name: Push changes
         uses: ad-m/github-push-action@v1.0.0
         with:

.gitea/workflows/build-only.yaml

@@ -0,0 +1,35 @@
+name: Build only (for PRs)
+
+on:
+  pull_request: 
+
+jobs:
+  build-only:
+    runs-on: ubuntu-latest  # Use a runner with Docker support
+    container: ghcr.io/catthehacker/ubuntu:act-latest  # Image with Docker pre-installed
+    outputs:
+      sha_short: ${{ steps.vars.outputs.sha_short }}
+    steps:
+      # Checkout the repository code
+      - name: Checkout repository
+        uses: actions/checkout@v6
+
+      - name: Set outputs
+        id: vars
+        run: |
+          echo "sha_short=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
+
+      # Set up Docker Buildx for building the image
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+        with:
+          driver: remote
+          endpoint: 'tcp://buildkitd:1234'
+
+      # Build the Docker image
+      - name: Build Docker Image
+        uses: docker/build-push-action@v6
+        with:
+          context: .                    # Build context (current directory)
+          file: ./Dockerfile            # Path to Dockerfile
+          platforms: "linux/amd64,linux/arm64"

Dockerfile

@@ -1,6 +1,91 @@
-FROM python:3.14.2-alpine3.22
+# Portions of this Dockerfile are sourced from GPLv3 licensed `yt-dlp slim` by Henrique Almeida (https://github.com/h3nc4/yt-dlp-slim)
-COPY ./app /app
+# Derivations to this Dockerfile in this repository following March 3, 2026 should be considered licensed under this project's MIT license (see ../LICENSE) unless otherwise stated
-WORKDIR /app
+
-RUN apk add ffmpeg deno
+########################################
-RUN pip install -r requirements.txt
+# Versions
-CMD ["python", "/app/main.py"]
+ARG YT_DLP_VERSION="2026.03.03"
+
+################################################################################
+# Deno builder stage
+FROM denoland/deno:bin-2.6.6@sha256:9f18d20207f2699595ea26d14e0b7e123cd0cd01100a577bc11f8ca5906c2d81 AS deno-builder
+
+################################################################################
+# YT-DLP builder stage
+FROM alpine:3.23@sha256:25109184c71bdad752c8312a8623239686a9a2071e8825f20acb8f2198c3f659 AS yt-dlp-builder
+ARG YT_DLP_VERSION
+ARG TARGETARCH
+
+RUN mkdir -p /rootfs/target /rootfs/tmp /rootfs/bin
+
+ADD "https://github.com/yt-dlp/yt-dlp/releases/download/${YT_DLP_VERSION}/SHA2-256SUMS" /SHA2-256SUMS
+ADD "https://github.com/yt-dlp/yt-dlp/releases/download/${YT_DLP_VERSION}/SHA2-256SUMS.sig" /SHA2-256SUMS.sig
+ADD "https://keyserver.ubuntu.com/pks/lookup?op=get&search=0xAC0CBBE6848D6A873464AF4E57CF65933B5A7581" "/yt-dlp_pubkey.asc"
+
+RUN apk add --no-cache gnupg && \
+  gpg --import /yt-dlp_pubkey.asc && \
+  gpg --verify /SHA2-256SUMS.sig /SHA2-256SUMS
+
+RUN case "$TARGETARCH" in \
+    amd64) YT_DLP_FILE="yt-dlp_linux" ;; \
+    arm64) YT_DLP_FILE="yt-dlp_linux_aarch64" ;; \
+    *) echo "Unsupported architecture: $TARGETARCH" && exit 1 ;; \
+  esac && \
+  wget -qO "/${YT_DLP_FILE}" "https://github.com/yt-dlp/yt-dlp/releases/download/${YT_DLP_VERSION}/${YT_DLP_FILE}" && \
+  grep " ${YT_DLP_FILE}$" /SHA2-256SUMS | sha256sum -c - && \
+  mv "/${YT_DLP_FILE}" /rootfs/bin/yt-dlp && \
+  chmod 755 /rootfs/bin/yt-dlp && \
+  chmod 1777 /rootfs/tmp
+
+################################################################################
+# FFmpeg builder stage
+FROM debian:13-slim@sha256:1d3c811171a08a5adaa4a163fbafd96b61b87aa871bbc7aa15431ac275d3d430 AS ffmpeg-builder
+RUN apt-get update && \
+  apt-get install -y --no-install-recommends ffmpeg
+COPY --from=yt-dlp-builder /rootfs/bin/yt-dlp /yt-dlp
+RUN mkdir -p /rootfs/bin && \
+  cp /usr/bin/ffmpeg /usr/bin/ffprobe /rootfs/bin/ && \
+  { ldd /usr/bin/ffmpeg; ldd /yt-dlp; } 2>/dev/null | \
+  grep -o '/[^ ]*' | sort -u | \
+  xargs -I '{}' cp --parents '{}' /rootfs && \
+  LIBDIR=$(dirname "$(find /rootfs -name 'libc.so.6' | head -1)") && \
+  for stub in libutil.so.1 libdl.so.2 libpthread.so.0 librt.so.1; do \
+    [ -f "${LIBDIR}/${stub}" ] || ln -sf libc.so.6 "${LIBDIR}/${stub}"; \
+  done
+
+################################################################################
+# App builder stage
+FROM golang:1.25.8-trixie@sha256:bc16125656839ffe56154c675f7a9662bec2ef7d4060177239914e7c6d2fd8a8 AS app-builder
+
+COPY app/ /opt/app
+WORKDIR /opt/app
+
+RUN go get && go build -o out/yt-dlp-bot
+
+################################################################################
+# Final squashed image
+FROM scratch AS final
+
+# Copy deno, yt-dlp, and ffmpeg binaries
+COPY --from=deno-builder /deno /bin/deno
+COPY --from=yt-dlp-builder /rootfs /
+COPY --from=ffmpeg-builder /rootfs/ /
+
+# Copy yt-dlp-bot app binary
+COPY --from=app-builder /opt/app/out/yt-dlp-bot /bin/
+
+# Copy SSL CA's (needed for Discord)
+COPY --from=app-builder /etc/ssl/certs /etc/ssl/certs
+
+WORKDIR /target
+ENV XDG_CACHE_HOME=/tmp/.cache
+
+ENV YTDLP_BIN=/bin/yt-dlp
+
+ENTRYPOINT ["/bin/yt-dlp-bot"]
+
+LABEL org.opencontainers.image.title="yt-dlp bot" \
+  org.opencontainers.image.description="A totally overengineered Discord bot to locally download YouTube videos for private use" \
+  org.opencontainers.image.authors="William Peebles <me@williamtpeebles.com>" \
+  org.opencontainers.image.vendor="William Peebles" \
+  org.opencontainers.image.licenses="MIT" \
+  org.opencontainers.image.source="https://git.dubyatp.xyz/williamp/yt-dlp-bot"

app/download.go

@@ -0,0 +1,109 @@
+package main
+
+import (
+	"fmt"
+	"log"
+
+	"github.com/bwmarrin/discordgo"
+)
+
+// startAsyncDownload initiates a download in a goroutine and handles progress updates
+func startAsyncDownload(s *discordgo.Session, i *discordgo.InteractionCreate, requester, url, videoFormatID, videoFormatName, audioFormatID, audioFormatName, outputDir, tempDir string) {
+	progressChan := make(chan ProgressUpdate, 1)
+	resultChan := make(chan DownloadResult, 1)
+
+	// Start download in goroutine
+	go func() {
+		defer close(resultChan)
+		defer func() {
+			if r := recover(); r != nil {
+				// Handle panic from DownloadVideo
+				resultChan <- DownloadResult{
+					Success: false,
+					Message: fmt.Sprintf("❌ **Download Failed**: %v", r),
+					URL:     url,
+					Format:  fmt.Sprintf("video: %s, audio: %s", videoFormatID, audioFormatID),
+					Error:   fmt.Errorf("%v", r),
+				}
+			}
+		}()
+
+		// Call DownloadVideo (it panics on error instead of returning error)
+		DownloadVideo(outputDir, tempDir, url, DownloadOptions{
+			EmbedThumbnail:   true,
+			IncludeSubtitles: true,
+			VideoFormatID:    videoFormatID,
+			AudioFormatID:    audioFormatID,
+		}, progressChan)
+
+		// If we reach here, download was successful
+		resultChan <- DownloadResult{
+			Success: true,
+			Message: "✅ **Successfully Downloaded**",
+			URL:     url,
+			Format:  fmt.Sprintf("video: %s, audio: %s", videoFormatID, audioFormatID),
+			Error:   nil,
+		}
+	}()
+
+	// Handle progress and results asynchronously
+	go func() {
+		_, err := s.InteractionResponseEdit(i.Interaction, &discordgo.WebhookEdit{
+			Content: ptr(fmt.Sprintf("%s **Starting Download**", loading_emoji)),
+		})
+		if err != nil {
+			log.Printf("Error updating interaction: %v", err)
+		}
+
+		for {
+			select {
+			case prog, ok := <-progressChan:
+				if !ok {
+					progressChan = nil
+					continue
+				}
+
+				var content string
+				if prog.Phase == "post-processing" {
+					content = fmt.Sprintf("%s **Post Processing**", loading_emoji)
+				} else {
+					var progressStr string
+					if prog.DownloadedBytes > 0 {
+						progressStr = formatBytes(prog.DownloadedBytes) + " downloaded"
+					} else {
+						progressStr = "starting..."
+					}
+					content = fmt.Sprintf("%s **Downloading Video**: %s", loading_emoji, progressStr)
+				}
+
+				_, err := s.InteractionResponseEdit(i.Interaction, &discordgo.WebhookEdit{
+					Content: ptr(content),
+				})
+				if err != nil {
+					log.Printf("Error updating progress: %v", err)
+				}
+
+			case result := <-resultChan:
+				if result.Success {
+					_, err = s.InteractionResponseEdit(i.Interaction, &discordgo.WebhookEdit{
+						Content: ptr("✅ **Successfully Downloaded**"),
+					})
+					_, err = s.FollowupMessageCreate(i.Interaction, false, &discordgo.WebhookParams{
+						Content: fmt.Sprintf("## Video Downloaded \n**URL**: %s \n**Quality**: %s + %s \n**Requested By**: <@%s> \n", result.URL, videoFormatName, audioFormatName, requester),
+					})
+					if err != nil {
+						log.Printf("Error updating interaction: %v", err)
+					}
+				} else {
+					_, err = s.InteractionResponseEdit(i.Interaction, &discordgo.WebhookEdit{
+						Content: ptr("❌ **Download Failed**: " + result.Message),
+					})
+					if err != nil {
+						log.Printf("Error updating interaction: %v", err)
+					}
+				}
+				return
+			}
+		}
+	}()
+}

app/go.mod

@@ -2,12 +2,19 @@ module git.dubyatp.xyz/williamp/yt-dlp-bot
 
 go 1.25.2
 
+//replace github.com/lrstanley/go-ytdlp => /home/williamp/go-ytdlp
+
+replace github.com/lrstanley/go-ytdlp => github.com/dubyatp/go-ytdlp v0.0.0-20260213041320-010f95f0f1d3
+
+require (
+	github.com/bwmarrin/discordgo v0.29.0
+	github.com/lrstanley/go-ytdlp v1.2.7
+)
+
 require (
 	github.com/ProtonMail/go-crypto v1.3.0 // indirect
-	github.com/bwmarrin/discordgo v0.29.0 // indirect
 	github.com/cloudflare/circl v1.6.1 // indirect
 	github.com/gorilla/websocket v1.4.2 // indirect
-	github.com/lrstanley/go-ytdlp v1.2.7 // indirect
 	github.com/ulikunitz/xz v0.5.13 // indirect
 	golang.org/x/crypto v0.41.0 // indirect
 	golang.org/x/sys v0.35.0 // indirect

app/go.sum

@@ -4,10 +4,16 @@ github.com/bwmarrin/discordgo v0.29.0 h1:FmWeXFaKUwrcL3Cx65c20bTRW+vOb6k8AnaP+Eg
 github.com/bwmarrin/discordgo v0.29.0/go.mod h1:NJZpH+1AfhIcyQsPeuBKsUtYrRnjkyu0kIVMCHkZtRY=
 github.com/cloudflare/circl v1.6.1 h1:zqIqSPIndyBh1bjLVVDHMPpVKqp8Su/V+6MeDzzQBQ0=
 github.com/cloudflare/circl v1.6.1/go.mod h1:uddAzsPgqdMAYatqJ0lsjX1oECcQLIlRpzZh3pJrofs=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/dubyatp/go-ytdlp v0.0.0-20260213041320-010f95f0f1d3 h1:tGzvzV6fSzybhIpwU+wjvjOSq8RBNtHENm+G03E+mgo=
+github.com/dubyatp/go-ytdlp v0.0.0-20260213041320-010f95f0f1d3/go.mod h1:38IL64XM6gULrWtKTiR0+TTNCVbxesNSbTyaFG2CGTI=
 github.com/gorilla/websocket v1.4.2 h1:+/TMaTYc4QFitKJxsQ7Yye35DkWvkdLcvGKqM+x0Ufc=
 github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
-github.com/lrstanley/go-ytdlp v1.2.7 h1:YNDvKkd0OCJSZLZePZvJwcirBCfL8Yw3eCwrTCE5w7Q=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
-github.com/lrstanley/go-ytdlp v1.2.7/go.mod h1:38IL64XM6gULrWtKTiR0+TTNCVbxesNSbTyaFG2CGTI=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 github.com/ulikunitz/xz v0.5.13 h1:ar98gWrjf4H1ev05fYP/o29PDZw9DrI3niHtnEqyuXA=
 github.com/ulikunitz/xz v0.5.13/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14=
 golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
@@ -20,3 +26,5 @@ golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

app/main.go

@@ -6,165 +6,25 @@ import (
 	"os"
 	"os/signal"
 	"sort"
-	"sync"
 	"syscall"
 	"time"
 
 	"github.com/bwmarrin/discordgo"
 )
 
-// InteractionState holds the state for a specific interaction
-type InteractionState struct {
-	URL           string
-	FormatOptions *FormatOptions
-	VideoFormatID string
-	AudioFormatID string
-}
-
-// DownloadResult represents the result of an async download operation
-type DownloadResult struct {
-	Success bool
-	Message string
-	URL     string
-	Format  string
-	Error   error
-}
-
-// startAsyncDownload initiates a download in a goroutine and handles progress updates
-func startAsyncDownload(s *discordgo.Session, i *discordgo.InteractionCreate, url, videoFormatID, audioFormatID, outputDir string) {
-	progressChan := make(chan ProgressUpdate, 1)
-	resultChan := make(chan DownloadResult, 1)
-
-	// Start download in goroutine
-	go func() {
-		defer close(resultChan)
-		defer func() {
-			if r := recover(); r != nil {
-				// Handle panic from downloadVideo
-				resultChan <- DownloadResult{
-					Success: false,
-					Message: fmt.Sprintf("Download failed: %v", r),
-					URL:     url,
-					Format:  fmt.Sprintf("video: %s, audio: %s", videoFormatID, audioFormatID),
-					Error:   fmt.Errorf("%v", r),
-				}
-			}
-		}()
-
-		// Call downloadVideo (it panics on error instead of returning error)
-		downloadVideo(outputDir, url, DownloadOptions{
-			EmbedThumbnail:   true,
-			IncludeSubtitles: true,
-			VideoFormatID:    videoFormatID,
-			AudioFormatID:    audioFormatID,
-		}, progressChan)
-
-		// If we reach here, download was successful
-		resultChan <- DownloadResult{
-			Success: true,
-			Message: "Video Downloaded Successfully!",
-			URL:     url,
-			Format:  fmt.Sprintf("video: %s, audio: %s", videoFormatID, audioFormatID),
-			Error:   nil,
-		}
-	}()
-
-	// Handle progress and results asynchronously
-	go func() {
-		// First update the original ephemeral message with "Processing..."
-		_, err := s.InteractionResponseEdit(i.Interaction, &discordgo.WebhookEdit{
-			Content: ptr(fmt.Sprintf("🔄 Processing download...\nURL: %s\nVideo: %s\nAudio: %s", url, videoFormatID, audioFormatID)),
-		})
-		if err != nil {
-			log.Printf("Error updating interaction: %v", err)
-		}
-
-		for {
-			select {
-			case prog, ok := <-progressChan:
-				if !ok {
-					progressChan = nil
-					continue
-				}
-				// Update message w/ phase and real time progress
-				phaseEmoji := "⏬"
-				if prog.Phase == "post-processing" {
-					phaseEmoji = "⚙️"
-				}
-				content := fmt.Sprintf("%s %s\n%s @ %s [eta: %s]\n📄 %s",
-					phaseEmoji,
-					prog.Phase,
-					prog.Status,
-					prog.Percent,
-					prog.ETA,
-					prog.Filename)
-				_, err := s.InteractionResponseEdit(i.Interaction, &discordgo.WebhookEdit{
-					Content: ptr(content),
-				})
-				if err != nil {
-					log.Printf("Error updating progress: %v", err)
-				}
-			case result := <-resultChan:
-				// Handle completion
-				if result.Success {
-					_, err = s.FollowupMessageCreate(i.Interaction, false, &discordgo.WebhookParams{
-						Content: "📥 Video downloaded: " + result.URL,
-					})
-					if err != nil {
-						log.Printf("Error updating interaction: %v", err)
-					}
-				} else {
-					_, err = s.InteractionResponseEdit(i.Interaction, &discordgo.WebhookEdit{
-						Content: ptr("❌ Download failed: " + result.Message),
-					})
-					if err != nil {
-						log.Printf("Error updating interaction: %v", err)
-					}
-				}
-				return
-			}
-		}
-	}()
-}
-
-// Helper function to create string pointer
-func ptr(s string) *string {
-	return &s
-}
-
-// Global state management
-var (
-	interactionStates      = make(map[string]*InteractionState)
-	interactionStatesMutex = sync.RWMutex{}
-)
-
-func getInteractionState(token string) *InteractionState {
-	interactionStatesMutex.RLock()
-	defer interactionStatesMutex.RUnlock()
-	return interactionStates[token]
-}
-
-func setInteractionState(token string, state *InteractionState) {
-	interactionStatesMutex.Lock()
-	defer interactionStatesMutex.Unlock()
-	interactionStates[token] = state
-}
-
-func deleteInteractionState(token string) {
-	interactionStatesMutex.Lock()
-	defer interactionStatesMutex.Unlock()
-	delete(interactionStates, token)
-}
-
 func main() {
-
 	out_dir := os.Getenv("OUT_PATH")
+	temp_dir := os.Getenv("TEMP_PATH")
 	bot_token := os.Getenv("DISCORD_TOKEN")
 
 	if out_dir == "" {
 		panic("No output dir specified")
 	}
 
+	if temp_dir == "" {
+		panic("No temp dir specified")
+	}
+
 	s, err := discordgo.New("Bot " + bot_token)
 	if err != nil {
 		log.Fatalf("Invalid bot parameters: %v", err)
@@ -232,6 +92,9 @@ func main() {
 				return
 			}
 
+			// Get requester user ID
+			state.Requester = i.User.ID
+
 			// Get selected video format
 			selectedValues := i.MessageComponentData().Values
 			if len(selectedValues) == 0 {
@@ -245,8 +108,19 @@ func main() {
 				return
 			}
 
-			// Store selected video format ID
+			// Store selected video format ID and name
 			state.VideoFormatID = selectedValues[0]
+			for _, vOpt := range state.FormatOptions.VideoOptions {
+				if vOpt.FormatID == selectedValues[0] {
+					label := fmt.Sprintf("%s (%s", vOpt.Resolution, vOpt.Ext)
+					if vOpt.TBR != nil {
+						label += fmt.Sprintf(", %.0fkbps", *vOpt.TBR)
+					}
+					label += ")"
+					state.VideoFormatName = label
+					break
+				}
+			}
 			setInteractionState(i.Interaction.Token, state)
 
 			// Build audio format options
@@ -363,7 +237,7 @@ func main() {
 			}
 			if state == nil {
 				s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
-					Type: discordgo.InteractionResponseChannelMessageWithSource,
+					Type: discordgo.InteractionResponseUpdateMessage,
 					Data: &discordgo.InteractionResponseData{
 						Content: "Error: No video URL found. Please start over with /download.",
 						Flags:   discordgo.MessageFlagsEphemeral,
@@ -379,20 +253,32 @@ func main() {
 				audioFormatID = selectedValues[0]
 			}
 
-			// Store selected audio format ID
+			// Store selected audio format ID and name
 			state.AudioFormatID = audioFormatID
+			for _, aOpt := range state.FormatOptions.AudioOptions {
+				if aOpt.FormatID == audioFormatID {
+					label := aOpt.Format
+					if aOpt.Language != nil {
+						label += fmt.Sprintf(" [%s]", *aOpt.Language)
+					}
+					if aOpt.TBR != nil {
+						label += fmt.Sprintf(" (%.0fkbps)", *aOpt.TBR)
+					}
+					state.AudioFormatName = label
+					break
+				}
+			}
 
 			response := ""
 			if state.URL != "" {
 				// Respond immediately to prevent timeout
-				response = fmt.Sprintf("🚀 Starting download...\nURL: %s\nVideo: %s\nAudio: %s\n\nYou'll receive an update when the download completes!",
+				response = fmt.Sprintf("%s **Starting download**", loading_emoji)
-					state.URL, state.VideoFormatID, state.AudioFormatID)
 
 				// Start async download after responding
 				go func() {
 					// Small delay to ensure response is sent first
 					time.Sleep(100 * time.Millisecond)
-					startAsyncDownload(s, i, state.URL, state.VideoFormatID, state.AudioFormatID, out_dir)
+					startAsyncDownload(s, i, state.Requester, state.URL, state.VideoFormatID, state.VideoFormatName, state.AudioFormatID, state.AudioFormatName, out_dir, temp_dir)
 				}()
 
 				// Clean up state after starting download
@@ -401,7 +287,7 @@ func main() {
 				response = "I don't see a video here :("
 			}
 			err := s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
-				Type: discordgo.InteractionResponseChannelMessageWithSource,
+				Type: discordgo.InteractionResponseUpdateMessage,
 				Data: &discordgo.InteractionResponseData{
 					Content: response,
 					Flags:   discordgo.MessageFlagsEphemeral,
@@ -439,7 +325,7 @@ func main() {
 			err := s.InteractionRespond(i.Interaction, &discordgo.InteractionResponse{
 				Type: discordgo.InteractionResponseChannelMessageWithSource,
 				Data: &discordgo.InteractionResponseData{
-					Content: "🔍 Fetching available formats...",
+					Content: fmt.Sprintf("%s Fetching available formats...", loading_emoji),
 					Flags:   discordgo.MessageFlagsEphemeral,
 				},
 			})
@@ -631,8 +517,4 @@ func main() {
 	<-sc
 
 	s.Close()
-
-	//var url string = "https://www.youtube.com/watch?v=WpBWSFF03eI"
-
-	//downloadVideo(out_dir, url, DownloadOptions{EmbedThumbnail: true, IncludeSubtitles: true})
 }

app/misc.go

@@ -0,0 +1,26 @@
+package main
+
+import (
+	"fmt"
+	"os"
+)
+
+var loading_emoji = os.Getenv("LOADING_EMOJI")
+
+// Helper function to create string pointer
+func ptr(s string) *string {
+	return &s
+}
+
+func formatBytes(b int) string {
+	switch {
+	case b >= 1<<30:
+		return fmt.Sprintf("%.1f GB", float64(b)/float64(1<<30))
+	case b >= 1<<20:
+		return fmt.Sprintf("%.1f MB", float64(b)/float64(1<<20))
+	case b >= 1<<10:
+		return fmt.Sprintf("%.1f KB", float64(b)/float64(1<<10))
+	default:
+		return fmt.Sprintf("%d B", b)
+	}
+}

app/state.go

@@ -0,0 +1,27 @@
+package main
+
+import "sync"
+
+// Global state management
+var (
+	interactionStates      = make(map[string]*InteractionState)
+	interactionStatesMutex = sync.RWMutex{}
+)
+
+func getInteractionState(token string) *InteractionState {
+	interactionStatesMutex.RLock()
+	defer interactionStatesMutex.RUnlock()
+	return interactionStates[token]
+}
+
+func setInteractionState(token string, state *InteractionState) {
+	interactionStatesMutex.Lock()
+	defer interactionStatesMutex.Unlock()
+	interactionStates[token] = state
+}
+
+func deleteInteractionState(token string) {
+	interactionStatesMutex.Lock()
+	defer interactionStatesMutex.Unlock()
+	delete(interactionStates, token)
+}

app/types.go

@@ -0,0 +1,55 @@
+package main
+
+type DownloadOptions struct {
+	EmbedThumbnail   bool
+	IncludeSubtitles bool
+	VideoFormatID    string
+	AudioFormatID    string
+}
+
+type VideoOption struct {
+	Height     *int     `json:"height,omitempty"`
+	Resolution string   `json:"resolution,omitempty"`
+	FormatID   string   `json:"format_id"`
+	Ext        string   `json:"ext"`
+	TBR        *float64 `json:"tbr,omitempty"`
+}
+
+type AudioOption struct {
+	Format   string   `json:"format"`
+	FormatID string   `json:"format_id"`
+	Ext      string   `json:"ext"`
+	TBR      *float64 `json:"tbr,omitempty"`
+	Language *string  `json:"language,omitempty"`
+}
+
+type FormatOptions struct {
+	VideoOptions []VideoOption `json:"video_options"`
+	AudioOptions []AudioOption `json:"audio_options"`
+}
+
+type ProgressUpdate struct {
+	Phase           string
+	DownloadedBytes int
+	Filename        string
+}
+
+// InteractionState holds the state for a specific interaction
+type InteractionState struct {
+	Requester       string
+	URL             string
+	FormatOptions   *FormatOptions
+	VideoFormatID   string
+	VideoFormatName string
+	AudioFormatID   string
+	AudioFormatName string
+}
+
+// DownloadResult represents the result of an async download operation
+type DownloadResult struct {
+	Success bool
+	Message string
+	URL     string
+	Format  string
+	Error   error
+}

app/ytdlp.go

@@ -3,49 +3,19 @@ package main
 import (
 	"context"
 	"encoding/json"
+	"os"
+	"path/filepath"
+	"sync"
 	"time"
 
 	"github.com/lrstanley/go-ytdlp"
 )
 
-type DownloadOptions struct {
+var ytdlpBinary = os.Getenv("YTDLP_BIN")
-	EmbedThumbnail   bool
-	IncludeSubtitles bool
-	VideoFormatID    string
-	AudioFormatID    string
-}
-
-type VideoOption struct {
-	Height     *int     `json:"height,omitempty"`
-	Resolution string   `json:"resolution,omitempty"`
-	FormatID   string   `json:"format_id"`
-	Ext        string   `json:"ext"`
-	TBR        *float64 `json:"tbr,omitempty"`
-}
-
-type AudioOption struct {
-	Format   string   `json:"format"`
-	FormatID string   `json:"format_id"`
-	Ext      string   `json:"ext"`
-	TBR      *float64 `json:"tbr,omitempty"`
-	Language *string  `json:"language,omitempty"`
-}
-
-type FormatOptions struct {
-	VideoOptions []VideoOption `json:"video_options"`
-	AudioOptions []AudioOption `json:"audio_options"`
-}
-
-type ProgressUpdate struct {
-	Status   ytdlp.ProgressStatus
-	Percent  string
-	ETA      time.Duration
-	Filename string
-	Phase    string
-}
 
 func GetFormats(url string) (*FormatOptions, error) {
 	dl := ytdlp.New().
+		SetExecutable(ytdlpBinary).
 		SkipDownload().
 		DumpJSON()
 
@@ -127,36 +97,79 @@ func GetFormats(url string) (*FormatOptions, error) {
 	return formatOpts, nil
 }
 
-func downloadVideo(out_dir, url string, opts DownloadOptions, progressChan chan<- ProgressUpdate) {
+func dirSize(path string) int {
-	defer close(progressChan)
+	var total int64
+	filepath.Walk(path, func(_ string, info os.FileInfo, err error) error {
+		if err == nil && !info.IsDir() {
+			total += info.Size()
+		}
+		return nil
+	})
+	return int(total)
+}
 
-	var lastPhase string
+func DownloadVideo(out_dir, temp_dir, url string, opts DownloadOptions, progressChan chan<- ProgressUpdate) {
+	var mu sync.Mutex
+	currentPhase := "downloading"
+	currentFilename := ""
+
+	// Poll the temp directory for actual bytes-on-disk progress.
+	// The yt-dlp progress callback only tracks phase/filename since
+	// DownloadedBytes from the callback is unreliable for DASH streams.
+	var wg sync.WaitGroup
+	wg.Add(1)
+	stopPoll := make(chan struct{})
+	go func() {
+		defer wg.Done()
+		ticker := time.NewTicker(500 * time.Millisecond)
+		defer ticker.Stop()
+		for {
+			select {
+			case <-stopPoll:
+				return
+			case <-ticker.C:
+				mu.Lock()
+				phase := currentPhase
+				filename := currentFilename
+				mu.Unlock()
+				progressChan <- ProgressUpdate{
+					Phase:           phase,
+					DownloadedBytes: dirSize(temp_dir),
+					Filename:        filename,
+				}
+			}
+		}
+	}()
+
+	defer func() {
+		close(stopPoll)
+		wg.Wait()
+		close(progressChan)
+	}()
+
+	homePath := "home:" + out_dir
+	tempPath := "temp:" + temp_dir
 
 	dl := ytdlp.New().
-		SetWorkDir(out_dir).
+		SetExecutable(ytdlpBinary).
-		RecodeVideo("mp4").
+		Paths(homePath).
+		Paths(tempPath).
 		ProgressFunc(100*time.Millisecond, func(prog ytdlp.ProgressUpdate) {
-			// Detect phase transition -- differentiate "downloading" as the main download
+			if prog.Status == ytdlp.ProgressStatusFinished ||
-			// and "post processing" when the file name changes, preventing it from appearing "reset"
+				prog.Status == ytdlp.ProgressStatusStarting ||
+				prog.Status == ytdlp.ProgressStatusError {
+				return
+			}
+
 			phase := "downloading"
-			if prog.Status == ytdlp.ProgressStatusDownloading && prog.Percent() == 0.0 {
+			if prog.Status == ytdlp.ProgressStatusPostProcessing {
-				// If we already had progress, it's likely post-processing
-				if lastPhase == "downloading" {
-					phase = "post-processing"
-				}
-			} else if prog.Status != ytdlp.ProgressStatusDownloading {
 				phase = "post-processing"
 			}
 
-			lastPhase = phase
+			mu.Lock()
-
+			currentPhase = phase
-			progressChan <- ProgressUpdate{
+			currentFilename = prog.Filename
-				Status:   prog.Status,
+			mu.Unlock()
-				Percent:  prog.PercentString(),
-				ETA:      prog.ETA(),
-				Filename: prog.Filename,
-				Phase:    phase,
-			}
 		}).
 		Output("%(title)s.%(ext)s")
 

flake.lock

@@ -2,11 +2,11 @@
   "nodes": {
     "nixpkgs": {
       "locked": {
-        "lastModified": 1770537093,
+        "lastModified": 1772674223,
-        "narHash": "sha256-pF1quXG5wsgtyuPOHcLfYg/ft/QMr8NnX0i6tW2187s=",
+        "narHash": "sha256-/suKbHSaSmuC9UY7G0VRQ3aO+QKqxAQPQ19wG7QNkF8=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "fef9403a3e4d31b0a23f0bacebbec52c248fbb51",
+        "rev": "66d9241e3dc2296726dc522e62dbfe89c7b449f3",
         "type": "github"
       },
       "original": {

flake.nix

@@ -46,6 +46,11 @@
                         .venv/bin/pip install -r ./app/requirements.txt
                         source .venv/bin/activate
                     fi
+<<<<<<< HEAD
+=======
+
+                    export YTDLP_BIN=${pkgs.lib.getExe pkgs.yt-dlp}
+>>>>>>> v1-refactor
                 '';
             };
         });

renovate.json

@@ -1,3 +1,18 @@
 {
-  "$schema": "https://docs.renovatebot.com/renovate-schema.json"
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
-}
+  "customManagers": [
+    {
+      "description": "Update yt-dlp version in Dockerfiles",
+      "customType": "regex",
+      "managerFilePatterns": [
+        "/^Dockerfile$/"
+      ],
+      "matchStrings": [
+        "ARG YT_DLP_VERSION=\"(?<currentValue>.*?)\""
+      ],
+      "datasourceTemplate": "github-tags",
+      "depNameTemplate": "yt-dlp/yt-dlp",
+      "versioningTemplate": "regex:^(?<major>\\d{4})\\.(?<minor>\\d{2})\\.(?<patch>\\d{2})$"
+    }
+  ]
+}