Merge pull request 'fix(deps): update module github.com/caddyserver/certmagic to v0.25.1' (#61) from renovate/github.com-caddyserver-certmagic-0.x into main

Reviewed-on: #61

.gitea/workflows/renovate.yml

@@ -1,21 +0,0 @@
-name: renovate
-
-on:
-  schedule:
-    - cron: "0 0 * * *"
-  push:
-    branches:
-      - staging
-
-jobs:
-  renovate:
-    runs-on: ubuntu-latest
-    container: git.fossy.my.id/renovate-clanker/renovate:latest
-    steps:
-      - uses: actions/checkout@v6
-      - run: renovate
-        env:
-          RENOVATE_CONFIG_FILE: ${{ gitea.workspace }}/renovate-config.js
-          LOG_LEVEL: "debug"
-          RENOVATE_TOKEN: ${{ secrets.RENOVATE_TOKEN }}
-          GITHUB_COM_TOKEN: ${{ secrets.COM_TOKEN }}

go.mod

@@ -3,8 +3,8 @@ module tunnel_pls
 go 1.25.5
 
 require (
-	git.fossy.my.id/bagas/tunnel-please-grpc v1.2.0
+	git.fossy.my.id/bagas/tunnel-please-grpc v1.5.0
-	github.com/caddyserver/certmagic v0.25.0
+	github.com/caddyserver/certmagic v0.25.1
 	github.com/charmbracelet/bubbles v0.21.0
 	github.com/charmbracelet/bubbletea v1.3.10
 	github.com/charmbracelet/lipgloss v1.1.0
@@ -19,7 +19,7 @@ require (
 require (
 	github.com/atotto/clipboard v0.1.4 // indirect
 	github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect
-	github.com/caddyserver/zerossl v0.1.3 // indirect
+	github.com/caddyserver/zerossl v0.1.4 // indirect
 	github.com/charmbracelet/colorprofile v0.4.1 // indirect
 	github.com/charmbracelet/x/ansi v0.11.3 // indirect
 	github.com/charmbracelet/x/cellbuf v0.0.14 // indirect

go.sum

@@ -1,5 +1,9 @@
-git.fossy.my.id/bagas/tunnel-please-grpc v1.2.0 h1:BS1dJU3wa2ILgTGwkV95Knle0il0OQtErGqyb6xV7SU=
+git.fossy.my.id/bagas/tunnel-please-grpc v1.3.0 h1:RhcBKUG41/om4jgN+iF/vlY/RojTeX1QhBa4p4428ec=
-git.fossy.my.id/bagas/tunnel-please-grpc v1.2.0/go.mod h1:fG+VkArdkceGB0bNA7IFQus9GetLAwdF5Oi4jdMlXtY=
+git.fossy.my.id/bagas/tunnel-please-grpc v1.3.0/go.mod h1:fG+VkArdkceGB0bNA7IFQus9GetLAwdF5Oi4jdMlXtY=
+git.fossy.my.id/bagas/tunnel-please-grpc v1.4.0 h1:tpJSKjaSmV+vxxbVx6qnStjxFVXjj2M0rygWXxLb99o=
+git.fossy.my.id/bagas/tunnel-please-grpc v1.4.0/go.mod h1:fG+VkArdkceGB0bNA7IFQus9GetLAwdF5Oi4jdMlXtY=
+git.fossy.my.id/bagas/tunnel-please-grpc v1.5.0 h1:3xszIhck4wo9CoeRq9vnkar4PhY7kz9QrR30qj2XszA=
+git.fossy.my.id/bagas/tunnel-please-grpc v1.5.0/go.mod h1:Weh6ZujgWmT8XxD3Qba7sJ6r5eyUMB9XSWynqdyOoLo=
 github.com/atotto/clipboard v0.1.4 h1:EH0zSVneZPSuFR11BlR9YppQTVDbh5+16AmcJi4g1z4=
 github.com/atotto/clipboard v0.1.4/go.mod h1:ZY9tmq7sm5xIbd9bOK4onWV4S6X0u6GY7Vn0Yu86PYI=
 github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k=
@@ -8,8 +12,12 @@ github.com/aymanbagabas/go-udiff v0.2.0 h1:TK0fH4MteXUDspT88n8CKzvK0X9O2xu9yQjWp
 github.com/aymanbagabas/go-udiff v0.2.0/go.mod h1:RE4Ex0qsGkTAJoQdQQCA0uG+nAzJO/pI/QwceO5fgrA=
 github.com/caddyserver/certmagic v0.25.0 h1:VMleO/XA48gEWes5l+Fh6tRWo9bHkhwAEhx63i+F5ic=
 github.com/caddyserver/certmagic v0.25.0/go.mod h1:m9yB7Mud24OQbPHOiipAoyKPn9pKHhpSJxXR1jydBxA=
+github.com/caddyserver/certmagic v0.25.1 h1:4sIKKbOt5pg6+sL7tEwymE1x2bj6CHr80da1CRRIPbY=
+github.com/caddyserver/certmagic v0.25.1/go.mod h1:VhyvndxtVton/Fo/wKhRoC46Rbw1fmjvQ3GjHYSQTEY=
 github.com/caddyserver/zerossl v0.1.3 h1:onS+pxp3M8HnHpN5MMbOMyNjmTheJyWRaZYwn+YTAyA=
 github.com/caddyserver/zerossl v0.1.3/go.mod h1:CxA0acn7oEGO6//4rtrRjYgEoa4MFw/XofZnrYwGqG4=
+github.com/caddyserver/zerossl v0.1.4 h1:CVJOE3MZeFisCERZjkxIcsqIH4fnFdlYWnPYeFtBHRw=
+github.com/caddyserver/zerossl v0.1.4/go.mod h1:CxA0acn7oEGO6//4rtrRjYgEoa4MFw/XofZnrYwGqG4=
 github.com/charmbracelet/bubbles v0.21.0 h1:9TdC97SdRVg/1aaXNVWfFH3nnLAwOXr8Fn6u6mfQdFs=
 github.com/charmbracelet/bubbles v0.21.0/go.mod h1:HF+v6QUR4HkEpz62dx7ym2xc71/KBHg+zKwJtMw+qtg=
 github.com/charmbracelet/bubbletea v1.3.10 h1:otUDHWMMzQSB0Pkc87rm691KZ3SWa4KUlvF9nRvCICw=

internal/grpc/client/client.go

@@ -9,6 +9,7 @@ import (
 	"log"
 	"time"
 	"tunnel_pls/internal/config"
+	"tunnel_pls/types"
 
 	"tunnel_pls/session"
 
@@ -39,7 +40,6 @@ type Client struct {
 	conn                       *grpc.ClientConn
 	config                     *GrpcConfig
 	sessionRegistry            session.Registry
-	slugService                proto.SlugChangeClient
 	eventService               proto.EventServiceClient
 	authorizeConnectionService proto.UserServiceClient
 	closing                    bool
@@ -114,14 +114,12 @@ func New(config *GrpcConfig, sessionRegistry session.Registry) (*Client, error)
 		return nil, fmt.Errorf("failed to connect to gRPC server at %s: %w", config.Address, err)
 	}
 
-	slugService := proto.NewSlugChangeClient(conn)
 	eventService := proto.NewEventServiceClient(conn)
 	authorizeConnectionService := proto.NewUserServiceClient(conn)
 
 	return &Client{
 		conn:                       conn,
 		config:                     config,
-		slugService:                slugService,
 		sessionRegistry:            sessionRegistry,
 		eventService:               eventService,
 		authorizeConnectionService: authorizeConnectionService,
@@ -201,7 +199,6 @@ func (c *Client) SubscribeEvents(ctx context.Context, identity, authToken string
 			if c.isConnectionError(err) {
 				log.Printf("Reconnect to controller within %v sec", backoff.Seconds())
 				if err = wait(); err != nil {
-					fmt.Println(err)
 					return err
 				}
 				growBackoff()
@@ -213,104 +210,152 @@ func (c *Client) SubscribeEvents(ctx context.Context, identity, authToken string
 }
 
 func (c *Client) processEventStream(subscribe grpc.BidiStreamingClient[proto.Node, proto.Events]) error {
+	handlers := c.eventHandlers(subscribe)
+
 	for {
 		recv, err := subscribe.Recv()
 		if err != nil {
 			return err
 		}
-		switch recv.GetType() {
+
-		case proto.EventType_SLUG_CHANGE:
+		handler, ok := handlers[recv.GetType()]
-			oldSlug := recv.GetSlugEvent().GetOld()
+		if !ok {
-			newSlug := recv.GetSlugEvent().GetNew()
-			sess, err := c.sessionRegistry.Get(oldSlug)
-			if err != nil {
-				errSend := subscribe.Send(&proto.Node{
-					Type: proto.EventType_SLUG_CHANGE_RESPONSE,
-					Payload: &proto.Node_SlugEventResponse{
-						SlugEventResponse: &proto.SlugChangeEventResponse{
-							Success: false,
-							Message: err.Error(),
-						},
-					},
-				})
-				if errSend != nil {
-					if c.isConnectionError(errSend) {
-						return errSend
-					}
-					log.Printf("non-connection send error for slug change failure: %v", errSend)
-				}
-				continue
-			}
-			err = c.sessionRegistry.Update(oldSlug, newSlug)
-			if err != nil {
-				errSend := subscribe.Send(&proto.Node{
-					Type: proto.EventType_SLUG_CHANGE_RESPONSE,
-					Payload: &proto.Node_SlugEventResponse{
-						SlugEventResponse: &proto.SlugChangeEventResponse{
-							Success: false,
-							Message: err.Error(),
-						},
-					},
-				})
-				if errSend != nil {
-					if c.isConnectionError(errSend) {
-						return errSend
-					}
-					log.Printf("non-connection send error for slug change failure: %v", errSend)
-				}
-				continue
-			}
-			sess.GetInteraction().Redraw()
-			err = subscribe.Send(&proto.Node{
-				Type: proto.EventType_SLUG_CHANGE_RESPONSE,
-				Payload: &proto.Node_SlugEventResponse{
-					SlugEventResponse: &proto.SlugChangeEventResponse{
-						Success: true,
-						Message: "",
-					},
-				},
-			})
-			if err != nil {
-				if c.isConnectionError(err) {
-					log.Printf("connection error sending slug change success: %v", err)
-					return err
-				}
-				log.Printf("non-connection send error for slug change success: %v", err)
-				continue
-			}
-		case proto.EventType_GET_SESSIONS:
-			sessions := c.sessionRegistry.GetAllSessionFromUser(recv.GetGetSessionsEvent().GetIdentity())
-			var details []*proto.Detail
-			for _, ses := range sessions {
-				detail := ses.Detail()
-				details = append(details, &proto.Detail{
-					Node:           config.Getenv("domain", "localhost"),
-					ForwardingType: detail.ForwardingType,
-					Slug:           detail.Slug,
-					UserId:         detail.UserID,
-					Active:         detail.Active,
-					StartedAt:      timestamppb.New(detail.StartedAt),
-				})
-			}
-			err = subscribe.Send(&proto.Node{
-				Type: proto.EventType_GET_SESSIONS,
-				Payload: &proto.Node_GetSessionsEvent{
-					GetSessionsEvent: &proto.GetSessionsResponse{
-						Details: details,
-					},
-				},
-			})
-			if err != nil {
-				if c.isConnectionError(err) {
-					log.Printf("connection error sending sessions success: %v", err)
-					return err
-				}
-				log.Printf("non-connection send error for sessions success: %v", err)
-				continue
-			}
-		default:
 			log.Printf("Unknown event type received: %v", recv.GetType())
+			continue
 		}
+
+		if err = handler(recv); err != nil {
+			return err
+		}
+	}
+}
+
+func (c *Client) eventHandlers(subscribe grpc.BidiStreamingClient[proto.Node, proto.Events]) map[proto.EventType]func(*proto.Events) error {
+	return map[proto.EventType]func(*proto.Events) error{
+		proto.EventType_SLUG_CHANGE:       func(evt *proto.Events) error { return c.handleSlugChange(subscribe, evt) },
+		proto.EventType_GET_SESSIONS:      func(evt *proto.Events) error { return c.handleGetSessions(subscribe, evt) },
+		proto.EventType_TERMINATE_SESSION: func(evt *proto.Events) error { return c.handleTerminateSession(subscribe, evt) },
+	}
+}
+
+func (c *Client) handleSlugChange(subscribe grpc.BidiStreamingClient[proto.Node, proto.Events], evt *proto.Events) error {
+	slugEvent := evt.GetSlugEvent()
+	user := slugEvent.GetUser()
+	oldSlug := slugEvent.GetOld()
+	newSlug := slugEvent.GetNew()
+
+	userSession, err := c.sessionRegistry.Get(types.SessionKey{Id: oldSlug, Type: types.HTTP})
+	if err != nil {
+		return c.sendNode(subscribe, &proto.Node{
+			Type: proto.EventType_SLUG_CHANGE_RESPONSE,
+			Payload: &proto.Node_SlugEventResponse{
+				SlugEventResponse: &proto.SlugChangeEventResponse{Success: false, Message: err.Error()},
+			},
+		}, "slug change failure response")
+	}
+
+	if err = c.sessionRegistry.Update(user, types.SessionKey{Id: oldSlug, Type: types.HTTP}, types.SessionKey{Id: newSlug, Type: types.HTTP}); err != nil {
+		return c.sendNode(subscribe, &proto.Node{
+			Type: proto.EventType_SLUG_CHANGE_RESPONSE,
+			Payload: &proto.Node_SlugEventResponse{
+				SlugEventResponse: &proto.SlugChangeEventResponse{Success: false, Message: err.Error()},
+			},
+		}, "slug change failure response")
+	}
+
+	userSession.GetInteraction().Redraw()
+	return c.sendNode(subscribe, &proto.Node{
+		Type: proto.EventType_SLUG_CHANGE_RESPONSE,
+		Payload: &proto.Node_SlugEventResponse{
+			SlugEventResponse: &proto.SlugChangeEventResponse{Success: true, Message: ""},
+		},
+	}, "slug change success response")
+}
+
+func (c *Client) handleGetSessions(subscribe grpc.BidiStreamingClient[proto.Node, proto.Events], evt *proto.Events) error {
+	sessions := c.sessionRegistry.GetAllSessionFromUser(evt.GetGetSessionsEvent().GetIdentity())
+
+	var details []*proto.Detail
+	for _, ses := range sessions {
+		detail := ses.Detail()
+		details = append(details, &proto.Detail{
+			Node:           config.Getenv("DOMAIN", "localhost"),
+			ForwardingType: detail.ForwardingType,
+			Slug:           detail.Slug,
+			UserId:         detail.UserID,
+			Active:         detail.Active,
+			StartedAt:      timestamppb.New(detail.StartedAt),
+		})
+	}
+
+	return c.sendNode(subscribe, &proto.Node{
+		Type: proto.EventType_GET_SESSIONS,
+		Payload: &proto.Node_GetSessionsEvent{
+			GetSessionsEvent: &proto.GetSessionsResponse{Details: details},
+		},
+	}, "send get sessions response")
+}
+
+func (c *Client) handleTerminateSession(subscribe grpc.BidiStreamingClient[proto.Node, proto.Events], evt *proto.Events) error {
+	terminate := evt.GetTerminateSessionEvent()
+	user := terminate.GetUser()
+	slug := terminate.GetSlug()
+
+	tunnelType, err := c.protoToTunnelType(terminate.GetTunnelType())
+	if err != nil {
+		return c.sendNode(subscribe, &proto.Node{
+			Type: proto.EventType_TERMINATE_SESSION,
+			Payload: &proto.Node_TerminateSessionEventResponse{
+				TerminateSessionEventResponse: &proto.TerminateSessionEventResponse{Success: false, Message: err.Error()},
+			},
+		}, "terminate session invalid tunnel type")
+	}
+
+	userSession, err := c.sessionRegistry.GetWithUser(user, types.SessionKey{Id: slug, Type: tunnelType})
+	if err != nil {
+		return c.sendNode(subscribe, &proto.Node{
+			Type: proto.EventType_TERMINATE_SESSION,
+			Payload: &proto.Node_TerminateSessionEventResponse{
+				TerminateSessionEventResponse: &proto.TerminateSessionEventResponse{Success: false, Message: err.Error()},
+			},
+		}, "terminate session fetch failed")
+	}
+
+	if err = userSession.GetLifecycle().Close(); err != nil {
+		return c.sendNode(subscribe, &proto.Node{
+			Type: proto.EventType_TERMINATE_SESSION,
+			Payload: &proto.Node_TerminateSessionEventResponse{
+				TerminateSessionEventResponse: &proto.TerminateSessionEventResponse{Success: false, Message: err.Error()},
+			},
+		}, "terminate session close failed")
+	}
+
+	return c.sendNode(subscribe, &proto.Node{
+		Type: proto.EventType_TERMINATE_SESSION,
+		Payload: &proto.Node_TerminateSessionEventResponse{
+			TerminateSessionEventResponse: &proto.TerminateSessionEventResponse{Success: true, Message: ""},
+		},
+	}, "terminate session success response")
+}
+
+func (c *Client) sendNode(subscribe grpc.BidiStreamingClient[proto.Node, proto.Events], node *proto.Node, context string) error {
+	if err := subscribe.Send(node); err != nil {
+		if c.isConnectionError(err) {
+			return err
+		}
+		log.Printf("%s: %v", context, err)
+	}
+	return nil
+}
+
+func (c *Client) protoToTunnelType(t proto.TunnelType) (types.TunnelType, error) {
+	switch t {
+	case proto.TunnelType_HTTP:
+		return types.HTTP, nil
+	case proto.TunnelType_TCP:
+		return types.TCP, nil
+	default:
+		return types.UNKNOWN, fmt.Errorf("unknown tunnel type received")
 	}
 }
 

renovate-config.js

@@ -1,8 +0,0 @@
-module.exports = {
-    "endpoint": "https://git.fossy.my.id/api/v1",
-    "gitAuthor": "Renovate-Clanker <renovate-bot@fossy.my.id>",
-    "platform": "gitea",
-    "onboardingConfigFileName": "renovate.json",
-    "autodiscover": true,
-    "optimizeForDisabled": true,
-};

server/http.go

@@ -13,6 +13,7 @@ import (
 	"time"
 	"tunnel_pls/internal/config"
 	"tunnel_pls/session"
+	"tunnel_pls/types"
 
 	"golang.org/x/crypto/ssh"
 )
@@ -313,7 +314,10 @@ func (hs *httpServer) handler(conn net.Conn) {
 		return
 	}
 
-	sshSession, err := hs.sessionRegistry.Get(slug)
+	sshSession, err := hs.sessionRegistry.Get(types.SessionKey{
+		Id:   slug,
+		Type: types.HTTP,
+	})
 	if err != nil {
 		_, err = conn.Write([]byte("HTTP/1.1 301 Moved Permanently\r\n" +
 			fmt.Sprintf("Location: https://tunnl.live/tunnel-not-found?slug=%s\r\n", slug) +

server/https.go

@@ -9,6 +9,7 @@ import (
 	"net"
 	"strings"
 	"tunnel_pls/internal/config"
+	"tunnel_pls/types"
 )
 
 func (hs *httpServer) ListenAndServeTLS() error {
@@ -89,7 +90,10 @@ func (hs *httpServer) handlerTLS(conn net.Conn) {
 		return
 	}
 
-	sshSession, err := hs.sessionRegistry.Get(slug)
+	sshSession, err := hs.sessionRegistry.Get(types.SessionKey{
+		Id:   slug,
+		Type: types.HTTP,
+	})
 	if err != nil {
 		_, err = conn.Write([]byte("HTTP/1.1 301 Moved Permanently\r\n" +
 			fmt.Sprintf("Location: https://tunnl.live/tunnel-not-found?slug=%s\r\n", slug) +

server/server.go

@@ -2,9 +2,11 @@ package server
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"log"
 	"net"
+	"time"
 	"tunnel_pls/internal/config"
 	"tunnel_pls/internal/grpc/client"
 	"tunnel_pls/session"
@@ -64,31 +66,32 @@ func (s *Server) Start() {
 
 func (s *Server) handleConnection(conn net.Conn) {
 	sshConn, chans, forwardingReqs, err := ssh.NewServerConn(conn, s.config)
-	defer func(sshConn *ssh.ServerConn) {
-		err = sshConn.Close()
-		if err != nil {
-			log.Printf("failed to close SSH server: %v", err)
-		}
-	}(sshConn)
-
 	if err != nil {
 		log.Printf("failed to establish SSH connection: %v", err)
-		err := conn.Close()
+		err = conn.Close()
 		if err != nil {
 			log.Printf("failed to close SSH connection: %v", err)
 			return
 		}
 		return
 	}
-	ctx := context.Background()
+
-	log.Println("SSH connection established:", sshConn.User())
+	defer func(sshConn *ssh.ServerConn) {
+		err = sshConn.Close()
+		if err != nil && !errors.Is(err, net.ErrClosed) {
+			log.Printf("failed to close SSH server: %v", err)
+		}
+	}(sshConn)
 
 	user := "UNAUTHORIZED"
 	if s.grpcClient != nil {
+		ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 		_, u, _ := s.grpcClient.AuthorizeConn(ctx, sshConn.User())
 		user = u
+		cancel()
 	}
 
+	log.Println("SSH connection established:", sshConn.User())
 	sshSession := session.New(sshConn, forwardingReqs, chans, s.sessionRegistry, user)
 	err = sshSession.Start()
 	if err != nil {

session/handler.go

@@ -164,8 +164,9 @@ func (s *SSHSession) HandleTCPIPForward(req *ssh.Request) {
 
 func (s *SSHSession) HandleHTTPForward(req *ssh.Request, portToBind uint16) {
 	slug := random.GenerateRandomString(20)
+	key := types.SessionKey{Id: slug, Type: types.HTTP}
 
-	if !s.registry.Register(slug, s) {
+	if !s.registry.Register(key, s) {
 		log.Printf("Failed to register client with slug: %s", slug)
 		err := req.Reply(false, nil)
 		if err != nil {
@@ -178,7 +179,7 @@ func (s *SSHSession) HandleHTTPForward(req *ssh.Request, portToBind uint16) {
 	err := binary.Write(buf, binary.BigEndian, uint32(portToBind))
 	if err != nil {
 		log.Println("Failed to write port to buffer:", err)
-		s.registry.Remove(slug)
+		s.registry.Remove(key)
 		err = req.Reply(false, nil)
 		if err != nil {
 			log.Println("Failed to reply to request:", err)
@@ -190,7 +191,7 @@ func (s *SSHSession) HandleHTTPForward(req *ssh.Request, portToBind uint16) {
 	err = req.Reply(true, buf.Bytes())
 	if err != nil {
 		log.Println("Failed to reply to request:", err)
-		s.registry.Remove(slug)
+		s.registry.Remove(key)
 		err = req.Reply(false, nil)
 		if err != nil {
 			log.Println("Failed to reply to request:", err)
@@ -225,10 +226,29 @@ func (s *SSHSession) HandleTCPForward(req *ssh.Request, addr string, portToBind
 		return
 	}
 
+	key := types.SessionKey{Id: fmt.Sprintf("%d", portToBind), Type: types.TCP}
+
+	if !s.registry.Register(key, s) {
+		log.Printf("Failed to register TCP client with id: %s", key.Id)
+		if setErr := portUtil.Default.SetPortStatus(portToBind, false); setErr != nil {
+			log.Printf("Failed to reset port status: %v", setErr)
+		}
+		if closeErr := listener.Close(); closeErr != nil {
+			log.Printf("Failed to close listener: %s", closeErr)
+		}
+		err = req.Reply(false, nil)
+		if err != nil {
+			log.Println("Failed to reply to request:", err)
+		}
+		_ = s.lifecycle.Close()
+		return
+	}
+
 	buf := new(bytes.Buffer)
 	err = binary.Write(buf, binary.BigEndian, uint32(portToBind))
 	if err != nil {
 		log.Println("Failed to write port to buffer:", err)
+		s.registry.Remove(key)
 		if setErr := portUtil.Default.SetPortStatus(portToBind, false); setErr != nil {
 			log.Printf("Failed to reset port status: %v", setErr)
 		}
@@ -244,6 +264,7 @@ func (s *SSHSession) HandleTCPForward(req *ssh.Request, addr string, portToBind
 	err = req.Reply(true, buf.Bytes())
 	if err != nil {
 		log.Println("Failed to reply to request:", err)
+		s.registry.Remove(key)
 		if setErr := portUtil.Default.SetPortStatus(portToBind, false); setErr != nil {
 			log.Printf("Failed to reset port status: %v", setErr)
 		}
@@ -258,6 +279,7 @@ func (s *SSHSession) HandleTCPForward(req *ssh.Request, addr string, portToBind
 	s.forwarder.SetType(types.TCP)
 	s.forwarder.SetListener(listener)
 	s.forwarder.SetForwardedPort(portToBind)
+	s.slugManager.Set(key.Id)
 	s.lifecycle.SetStatus(types.RUNNING)
 	go s.forwarder.AcceptTCPConnections()
 	s.interaction.Start()

session/interaction/interaction.go

@@ -23,15 +23,20 @@ import (
 
 type Lifecycle interface {
 	Close() error
+	GetUser() string
+}
+
+type SessionRegistry interface {
+	Update(user string, oldKey, newKey types.SessionKey) error
 }
 
 type Controller interface {
 	SetChannel(channel ssh.Channel)
 	SetLifecycle(lifecycle Lifecycle)
-	SetSlugModificator(func(oldSlug, newSlug string) error)
 	Start()
 	SetWH(w, h int)
 	Redraw()
+	SetSessionRegistry(registry SessionRegistry)
 }
 
 type Forwarder interface {
@@ -41,14 +46,14 @@ type Forwarder interface {
 }
 
 type Interaction struct {
-	channel          ssh.Channel
+	channel         ssh.Channel
-	slugManager      slug.Manager
+	slugManager     slug.Manager
-	forwarder        Forwarder
+	forwarder       Forwarder
-	lifecycle        Lifecycle
+	lifecycle       Lifecycle
-	updateClientSlug func(oldSlug, newSlug string) error
+	sessionRegistry SessionRegistry
-	program          *tea.Program
+	program         *tea.Program
-	ctx              context.Context
+	ctx             context.Context
-	cancel           context.CancelFunc
+	cancel          context.CancelFunc
 }
 
 func (i *Interaction) SetWH(w, h int) {
@@ -102,17 +107,21 @@ type tickMsg time.Time
 func NewInteraction(slugManager slug.Manager, forwarder Forwarder) *Interaction {
 	ctx, cancel := context.WithCancel(context.Background())
 	return &Interaction{
-		channel:          nil,
+		channel:         nil,
-		slugManager:      slugManager,
+		slugManager:     slugManager,
-		forwarder:        forwarder,
+		forwarder:       forwarder,
-		lifecycle:        nil,
+		lifecycle:       nil,
-		updateClientSlug: nil,
+		sessionRegistry: nil,
-		program:          nil,
+		program:         nil,
-		ctx:              ctx,
+		ctx:             ctx,
-		cancel:           cancel,
+		cancel:          cancel,
 	}
 }
 
+func (i *Interaction) SetSessionRegistry(registry SessionRegistry) {
+	i.sessionRegistry = registry
+}
+
 func (i *Interaction) SetLifecycle(lifecycle Lifecycle) {
 	i.lifecycle = lifecycle
 }
@@ -121,10 +130,6 @@ func (i *Interaction) SetChannel(channel ssh.Channel) {
 	i.channel = channel
 }
 
-func (i *Interaction) SetSlugModificator(modificator func(oldSlug, newSlug string) error) {
-	i.updateClientSlug = modificator
-}
-
 func (i *Interaction) Stop() {
 	if i.cancel != nil {
 		i.cancel()
@@ -218,7 +223,13 @@ func (m *model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 				return m, tea.Batch(tea.ClearScreen, textinput.Blink)
 			case "enter":
 				inputValue := m.slugInput.Value()
-				if err := m.interaction.updateClientSlug(m.interaction.slugManager.Get(), inputValue); err != nil {
+				if err := m.interaction.sessionRegistry.Update(m.interaction.lifecycle.GetUser(), types.SessionKey{
+					Id:   m.interaction.slugManager.Get(),
+					Type: types.HTTP,
+				}, types.SessionKey{
+					Id:   inputValue,
+					Type: types.HTTP,
+				}); err != nil {
 					m.slugError = err.Error()
 					return m, nil
 				}
@@ -661,22 +672,32 @@ func (m *model) View() string {
 		MarginBottom(boxMargin).
 		Width(boxMaxWidth)
 
-	urlDisplay := m.getTunnelURL()
+	authenticatedUser := m.interaction.lifecycle.GetUser()
-	if shouldUseCompactLayout(m.width, 80) && len(urlDisplay) > m.width-20 {
+
-		maxLen := m.width - 25
+	userInfoStyle := lipgloss.NewStyle().
-		if maxLen > 10 {
+		Foreground(lipgloss.Color("#FAFAFA")).
-			urlDisplay = truncateString(urlDisplay, maxLen)
+		Bold(true)
-		}
+
-	}
+	sectionHeaderStyle := lipgloss.NewStyle().
+		Foreground(lipgloss.Color("#888888")).
+		Bold(true)
+
+	addressStyle := lipgloss.NewStyle().
+		Foreground(lipgloss.Color("#FAFAFA"))
 
 	var infoContent string
 	if shouldUseCompactLayout(m.width, 70) {
-		infoContent = fmt.Sprintf("🌐 %s", urlBoxStyle.Render(urlDisplay))
+		infoContent = fmt.Sprintf("👤 %s\n\n%s\n%s",
-	} else if isCompact {
+			userInfoStyle.Render(authenticatedUser),
-		infoContent = fmt.Sprintf("🌐  Forwarding to:\n\n     %s", urlBoxStyle.Render(urlDisplay))
+			sectionHeaderStyle.Render("🌐 FORWARDING ADDRESS:"),
+			addressStyle.Render(fmt.Sprintf("   %s", urlBoxStyle.Render(m.getTunnelURL()))))
 	} else {
-		infoContent = fmt.Sprintf("🌐  F O R W A R D I N G   T O:\n\n     %s", urlBoxStyle.Render(urlDisplay))
+		infoContent = fmt.Sprintf("👤  Authenticated as: %s\n\n%s\n     %s",
+			userInfoStyle.Render(authenticatedUser),
+			sectionHeaderStyle.Render("🌐  FORWARDING ADDRESS:"),
+			addressStyle.Render(urlBoxStyle.Render(m.getTunnelURL())))
 	}
+
 	b.WriteString(responsiveInfoBox.Render(infoContent))
 	b.WriteString("\n")
 

session/lifecycle/lifecycle.go

@@ -19,30 +19,36 @@ type Forwarder interface {
 	GetForwardedPort() uint16
 }
 
-type Lifecycle struct {
+type SessionRegistry interface {
-	status           types.Status
+	Remove(key types.SessionKey)
-	conn             ssh.Conn
-	channel          ssh.Channel
-	forwarder        Forwarder
-	slugManager      slug.Manager
-	unregisterClient func(slug string)
-	startedAt        time.Time
 }
 
-func NewLifecycle(conn ssh.Conn, forwarder Forwarder, slugManager slug.Manager) *Lifecycle {
+type Lifecycle struct {
+	status          types.Status
+	conn            ssh.Conn
+	channel         ssh.Channel
+	forwarder       Forwarder
+	sessionRegistry SessionRegistry
+	slugManager     slug.Manager
+	startedAt       time.Time
+	user            string
+}
+
+func NewLifecycle(conn ssh.Conn, forwarder Forwarder, slugManager slug.Manager, user string) *Lifecycle {
 	return &Lifecycle{
-		status:           types.INITIALIZING,
+		status:          types.INITIALIZING,
-		conn:             conn,
+		conn:            conn,
-		channel:          nil,
+		channel:         nil,
-		forwarder:        forwarder,
+		forwarder:       forwarder,
-		slugManager:      slugManager,
+		slugManager:     slugManager,
-		unregisterClient: nil,
+		sessionRegistry: nil,
-		startedAt:        time.Now(),
+		startedAt:       time.Now(),
+		user:            user,
 	}
 }
 
-func (l *Lifecycle) SetUnregisterClient(unregisterClient func(slug string)) {
+func (l *Lifecycle) SetSessionRegistry(registry SessionRegistry) {
-	l.unregisterClient = unregisterClient
+	l.sessionRegistry = registry
 }
 
 type SessionLifecycle interface {
@@ -50,12 +56,17 @@ type SessionLifecycle interface {
 	SetStatus(status types.Status)
 	GetConnection() ssh.Conn
 	GetChannel() ssh.Channel
+	GetUser() string
 	SetChannel(channel ssh.Channel)
-	SetUnregisterClient(unregisterClient func(slug string))
+	SetSessionRegistry(registry SessionRegistry)
 	IsActive() bool
 	StartedAt() time.Time
 }
 
+func (l *Lifecycle) GetUser() string {
+	return l.user
+}
+
 func (l *Lifecycle) GetChannel() ssh.Channel {
 	return l.channel
 }
@@ -94,12 +105,13 @@ func (l *Lifecycle) Close() error {
 	}
 
 	clientSlug := l.slugManager.Get()
-	if clientSlug != "" {
+	if clientSlug != "" && l.sessionRegistry.Remove != nil {
-		l.unregisterClient(clientSlug)
+		key := types.SessionKey{Id: clientSlug, Type: l.forwarder.GetTunnelType()}
+		l.sessionRegistry.Remove(key)
 	}
 
 	if l.forwarder.GetTunnelType() == types.TCP {
-		err := portUtil.Default.SetPortStatus(l.forwarder.GetForwardedPort(), false)
+		err = portUtil.Default.SetPortStatus(l.forwarder.GetForwardedPort(), false)
 		if err != nil {
 			return err
 		}

session/registry.go

@@ -3,96 +3,115 @@ package session
 import (
 	"fmt"
 	"sync"
+	"tunnel_pls/types"
 )
 
+type Key = types.SessionKey
+
 type Registry interface {
-	Get(slug string) (session *SSHSession, err error)
+	Get(key Key) (session *SSHSession, err error)
-	Update(oldSlug, newSlug string) error
+	GetWithUser(user string, key Key) (session *SSHSession, err error)
-	Register(slug string, session *SSHSession) (success bool)
+	Update(user string, oldKey, newKey Key) error
-	Remove(slug string)
+	Register(key Key, session *SSHSession) (success bool)
+	Remove(key Key)
 	GetAllSessionFromUser(user string) []*SSHSession
 }
 type registry struct {
 	mu        sync.RWMutex
-	byUser    map[string]map[string]*SSHSession
+	byUser    map[string]map[Key]*SSHSession
-	slugIndex map[string]string
+	slugIndex map[Key]string
 }
 
 func NewRegistry() Registry {
 	return &registry{
-		byUser:    make(map[string]map[string]*SSHSession),
+		byUser:    make(map[string]map[Key]*SSHSession),
-		slugIndex: make(map[string]string),
+		slugIndex: make(map[Key]string),
 	}
 }
 
-func (r *registry) Get(slug string) (session *SSHSession, err error) {
+func (r *registry) Get(key Key) (session *SSHSession, err error) {
 	r.mu.RLock()
 	defer r.mu.RUnlock()
 
-	userID, ok := r.slugIndex[slug]
+	userID, ok := r.slugIndex[key]
 	if !ok {
 		return nil, fmt.Errorf("session not found")
 	}
 
-	client, ok := r.byUser[userID][slug]
+	client, ok := r.byUser[userID][key]
 	if !ok {
 		return nil, fmt.Errorf("session not found")
 	}
 	return client, nil
 }
 
-func (r *registry) Update(oldSlug, newSlug string) error {
+func (r *registry) GetWithUser(user string, key Key) (session *SSHSession, err error) {
-	if isForbiddenSlug(newSlug) {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+
+	client, ok := r.byUser[user][key]
+	if !ok {
+		return nil, fmt.Errorf("session not found")
+	}
+	return client, nil
+}
+
+func (r *registry) Update(user string, oldKey, newKey Key) error {
+	if oldKey.Type != newKey.Type {
+		return fmt.Errorf("tunnel type cannot change")
+	}
+
+	if newKey.Type != types.HTTP {
+		return fmt.Errorf("non http tunnel cannot change slug")
+	}
+
+	if isForbiddenSlug(newKey.Id) {
 		return fmt.Errorf("this subdomain is reserved. Please choose a different one")
-	} else if !isValidSlug(newSlug) {
+	}
+
+	if !isValidSlug(newKey.Id) {
 		return fmt.Errorf("invalid subdomain. Follow the rules")
 	}
 
 	r.mu.Lock()
 	defer r.mu.Unlock()
 
-	userID, ok := r.slugIndex[oldSlug]
+	if _, exists := r.slugIndex[newKey]; exists && newKey != oldKey {
-	if !ok {
-		return fmt.Errorf("session not found")
-	}
-
-	if _, exists := r.slugIndex[newSlug]; exists && newSlug != oldSlug {
 		return fmt.Errorf("someone already uses this subdomain")
 	}
-
+	client, ok := r.byUser[user][oldKey]
-	client, ok := r.byUser[userID][oldSlug]
 	if !ok {
 		return fmt.Errorf("session not found")
 	}
 
-	delete(r.byUser[userID], oldSlug)
+	delete(r.byUser[user], oldKey)
-	delete(r.slugIndex, oldSlug)
+	delete(r.slugIndex, oldKey)
 
-	client.slugManager.Set(newSlug)
+	client.slugManager.Set(newKey.Id)
-	r.slugIndex[newSlug] = userID
+	r.slugIndex[newKey] = user
 
-	if r.byUser[userID] == nil {
+	if r.byUser[user] == nil {
-		r.byUser[userID] = make(map[string]*SSHSession)
+		r.byUser[user] = make(map[Key]*SSHSession)
 	}
-	r.byUser[userID][newSlug] = client
+	r.byUser[user][newKey] = client
 	return nil
 }
 
-func (r *registry) Register(slug string, session *SSHSession) (success bool) {
+func (r *registry) Register(key Key, session *SSHSession) (success bool) {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 
-	if _, exists := r.slugIndex[slug]; exists {
+	if _, exists := r.slugIndex[key]; exists {
 		return false
 	}
 
-	userID := session.userID
+	userID := session.lifecycle.GetUser()
 	if r.byUser[userID] == nil {
-		r.byUser[userID] = make(map[string]*SSHSession)
+		r.byUser[userID] = make(map[Key]*SSHSession)
 	}
 
-	r.byUser[userID][slug] = session
+	r.byUser[userID][key] = session
-	r.slugIndex[slug] = userID
+	r.slugIndex[key] = userID
 	return true
 }
 
@@ -112,20 +131,20 @@ func (r *registry) GetAllSessionFromUser(user string) []*SSHSession {
 	return sessions
 }
 
-func (r *registry) Remove(slug string) {
+func (r *registry) Remove(key Key) {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 
-	userID, ok := r.slugIndex[slug]
+	userID, ok := r.slugIndex[key]
 	if !ok {
 		return
 	}
 
-	delete(r.byUser[userID], slug)
+	delete(r.byUser[userID], key)
 	if len(r.byUser[userID]) == 0 {
 		delete(r.byUser, userID)
 	}
-	delete(r.slugIndex, slug)
+	delete(r.slugIndex, key)
 }
 
 func isValidSlug(slug string) bool {

session/session.go

@@ -28,7 +28,6 @@ type SSHSession struct {
 	forwarder     forwarder.ForwardingController
 	slugManager   slug.Manager
 	registry      Registry
-	userID        string
 }
 
 func (s *SSHSession) GetLifecycle() lifecycle.SessionLifecycle {
@@ -47,16 +46,16 @@ func (s *SSHSession) GetSlugManager() slug.Manager {
 	return s.slugManager
 }
 
-func New(conn *ssh.ServerConn, forwardingReq <-chan *ssh.Request, sshChan <-chan ssh.NewChannel, sessionRegistry Registry, userID string) *SSHSession {
+func New(conn *ssh.ServerConn, forwardingReq <-chan *ssh.Request, sshChan <-chan ssh.NewChannel, sessionRegistry Registry, user string) *SSHSession {
 	slugManager := slug.NewManager()
 	forwarderManager := forwarder.NewForwarder(slugManager)
 	interactionManager := interaction.NewInteraction(slugManager, forwarderManager)
-	lifecycleManager := lifecycle.NewLifecycle(conn, forwarderManager, slugManager)
+	lifecycleManager := lifecycle.NewLifecycle(conn, forwarderManager, slugManager, user)
 
 	interactionManager.SetLifecycle(lifecycleManager)
-	interactionManager.SetSlugModificator(sessionRegistry.Update)
 	forwarderManager.SetLifecycle(lifecycleManager)
-	lifecycleManager.SetUnregisterClient(sessionRegistry.Remove)
+	interactionManager.SetSessionRegistry(sessionRegistry)
+	lifecycleManager.SetSessionRegistry(sessionRegistry)
 
 	return &SSHSession{
 		initialReq:    forwardingReq,
@@ -66,7 +65,6 @@ func New(conn *ssh.ServerConn, forwardingReq <-chan *ssh.Request, sshChan <-chan
 		forwarder:     forwarderManager,
 		slugManager:   slugManager,
 		registry:      sessionRegistry,
-		userID:        userID,
 	}
 }
 
@@ -82,7 +80,7 @@ func (s *SSHSession) Detail() Detail {
 	return Detail{
 		ForwardingType: string(s.forwarder.GetTunnelType()),
 		Slug:           s.slugManager.Get(),
-		UserID:         s.userID,
+		UserID:         s.lifecycle.GetUser(),
 		Active:         s.lifecycle.IsActive(),
 		StartedAt:      s.lifecycle.StartedAt(),
 	}

types/types.go

@@ -11,10 +11,16 @@ const (
 type TunnelType string
 
 const (
-	HTTP TunnelType = "HTTP"
+	UNKNOWN TunnelType = "UNKNOWN"
-	TCP  TunnelType = "TCP"
+	HTTP    TunnelType = "HTTP"
+	TCP     TunnelType = "TCP"
 )
 
+type SessionKey struct {
+	Id   string
+	Type TunnelType
+}
+
 var BadGatewayResponse = []byte("HTTP/1.1 502 Bad Gateway\r\n" +
 	"Content-Length: 11\r\n" +
 	"Content-Type: text/plain\r\n\r\n" +