Enhance documentation across the codebase

Author: ayanrajpoot10

cmd/config.go

@@ -10,35 +10,74 @@ import (
 	"github.com/spf13/cobra"
 )
 
-// configCmd represents the config command
+// configCmd represents the config command and its subcommands.
+// It provides functionality for configuration file management including
+// generation and validation operations.
 var configCmd = &cobra.Command{
 	Use:   "config",
 	Short: "Configuration management commands",
+	Long: `Configuration management commands for Tunn tunneling tool.
+
+This command provides subcommands for:
+• Generating sample configuration files
+• Validating existing configuration files
+
+Use the subcommands to manage your Tunn configuration files effectively.`,
 }
 
+// generateCmd represents the config generate command.
+// It creates sample configuration files for different tunnel modes.
 var generateCmd = &cobra.Command{
 	Use:   "generate",
 	Short: "Generate a sample configuration file",
-	Long:  `Generate a sample configuration file with examples for all supported modes.`,
-	Run:   generateConfig,
+	Long: `Generate a sample configuration file with examples for all supported modes.
+
+The generated configuration file includes all available options with example values,
+making it easy to customize for your specific tunneling requirements.
+
+Supported modes:
+• direct: Direct connection with optional WebSocket upgrade
+• proxy: Connection through HTTP proxy with WebSocket upgrade
+
+Examples:
+  tunn config generate --mode direct --output config.json
+  tunn config generate --mode proxy --output proxy-config.json`,
+	Run: generateConfig,
 }
 
+// validateCmd represents the config validate command.
+// It validates the syntax and content of configuration files.
 var validateCmd = &cobra.Command{
 	Use:   "validate",
 	Short: "Validate configuration file",
-	Long:  `Validate the syntax and content of a configuration file.`,
-	Run:   validateConfig,
+	Long: `Validate the syntax and content of a configuration file.
+
+This command checks:
+• JSON syntax correctness
+• Required fields presence
+• Field value validity
+• Mode-specific configuration requirements
+
+The validation ensures your configuration file is ready for use with Tunn.
+
+Examples:
+  tunn config validate --config config.json
+  tunn config validate -c /path/to/config.json`,
+	Run: validateConfig,
 }
 
+// validateFlags holds the command-line flags for the validate subcommand.
 var validateFlags struct {
 	configPath string
 }
 
+// generateFlags holds the command-line flags for the generate subcommand.
 var generateFlags struct {
 	output string
 	mode   string
 }
 
+// init initializes the config command and its subcommands with their respective flags.
 func init() {
 	rootCmd.AddCommand(configCmd)
 	configCmd.AddCommand(generateCmd)
@@ -51,6 +90,9 @@ func init() {
 	validateCmd.MarkFlagRequired("config")
 }
 
+// generateConfig generates a sample configuration file based on the specified mode.
+// It creates a configuration template with example values that users can customize
+// for their specific tunneling needs.
 func generateConfig(cmd *cobra.Command, args []string) {
 	var sampleConfig *config.Config
 
@@ -108,6 +150,9 @@ func generateConfig(cmd *cobra.Command, args []string) {
 	fmt.Printf("Success: Sample %s mode configuration generated: %s\n", generateFlags.mode, generateFlags.output)
 }
 
+// validateConfig validates an existing configuration file for syntax and content correctness.
+// It loads the configuration file and performs comprehensive validation checks to ensure
+// all required fields are present and valid for the specified tunnel mode.
 func validateConfig(cmd *cobra.Command, args []string) {
 	configPath := validateFlags.configPath
 	if configPath == "" {

cmd/root.go

@@ -1,3 +1,8 @@
+// Package cmd provides the command-line interface for the Tunn SSH tunneling tool.
+//
+// This package implements the CLI commands using the Cobra library, handling
+// configuration loading, command parsing, and tunnel management initialization.
+// It supports multiple subcommands for configuration management and tunnel operations.
 package cmd
 
 import (
@@ -12,14 +17,32 @@ import (
 )
 
 var (
-	configFile   string
+	// configFile holds the path to the configuration file specified by the user.
+	configFile string
+
+	// tunnelConfig contains the loaded and validated tunnel configuration.
 	tunnelConfig *config.Config
 )
 
-// rootCmd represents the base command when called without any subcommands
+// rootCmd represents the base command when called without any subcommands.
+// It loads the configuration file and starts the tunnel manager.
 var rootCmd = &cobra.Command{
-	Use:     "tunn",
-	Short:   "A powerful tunnel tool for secure connections",
+	Use:   "tunn",
+	Short: "A powerful tunnel tool for secure connections",
+	Long: `Tunn is a cross-platform SSH tunneling tool that creates secure connections
+through direct connections over WebSocket and HTTP proxies.
+
+Features:
+• Multiple tunnel modes: Direct connection and Proxy
+• WebSocket-based SSH tunnels for better bypass capabilities
+• SOCKS5 and HTTP proxy support
+• Domain spoofing capabilities
+• Cross-platform support (Windows, Linux, macOS)
+
+Examples:
+  tunn --config config.json
+  tunn config generate --mode direct --output myconfig.json
+  tunn config validate --config myconfig.json`,
 	Version: "v0.1.2",
 	PreRun: func(cmd *cobra.Command, args []string) {
 		var err error
@@ -32,19 +55,23 @@ var rootCmd = &cobra.Command{
 }
 
 // Execute adds all child commands to the root command and sets flags appropriately.
+// This is called by main.main(). It only needs to happen once to the rootCmd.
 func Execute() {
 	if err := rootCmd.Execute(); err != nil {
 		fmt.Println(err)
 		os.Exit(1)
 	}
 }
 
+// init initializes the root command with persistent flags and configuration.
 func init() {
 	rootCmd.PersistentFlags().StringVarP(&configFile, "config", "c", "config.json", "config file path")
 	rootCmd.CompletionOptions.DisableDefaultCmd = true
 	rootCmd.SetHelpCommand(&cobra.Command{Use: "no-help", Hidden: true})
 }
 
+// runTunnel is the main execution function that starts the tunnel manager
+// with the loaded configuration.
 func runTunnel(cmd *cobra.Command, args []string) {
 	fmt.Printf("Mode: %s\n", tunnelConfig.Mode)
 	fmt.Printf("\n")

internal/tunnel/manager.go

@@ -1,3 +1,12 @@
+// Package tunnel provides the core tunnel management functionality for Tunn.
+//
+// This package implements the tunnel lifecycle management, including connection
+// establishment, SSH client setup, and proxy server initialization. It coordinates
+// between the configuration, connection, SSH, and proxy packages to provide
+// a complete tunneling solution.
+//
+// The Manager type handles the entire tunnel lifecycle from initialization
+// through graceful shutdown, managing both SSH connections and local proxy servers.
 package tunnel
 
 import (
@@ -12,21 +21,47 @@ import (
 	"tunn/pkg/ssh"
 )
 
-// Manager manages the tunnel lifecycle
+// Manager manages the complete tunnel lifecycle including connection establishment,
+// SSH client setup, proxy server initialization, and graceful shutdown.
+//
+// The Manager coordinates between different components to provide a seamless
+// tunneling experience, handling both direct and proxy-based connection modes.
 type Manager struct {
-	config      *config.Config
-	sshClient   ssh.Client
-	proxyServer interface{} // Can be either SOCKS5 or HTTP proxy
+	config      *config.Config // The tunnel configuration
+	sshClient   ssh.Client     // SSH client for tunneling
+	proxyServer interface{}    // Local proxy server (SOCKS5 or HTTP)
 }
 
-// NewManager creates a new tunnel manager
+// NewManager creates a new tunnel manager with the provided configuration.
+//
+// The manager will use the configuration to determine the appropriate connection
+// method, SSH settings, and proxy type to establish.
+//
+// Parameters:
+//   - cfg: The tunnel configuration containing all necessary settings
+//
+// Returns:
+//   - *Manager: A new tunnel manager instance ready for startup
 func NewManager(cfg *config.Config) *Manager {
 	return &Manager{
 		config: cfg,
 	}
 }
 
-// Start starts the tunnel and proxy server
+// Start establishes the complete tunnel setup and starts all necessary services.
+//
+// This method performs the following operations in sequence:
+//  1. Establishes the base connection (direct or through proxy)
+//  2. Creates and initializes the SSH client over the connection
+//  3. Starts the SSH transport layer
+//  4. Launches the appropriate local proxy server (SOCKS5 or HTTP)
+//  5. Waits for shutdown signals to gracefully terminate
+//
+// The method blocks until a shutdown signal is received, making it suitable
+// for use in the main application loop.
+//
+// Returns:
+//   - error: An error if any step of the setup process fails
 func (m *Manager) Start() error {
 	// Establish connection
 	establisher, err := connection.GetEstablisher(m.config.Mode)
@@ -63,7 +98,18 @@ func (m *Manager) Start() error {
 	return nil
 }
 
-// startProxy starts the appropriate proxy server
+// startProxy initializes and starts the appropriate local proxy server based on configuration.
+//
+// This method creates either a SOCKS5 or HTTP proxy server according to the ProxyType
+// setting in the configuration. The proxy server will listen on the configured port
+// and forward connections through the established SSH tunnel.
+//
+// Supported proxy types:
+//   - "socks5" or "socks": Creates a SOCKS5 proxy server
+//   - "http": Creates an HTTP proxy server
+//
+// Returns:
+//   - error: An error if the proxy type is unsupported or proxy startup fails
 func (m *Manager) startProxy() error {
 	switch m.config.ProxyType {
 	case "socks5", "socks":
@@ -79,7 +125,14 @@ func (m *Manager) startProxy() error {
 	}
 }
 
-// waitForShutdown waits for shutdown signals
+// waitForShutdown blocks and waits for system shutdown signals to gracefully terminate the tunnel.
+//
+// This method listens for SIGINT (Ctrl+C) and SIGTERM signals, providing a clean
+// shutdown mechanism. When a signal is received, it closes the SSH client connection
+// and performs cleanup operations.
+//
+// The method blocks the calling goroutine until a shutdown signal is received,
+// making it suitable for use in the main application flow.
 func (m *Manager) waitForShutdown() {
 	sigChan := make(chan os.Signal, 1)
 	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)

main.go

@@ -1,7 +1,23 @@
+// Package main provides the entry point for the Tunn SSH tunneling tool.
+//
+// Tunn is a cross-platform SSH tunneling application that creates secure
+// connections through direct connections over WebSocket and HTTP proxies.
+// It supports both SOCKS5 and HTTP proxy modes for flexible tunneling solutions.
+//
+// Usage:
+//
+//	tunn --config config.json
+//	tunn config generate --mode direct
+//	tunn config validate --config myconfig.json
+//
+// For more information, see the README.md file or run:
+//
+//	tunn --help
 package main
 
 import "tunn/cmd"
 
+// main is the application entry point that delegates execution to the CLI command handler.
 func main() {
 	cmd.Execute()
 }