refactor(otp): update WaitForOTP to accept context for cancellation and timeout

feat(bot): add auto OTP handling for Telegram bot using webhook
feat(cli): implement auto OTP handling for CLI using webhook
fix(cli): display "Auto OTP received" message when OTP is received via webhook
fix(otp): ensure correct waiter channel is deleted in WaitForOTP to prevent race conditions

Author: 0xtbug

bot/login.go

@@ -39,6 +39,29 @@ func (h *Handler) handlePhoneInput(b *gotgbot.Bot, ctx *ext.Context, userID int6
 	otpCallback := func() (string, error) {
 		_, _ = ctx.EffectiveMessage.Reply(b, "📲 OTP dikirim ke HP kamu.\n\n🔢 *Kirim kode OTP:*", &gotgbot.SendMessageOpts{ParseMode: "Markdown"})
 
+		if h.otpListener != nil {
+			waitCtx, cancel := context.WithTimeout(apiCtx, 3*time.Minute)
+			defer cancel() // LANGSUNG mati kalau manual input yang jalan/menang
+
+			webhookChan := make(chan string, 1)
+			go func() {
+				otp, err := h.otpListener.WaitForOTP(waitCtx, local)
+				if err == nil && otp != "" {
+					webhookChan <- otp
+				}
+			}()
+
+			select {
+			case otp := <-otpChan:
+				return otp, nil
+			case otp := <-webhookChan:
+				_, _ = ctx.EffectiveMessage.Reply(b, "🤖 *Auto OTP diterima dari SMS Forwarder!* Memverifikasi...", &gotgbot.SendMessageOpts{ParseMode: "Markdown"})
+				return otp, nil
+			case <-time.After(2 * time.Minute):
+				return "", fmt.Errorf("OTP timeout (2 menit)")
+			}
+		}
+
 		select {
 		case otp := <-otpChan:
 			return otp, nil

cli/commands.go

@@ -77,20 +77,37 @@ func (m *tuiModel) doLogin(localPhone string) tea.Cmd {
 	return func() tea.Msg {
 		ctx := context.Background()
 		otpCallback := func() (string, error) {
+			if programRef != nil {
+				programRef.Send(otpRequestMsg{})
+			}
+
 			if m.otpListener != nil {
-				if programRef != nil {
-					programRef.Send(otpRequestMsg{})
-				}
-				otp, err := m.otpListener.WaitForOTP(localPhone, 3*time.Minute)
-				if err != nil {
-					return "", fmt.Errorf("auto OTP: %w", err)
+				waitCtx, cancel := context.WithTimeout(ctx, 3*time.Minute)
+				defer cancel() // LANGSUNG mati kalau manual input yang jalan/menang
+
+				webhookChan := make(chan string, 1)
+				go func() {
+					otp, err := m.otpListener.WaitForOTP(waitCtx, localPhone)
+					if err == nil && otp != "" {
+						webhookChan <- otp
+					}
+				}()
+
+				select {
+				case otp := <-otpChan:
+					if otp == "" {
+						return "", fmt.Errorf("OTP kosong")
+					}
+					return otp, nil
+				case otp := <-webhookChan:
+					if programRef != nil {
+						programRef.Send(autoOtpMsg{})
+					}
+					return otp, nil
 				}
-				return otp, nil
 			}
 
-			if programRef != nil {
-				programRef.Send(otpRequestMsg{})
-			}
+			// Manual OTP: wait from user input
 			otp := <-otpChan
 			if otp == "" {
 				return "", fmt.Errorf("OTP kosong")

cli/menus.go

@@ -105,6 +105,12 @@ func (m tuiModel) updateLogin(msg tea.Msg) (tea.Model, tea.Cmd) {
 }
 
 func (m tuiModel) updateOTP(msg tea.Msg) (tea.Model, tea.Cmd) {
+	if _, ok := msg.(autoOtpMsg); ok {
+		m.screen = screenLoading
+		m.loading = "🤖 Auto OTP diterima, memverifikasi..."
+		return m, nil
+	}
+
 	if key, ok := msg.(tea.KeyMsg); ok {
 		if key.String() == "enter" {
 			otp := m.input.Value()

cli/model.go

@@ -55,6 +55,7 @@ type buyMsg struct {
 	err    error
 }
 type otpRequestMsg struct{}
+type autoOtpMsg struct{}
 type paymentPollMsg struct {
 	status *telkomsel.PaymentStatus
 	err    error

otp/listener.go

@@ -73,7 +73,7 @@ func (l *Listener) Stop() error {
 	return l.server.Shutdown(ctx)
 }
 
-func (l *Listener) WaitForOTP(phone string, timeout time.Duration) (string, error) {
+func (l *Listener) WaitForOTP(ctx context.Context, phone string) (string, error) {
 	normalized := normalizePhone(phone)
 	ch := make(chan string, 1)
 
@@ -83,18 +83,21 @@ func (l *Listener) WaitForOTP(phone string, timeout time.Duration) (string, erro
 
 	defer func() {
 		l.mu.Lock()
-		delete(l.waiters, normalized)
+		// Only delete if it hasn't been overwritten by a newer request
+		if l.waiters[normalized] == ch {
+			delete(l.waiters, normalized)
+		}
 		l.mu.Unlock()
 	}()
 
-	log.Printf("[OTP] Waiting for OTP for phone %s (timeout: %v)", normalized, timeout)
+	log.Printf("[OTP] Waiting for OTP for phone %s", normalized)
 
 	select {
 	case otp := <-ch:
 		log.Printf("[OTP] Received OTP for phone %s: %s", normalized, otp)
 		return otp, nil
-	case <-time.After(timeout):
-		return "", fmt.Errorf("OTP timeout after %v — no SMS received from webhook", timeout)
+	case <-ctx.Done():
+		return "", ctx.Err()
 	}
 }
 

otp/relogin.go

@@ -47,7 +47,11 @@ func AutoRelogin(ctx context.Context, auth *telkomsel.Auth, listener *Listener,
 	}
 
 	log.Printf("[AutoRelogin] Waiting for OTP from webhook (timeout: %v)...", OTPWaitTimeout)
-	otp, err := listener.WaitForOTP(phone, OTPWaitTimeout)
+	
+	waitCtx, cancel := context.WithTimeout(ctx, OTPWaitTimeout)
+	defer cancel()
+	
+	otp, err := listener.WaitForOTP(waitCtx, phone)
 	if err != nil {
 		return nil, fmt.Errorf("auto re-login wait OTP: %w", err)
 	}