Update 'latest' tag using commit hash instead of version ref

README.md

@@ -10,19 +10,53 @@ A Go-based command-line tool to manage SSH tunnels. This tool allows you to:
 ## Installation
 
 ```
-go install github.com/yourusername/sshtunnel/cmd@latest
+go install git.mvl.sh/vleeuwenmenno/sshtunnel@latest
+```
+
+You can also install a specific version:
+
+```
+go install git.mvl.sh/vleeuwenmenno/sshtunnel@v1.0.0
 ```
 
 Or clone this repository and build it yourself:
 
 ```
-git clone https://github.com/yourusername/sshtunnel.git
+git clone https://git.mvl.sh/vleeuwenmenno/sshtunnel.git
 cd sshtunnel
-go build -o sshtunnel ./cmd
+make
+sudo make install
+```
+
+The build process will automatically include version information from git tags.
+
+## Uninstallation
+
+For installation using `go install`, run:
+
+```
+go clean -i git.mvl.sh/vleeuwenmenno/sshtunnel
+```
+
+For manual installation, run:
+
+```
+sudo make uninstall
 ```
 
 ## Usage
 
+### Showing version information
+
+```
+sshtunnel version
+```
+
+This will display the current version of sshtunnel along with build information.
+
+Options:
+- `-c, --check-updates`: Check for updates against the latest release
+
 ### Listing active tunnels
 
 ```
@@ -34,31 +68,31 @@ This will display all active SSH tunnels with their IDs, local ports, remote end
 ### Starting a new tunnel
 
 ```
-sshtunnel start -local 8080 -remote 80 -host example.com -server user@ssh-server.com
+sshtunnel start -l 8080 -r 80 -H example.com -s user@ssh-server.com
 ```
 
 Options:
-- `-local`: Local port to forward (required)
+- `-l`: Local port to forward (required)
-- `-remote`: Remote port to forward to (required)
+- `-r`: Remote port to forward to (required)
-- `-host`: Remote host to forward to (default: "localhost")
+- `-H`: Remote host to forward to (default: "localhost")
-- `-server`: SSH server address in the format user@host (required)
+- `-s`: SSH server address in the format user@host (required)
-- `-identity`: Path to SSH identity file (optional)
+- `-i`: Path to SSH identity file (optional)
 
 ### Stopping tunnels
 
 Stop a specific tunnel by ID:
 ```
-sshtunnel stop -id 1
+sshtunnel stop -i 1
 ```
 
 Stop all active tunnels:
 ```
-sshtunnel stop -all
+sshtunnel stop --all
 ```
 
 Options:
-- `-id`: ID of the tunnel to stop
+- `-i`: ID of the tunnel to stop
-- `-all`: Stop all tunnels
+- `--all`: Stop all tunnels
 
 ### Viewing traffic statistics
 
@@ -69,12 +103,12 @@ sshtunnel stats --all
 
 View statistics for a specific tunnel:
 ```
-sshtunnel stats --id 1
+sshtunnel stats -i 1
 ```
 
 Monitor tunnel traffic in real-time:
 ```
-sshtunnel stats --id 1 --watch
+sshtunnel stats -i 1 --watch
 ```
 
 Options:
@@ -96,6 +130,58 @@ This command will:
 3. Validate all recorded tunnels and their current state
 4. Show active SSH tunnel processes and their status
 
+### Version information
+
+```
+sshtunnel version --check-updates
+```
+
+This displays version information and checks for updates to the tool. 
+
+When a new version is available, you'll get instructions on how to update.
+
+### Shell completion
+
+Generate shell completion scripts:
+
+```
+# Bash
+sshtunnel completion bash > ~/.bash_completion.d/sshtunnel
+source ~/.bash_completion.d/sshtunnel
+
+# Zsh
+sshtunnel completion zsh > "${fpath[1]}/_sshtunnel"
+
+# Fish
+sshtunnel completion fish > ~/.config/fish/completions/sshtunnel.fish
+```
+
+For system-wide installation:
+```
+# Bash (Linux)
+sudo sshtunnel completion bash > /etc/bash_completion.d/sshtunnel
+
+# Bash (macOS with Homebrew)
+sshtunnel completion bash > $(brew --prefix)/etc/bash_completion.d/sshtunnel
+```
+
+## Development
+
+### Release Process
+
+The project includes a release script to help manage version tags:
+
+```
+./bin/scripts/release.sh
+```
+
+This script will:
+1. Find the latest version tag
+2. Suggest the next patch version (e.g., v1.0.0 → v1.0.1)
+3. Allow you to accept this suggestion or enter a custom version
+4. Create and push the new tag
+5. Update the "latest" tag to point to the new version
+
 ## How it works
 
 The tool creates SSH tunnels using the system's SSH client and manages them by tracking their process IDs in a hidden directory (`~/.sshtunnels/`). Each tunnel is assigned a unique ID for easy management. Traffic statistics are collected and stored to help you monitor data transfer through your tunnels.

bin/scripts/build-binary.sh

@@ -28,8 +28,12 @@ if [ -n "$(git status --porcelain)" ]; then
     POSTFIX=" (dirty)"
 fi
 
+# Format a clean version string for the build
+VERSION=$(echo "$BRANCH" | sed 's/^v//')
+BUILD_DATE=$(date -u '+%Y-%m-%d %H:%M:%S')
+
 printfe "%s\n" "cyan" "Building $BINARY_NAME binary for $BRANCH ($LATEST_COMMIT_HASH)$POSTFIX..."
-go build -o $BINARY_PATH
+go build -ldflags="-X 'git.mvl.sh/vleeuwenmenno/sshtunnel/cmd.Version=$BRANCH' -X 'git.mvl.sh/vleeuwenmenno/sshtunnel/cmd.BuildDate=$BUILD_DATE'" -o $BINARY_PATH
 
 if [ $? -ne 0 ]; then
     printf "\033[0;31m"
@@ -39,9 +43,9 @@ if [ $? -ne 0 ]; then
 fi
 
 # Put tag and hash in .sshtunnel_version file
-echo "$BRANCH ($LATEST_COMMIT_HASH)$POSTFIX" > $BINARY_PATH_VERSION
+echo "$BRANCH" > $BINARY_PATH_VERSION
 
-printfe "%s\n" "cyan" "Generating Bash completion script..."
+printfe "%s\n" "cyan" "Generating completion scripts..."
 $BINARY_PATH completion bash > $COMPLETION_SCRIPT
 
 printfe "%s\n" "green" "Bash completion script installed to $COMPLETION_SCRIPT."

bin/scripts/release.sh

@@ -0,0 +1,90 @@
+#!/usr/bin/env bash
+
+source bin/helpers/func.sh
+
+printfe "%s\n" "green" "SSH Tunnel Manager Release Script"
+printfe "%s\n" "normal" "==============================="
+
+# Check if git is installed
+if ! command -v git &> /dev/null; then
+    printfe "%s\n" "red" "Error: git is not installed"
+    exit 1
+fi
+
+# Check if we're in a git repository
+if ! git rev-parse --is-inside-work-tree &> /dev/null; then
+    printfe "%s\n" "red" "Error: Not in a git repository"
+    exit 1
+fi
+
+# Fetch all tags first to ensure we have the latest
+printfe "%s\n" "cyan" "Fetching all tags..."
+log_and_run git fetch --tags
+
+# Get the latest version tag, excluding 'latest' tag, or default to v0.0.0 if no tags exist
+VERSION_TAGS=$(git tag -l 'v*.*.*' | grep -v 'latest' | sort -V)
+if [ -z "$VERSION_TAGS" ]; then
+    printfe "%s\n" "yellow" "No version tags found. Starting with v0.0.0."
+    LATEST_TAG="v0.0.0"
+else
+    # Get the latest version tag
+    LATEST_TAG=$(echo "$VERSION_TAGS" | tail -n 1)
+    printfe "%s" "cyan" "Found latest version tag: "
+    printfe "%s\n" "yellow" "$LATEST_TAG" false
+fi
+
+# Parse the version number
+if [[ $LATEST_TAG =~ ^v([0-9]+)\.([0-9]+)\.([0-9]+)$ ]]; then
+    MAJOR=${BASH_REMATCH[1]}
+    MINOR=${BASH_REMATCH[2]}
+    PATCH=${BASH_REMATCH[3]}
+else
+    printfe "%s\n" "red" "Error: Could not parse latest tag: $LATEST_TAG"
+    exit 1
+fi
+
+# Calculate the next patch version
+NEXT_PATCH=$((PATCH + 1))
+NEXT_VERSION="v$MAJOR.$MINOR.$NEXT_PATCH"
+
+# Display current version and suggested next version
+printfe "%s" "cyan" "Current version: "
+printfe "%s\n" "yellow" "$LATEST_TAG" false
+printfe "%s" "cyan" "Suggested next version: "
+printfe "%s\n" "yellow" "$NEXT_VERSION" false
+
+# Ask for confirmation or custom version
+read -p "Accept suggested version? (y/n) " ACCEPT
+if [[ $ACCEPT != "y" && $ACCEPT != "Y" ]]; then
+    read -p "Enter custom version (format vX.Y.Z): " CUSTOM_VERSION
+    if [[ $CUSTOM_VERSION =~ ^v([0-9]+)\.([0-9]+)\.([0-9]+)$ ]]; then
+        NEXT_VERSION=$CUSTOM_VERSION
+    else
+        printfe "%s\n" "red" "Error: Invalid version format. Must be vX.Y.Z where X, Y, Z are numbers."
+        exit 1
+    fi
+fi
+
+printfe "%s" "cyan" "Creating and pushing tag: "
+printfe "%s\n" "yellow" "$NEXT_VERSION" false
+
+# Make sure we have the latest changes
+# We've already fetched tags at the beginning
+
+# Create the new tag
+printfe "%s\n" "cyan" "Creating new tag..."
+log_and_run git tag "$NEXT_VERSION"
+
+# Push the new tag
+printfe "%s\n" "cyan" "Pushing new tag..."
+log_and_run git push origin "$NEXT_VERSION"
+
+# Update the latest tag
+printfe "%s\n" "cyan" "Updating 'latest' tag..."
+# Get the commit that the new version tag points to
+COMMIT_HASH=$(git rev-parse "$NEXT_VERSION")
+log_and_run git tag -f latest "$COMMIT_HASH"
+log_and_run git push -f origin latest
+
+printfe "%s\n" "green" "Successfully tagged and pushed version $NEXT_VERSION"
+printfe "%s\n" "cyan" "Also updated 'latest' tag to point to $NEXT_VERSION"

cmd/start.go

@@ -8,8 +8,8 @@ import (
 	"strings"
 	"time"
 
+	"git.mvl.sh/vleeuwenmenno/sshtunnel/pkg/stats"
 	"github.com/spf13/cobra"
-	"sshtunnel/pkg/stats"
 )
 
 var (

cmd/stats.go

@@ -5,8 +5,8 @@ import (
 	"os"
 	"time"
 
-	"sshtunnel/pkg/monitor"
+	"git.mvl.sh/vleeuwenmenno/sshtunnel/pkg/monitor"
-	"sshtunnel/pkg/stats"
+	"git.mvl.sh/vleeuwenmenno/sshtunnel/pkg/stats"
 
 	"github.com/spf13/cobra"
 )

cmd/stop.go

@@ -5,8 +5,8 @@ import (
 	"os"
 	"syscall"
 
+	"git.mvl.sh/vleeuwenmenno/sshtunnel/pkg/stats"
 	"github.com/spf13/cobra"
-	"sshtunnel/pkg/stats"
 )
 
 var (

cmd/version.go

@@ -0,0 +1,216 @@
+package cmd
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+	"time"
+
+	"github.com/spf13/cobra"
+)
+
+var (
+	// Version is set during build
+	Version = "dev"
+
+	// BuildDate is set during build
+	BuildDate = ""
+
+	// For go install builds, this will be the go.mod version
+	versionFromMod = "$GOFLAGS: -ldflags=-X git.mvl.sh/vleeuwenmenno/sshtunnel/cmd.Version=${VERSION}"
+
+	checkForUpdates bool
+)
+
+var versionCmd = &cobra.Command{
+	Use:   "version",
+	Short: "Show sshtunnel version information",
+	Long:  `Display the current version of sshtunnel and check for updates.`,
+	Run: func(cmd *cobra.Command, args []string) {
+		// Display current version
+		showVersion()
+
+		// Check for updates if requested
+		if checkForUpdates {
+			checkUpdate()
+		}
+	},
+}
+
+func init() {
+	rootCmd.AddCommand(versionCmd)
+	versionCmd.Flags().BoolVarP(&checkForUpdates, "check-updates", "c", false, "Check for updates")
+
+	// If version is still "dev", try to read from other sources
+	if Version == "dev" {
+		// Check if version was injected via go install's version info
+		if strings.Contains(versionFromMod, "${VERSION}") {
+			// Not replaced, try to read from the installed version file
+			Version = readInstalledVersion()
+		} else {
+			// Extract version from the injected string
+			re := regexp.MustCompile(`Version=(.+)$`)
+			matches := re.FindStringSubmatch(versionFromMod)
+			if len(matches) > 1 {
+				Version = matches[1]
+			} else {
+				// Fall back to reading from installed file
+				Version = readInstalledVersion()
+			}
+		}
+	}
+}
+
+func showVersion() {
+	fmt.Printf("sshtunnel %s\n", Version)
+	if BuildDate != "" {
+		fmt.Printf("Build date: %s\n", BuildDate)
+	}
+	fmt.Printf("Go version: %s\n", runtime.Version())
+	fmt.Printf("OS/Arch: %s/%s\n", runtime.GOOS, runtime.GOARCH)
+}
+
+func readInstalledVersion() string {
+	// Check system-installed version file first
+	versionFile := "/usr/local/share/sshtunnel/sshtunnel.version"
+	if _, err := os.Stat(versionFile); err == nil {
+		content, err := os.ReadFile(versionFile)
+		if err == nil {
+			return strings.TrimSpace(string(content))
+		}
+	}
+
+	// Try user's home directory for go install version
+	homeDir, err := os.UserHomeDir()
+	if err == nil {
+		goPath := filepath.Join(homeDir, "go", "pkg", "mod", "git.mvl.sh", "vleeuwenmenno", "sshtunnel@*")
+		matches, err := filepath.Glob(goPath)
+		if err == nil && len(matches) > 0 {
+			// Sort matches to get the latest version
+			// Example: .../sshtunnel@v1.0.0 -> extract v1.0.0
+			latestMatch := matches[len(matches)-1]
+			parts := strings.Split(filepath.Base(latestMatch), "@")
+			if len(parts) > 1 {
+				return parts[1]
+			}
+		}
+	}
+
+	// Check if executable name has version info
+	execPath, err := os.Executable()
+	if err == nil {
+		execName := filepath.Base(execPath)
+		if strings.Contains(execName, "sshtunnel-v") {
+			parts := strings.Split(execName, "-v")
+			if len(parts) > 1 {
+				return "v" + parts[1]
+			}
+		}
+		
+		// Check if it's in GOBIN with a version suffix
+		re := regexp.MustCompile(`sshtunnel@(v[0-9]+\.[0-9]+\.[0-9]+)$`)
+		matches := re.FindStringSubmatch(execName)
+		if len(matches) > 1 {
+			return matches[1]
+		}
+	}
+
+	// Default version if we couldn't find any version information
+	return "dev"
+}
+
+func checkUpdate() {
+	fmt.Println("\nChecking for updates...")
+	client := http.Client{
+		Timeout: 5 * time.Second,
+	}
+
+	resp, err := client.Get("https://git.mvl.sh/api/v1/repos/vleeuwenmenno/sshtunnel/tags")
+	if err != nil {
+		fmt.Printf("Error checking for updates: %s\n", err)
+		return
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		fmt.Printf("Error reading response: %s\n", err)
+		return
+	}
+
+	var tags []struct {
+		Name string `json:"name"`
+	}
+	if err := json.Unmarshal(body, &tags); err != nil {
+		fmt.Printf("Error parsing response: %s\n", err)
+		return
+	}
+
+	// Find the latest version tag
+	var latestTag string
+	for _, tag := range tags {
+		if strings.HasPrefix(tag.Name, "v") && (latestTag == "" || compareVersions(tag.Name, latestTag) > 0) {
+			latestTag = tag.Name
+		}
+	}
+
+	if latestTag == "" {
+		fmt.Println("No version tags found in the repository")
+		return
+	}
+
+	// Compare with current version
+	if compareVersions(latestTag, Version) > 0 {
+		fmt.Printf("A newer version is available: %s (you have %s)\n", latestTag, Version)
+		fmt.Println("To update, run: go install git.mvl.sh/vleeuwenmenno/sshtunnel@latest")
+	} else {
+		fmt.Println("You are running the latest version")
+	}
+}
+
+// compareVersions compares two semantic version strings (v1.2.3)
+// returns:  1 if v1 > v2
+//          -1 if v1 < v2
+//           0 if v1 == v2
+func compareVersions(v1, v2 string) int {
+	// Remove 'v' prefix if any
+	v1 = strings.TrimPrefix(v1, "v")
+	v2 = strings.TrimPrefix(v2, "v")
+
+	// Split into parts
+	parts1 := strings.Split(v1, ".")
+	parts2 := strings.Split(v2, ".")
+
+	// Compare each part
+	for i := 0; i < len(parts1) && i < len(parts2); i++ {
+		// Skip non-numeric parts (like pre-release suffixes)
+		num1 := 0
+		fmt.Sscanf(parts1[i], "%d", &num1)
+		
+		num2 := 0
+		fmt.Sscanf(parts2[i], "%d", &num2)
+
+		if num1 > num2 {
+			return 1
+		}
+		if num1 < num2 {
+			return -1
+		}
+	}
+
+	// If we get here, the common parts are equal
+	if len(parts1) > len(parts2) {
+		return 1
+	}
+	if len(parts1) < len(parts2) {
+		return -1
+	}
+
+	return 0
+}

go.mod

@@ -1,4 +1,4 @@
-module sshtunnel
+module git.mvl.sh/vleeuwenmenno/sshtunnel
 
 go 1.22.2
 

main.go

@@ -4,7 +4,7 @@ import (
 	"fmt"
 	"os"
 
-	"sshtunnel/cmd"
+	"git.mvl.sh/vleeuwenmenno/sshtunnel/cmd"
 )
 
 func main() {

pkg/monitor/monitor.go

@@ -8,7 +8,7 @@ import (
 	"strings"
 	"time"
 
-	"sshtunnel/pkg/stats"
+	"git.mvl.sh/vleeuwenmenno/sshtunnel/pkg/stats"
 )
 
 // Monitor represents a SSH tunnel traffic monitor