diff --git a/README.md b/README.md index cc1d7da..1d7b1e1 100644 --- a/README.md +++ b/README.md @@ -2,7 +2,9 @@
-**SSH-First GitHub Account Management - Clean, Fast, and Isolated** +**SSH-First Multi-Platform Account Management - Clean, Fast, and Isolated** + +*Now supporting GitHub, GitLab, and more!* [![Go Version](https://img.shields.io/badge/Go-1.23+-blue)](https://golang.org/doc/devel/release.html) [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) @@ -23,6 +25,7 @@ - [Overview](#-overview) - [The Problem](#-the-problem-we-solve) - [Features](#-features) +- [Multi-Platform Support](#-multi-platform-support) - [How It Works](#-how-it-works) - [Installation](#-installation) - [Quick Start](#-quick-start) @@ -38,18 +41,19 @@ ## 🎯 Overview -**gitshift** is a clean, focused CLI tool for managing multiple GitHub accounts with **complete SSH isolation**. No GitHub API dependencies, no complex TUI interfaces - just pure SSH-based account management that works. +**gitshift** is a clean, focused CLI tool for managing multiple Git accounts across **GitHub, GitLab, and other platforms** with **complete SSH isolation**. No complex API dependencies, no TUI interfaces - just pure SSH-based account management that works everywhere. ### Why gitshift? -Managing multiple GitHub accounts (work, personal, client projects) traditionally requires: -- Manual SSH config editing +Managing multiple Git accounts across different platforms (work GitHub, personal GitLab, client projects) traditionally requires: +- Manual SSH config editing for each platform - Complex git configuration management -- Constant context switching +- Constant context switching between accounts - Risk of pushing to wrong accounts - SSH key conflicts and authentication failures +- Platform-specific authentication setup -**gitshift eliminates all of this** with a simple, SSH-first approach. +**gitshift eliminates all of this** with a simple, SSH-first, multi-platform approach. --- @@ -57,10 +61,10 @@ Managing multiple GitHub accounts (work, personal, client projects) traditionall ```mermaid graph TD - A[Developer] -->|Switches Context| B{Multiple GitHub Accounts} - B -->|Work Account| C[❌ Wrong SSH Key Used] - B -->|Personal Account| D[❌ Git Config Conflict] - B -->|Client Account| E[❌ Authentication Failure] + A[Developer] -->|Switches Context| B{Multiple Git Accounts} + B -->|Work GitHub| C[❌ Wrong SSH Key Used] + B -->|Personal GitLab| D[❌ Git Config Conflict] + B -->|Client GitHub| E[❌ Authentication Failure] C --> F[😤 Commit to Wrong Account] D --> G[😤 Wrong Email in Commits] @@ -91,13 +95,15 @@ graph TD ### Core Capabilities -- 🔐 **SSH-Only Approach** - No GitHub API dependencies required -- 🔄 **Complete Isolation** - Accounts never interfere with each other -- 🔑 **Smart SSH Management** - Auto-generates and manages SSH keys +- 🌍 **Multi-Platform Support** - GitHub, GitLab, Bitbucket, and self-hosted +- 🔐 **SSH-First Approach** - Minimal API dependencies, works everywhere +- 🔄 **Complete Isolation** - Accounts never interfere across platforms +- 🔑 **Smart SSH Management** - Auto-generates and manages SSH keys per platform - ⚡ **Fast Switching** - Instant account transitions with validation -- 🛡️ **Secure by Design** - SSH config with `IdentitiesOnly=yes` -- 🌐 **Known Hosts Management** - Auto-manages GitHub host keys +- 🛡️ **Secure by Design** - Platform-specific SSH configs with `IdentitiesOnly=yes` +- 🌐 **Known Hosts Management** - Auto-manages host keys for all platforms - 📋 **Auto Key Management** - Adds keys to ssh-agent and clipboard +- 🔍 **Auto Platform Detection** - Detects platform from repository URLs - 🔍 **Account Discovery** - Finds existing SSH keys automatically ### Implemented Commands @@ -118,6 +124,42 @@ All features documented below are **verified and implemented** in the codebase: --- +## 🌍 Multi-Platform Support + +gitshift supports multiple Git hosting platforms out of the box: + +### Supported Platforms + +| Platform | Status | SSH | API | Notes | +|----------|--------|-----|-----|-------| +| **GitHub** | ✅ Full | ✅ | ✅ | Complete support | +| **GitHub Enterprise** | ✅ Full | ✅ | ✅ | Custom domains supported | +| **GitLab** | ✅ SSH | ✅ | ⚠️ | API in progress | +| **GitLab Self-Hosted** | ✅ SSH | ✅ | ⚠️ | Custom domains supported | +| **Bitbucket** | 🚧 Planned | - | - | Coming soon | + +### Platform-Specific Examples + +```bash +# Add GitHub account +gitshift add personal --platform github --email john@personal.com + +# Add GitLab account +gitshift add gitlab-personal --platform gitlab --email john@personal.com + +# Add self-hosted GitLab +gitshift add company-gitlab --platform gitlab --domain gitlab.company.com + +# Switch between platforms +gitshift switch personal # GitHub account +gitshift switch gitlab-personal # GitLab account +gitshift switch company-gitlab # Self-hosted GitLab +``` + +**See detailed documentation:** [docs/MULTI_PLATFORM_SUPPORT.md](docs/MULTI_PLATFORM_SUPPORT.md) + +--- + ## 🔄 How It Works ### Account Switching Flow @@ -129,16 +171,16 @@ sequenceDiagram participant SSH Config participant Git Config participant SSH Agent - participant GitHub + participant Platform User->>gitshift: gitshift switch work - gitshift->>gitshift: Validate account exists - gitshift->>SSH Config: Update ~/.ssh/config + gitshift->>gitshift: Validate account & detect platform + gitshift->>SSH Config: Update ~/.ssh/config (platform-specific) gitshift->>Git Config: Set user.name & user.email gitshift->>SSH Agent: Clear old keys - gitshift->>SSH Agent: Load work SSH key - gitshift->>GitHub: Test SSH connection - GitHub-->>gitshift: Authentication successful + gitshift->>SSH Agent: Load account SSH key + gitshift->>Platform: Test SSH connection + Platform-->>gitshift: Authentication successful gitshift-->>User: ✅ Switched to work account ``` diff --git a/docs/CONFIGURATION.md b/docs/CONFIGURATION.md index 40ebbf4..c0c69d4 100644 --- a/docs/CONFIGURATION.md +++ b/docs/CONFIGURATION.md @@ -89,7 +89,11 @@ config_version: "1.0.0" | `name` | string | ✅ | Git user.name | | `email` | string | ✅ | Git user.email (must be valid email) | | `ssh_key_path` | string | ❌ | Path to SSH private key file | -| `github_username` | string | ✅ | GitHub username | +| `platform` | string | ❌ | Platform type: `github`, `gitlab`, `bitbucket` (default: `github`) | +| `domain` | string | ❌ | Platform domain (e.g., `github.com`, `gitlab.company.com`) | +| `username` | string | ✅ | Platform-specific username | +| `github_username` | string | ⚠️ | **Deprecated:** Use `username` with `platform: github` | +| `api_endpoint` | string | ❌ | Custom API endpoint for self-hosted platforms | | `description` | string | ❌ | Human-readable description | | `is_default` | boolean | ❌ | Whether this is the default account | | `status` | string | ❌ | Account status (active, pending, disabled) | @@ -147,6 +151,177 @@ client-project: is_default: false status: active created_at: "2025-01-15T12:00:00Z" +``` + +--- + +## 🌍 **Multi-Platform Configuration** + +gitshift supports multiple Git hosting platforms including GitHub, GitLab, GitHub Enterprise, and self-hosted instances. + +### **Supported Platforms** + +| Platform | Value | SSH Support | API Support | Notes | +|----------|-------|-------------|-------------|-------| +| GitHub | `github` | ✅ Full | ✅ Full | Default platform | +| GitHub Enterprise | `github` | ✅ Full | ✅ Full | Requires custom domain | +| GitLab | `gitlab` | ✅ Full | ⚠️ Basic | SSH fully functional | +| GitLab Self-Hosted | `gitlab` | ✅ Full | ⚠️ Basic | Requires custom domain | +| Bitbucket | `bitbucket` | 🚧 Planned | 🚧 Planned | Coming soon | + +### **Platform-Specific Account Examples** + +#### **GitHub Account (Default)** +```yaml +personal-github: + alias: personal-github + name: John Doe + email: john@personal.com + ssh_key_path: ~/.ssh/id_ed25519_github_personal + platform: github # Can be omitted, defaults to github + username: johndoe + description: Personal GitHub account + is_default: true +``` + +#### **GitLab Account** +```yaml +personal-gitlab: + alias: personal-gitlab + name: John Doe + email: john@personal.com + ssh_key_path: ~/.ssh/id_ed25519_gitlab_personal + platform: gitlab + username: johndoe + domain: gitlab.com # Optional for gitlab.com + description: Personal GitLab account +``` + +#### **GitHub Enterprise** +```yaml +work-github: + alias: work-github + name: John Doe + email: john@company.com + ssh_key_path: ~/.ssh/id_ed25519_github_enterprise + platform: github + username: jdoe + domain: github.company.com # Required for enterprise + api_endpoint: https://github.company.com/api/v3 # Optional + description: Work GitHub Enterprise account +``` + +#### **Self-Hosted GitLab** +```yaml +company-gitlab: + alias: company-gitlab + name: John Doe + email: john@company.com + ssh_key_path: ~/.ssh/id_ed25519_gitlab_company + platform: gitlab + username: jdoe + domain: gitlab.company.com # Required for self-hosted + api_endpoint: https://gitlab.company.com/api/v4 # Optional + description: Company GitLab instance +``` + +### **Multi-Platform Configuration Example** + +Complete configuration with multiple platforms: + +```yaml +accounts: + # GitHub accounts + personal-github: + alias: personal-github + platform: github + username: johndoe + name: John Doe + email: john@personal.com + ssh_key_path: ~/.ssh/id_ed25519_github_personal + is_default: true + + work-github: + alias: work-github + platform: github + username: jdoe-work + name: John Doe + email: john@work.com + ssh_key_path: ~/.ssh/id_ed25519_github_work + + # GitLab accounts + personal-gitlab: + alias: personal-gitlab + platform: gitlab + username: johndoe + name: John Doe + email: john@personal.com + ssh_key_path: ~/.ssh/id_ed25519_gitlab_personal + + # Self-hosted GitLab + client-gitlab: + alias: client-gitlab + platform: gitlab + domain: gitlab.client.com + username: jdoe + name: John Doe + email: john@client.com + ssh_key_path: ~/.ssh/id_ed25519_gitlab_client + +current_account: personal-github +``` + +### **Platform Detection** + +gitshift automatically detects the platform from repository URLs: + +```bash +# GitHub +git@github.com:user/repo.git → Platform: github +https://github.com/user/repo.git → Platform: github + +# GitLab +git@gitlab.com:user/repo.git → Platform: gitlab +https://gitlab.com/user/repo.git → Platform: gitlab + +# Self-hosted +git@gitlab.company.com:user/repo.git → Platform: gitlab (custom domain) +``` + +### **Platform Usage Examples** + +```bash +# Add GitHub account +gitshift add personal --platform github --email john@personal.com + +# Add GitLab account +gitshift add gitlab-personal --platform gitlab --email john@gitlab.com + +# Add self-hosted GitLab +gitshift add company-gitlab \ + --platform gitlab \ + --domain gitlab.company.com \ + --email john@company.com + +# Switch between platforms +gitshift switch personal-github # GitHub +gitshift switch gitlab-personal # GitLab +gitshift switch company-gitlab # Self-hosted GitLab +``` + +### **Backward Compatibility** + +Existing GitHub-only configurations work without changes: + +```yaml +# Old format (still works) +personal: + alias: personal + github_username: johndoe # Automatically mapped to username + # platform defaults to github +``` + +**Migration:** No action required. Add `platform` and `username` fields when convenient last_used: "2025-01-16T07:30:00Z" ``` diff --git a/docs/README.md b/docs/README.md index c64de80..3a0ad44 100644 --- a/docs/README.md +++ b/docs/README.md @@ -19,11 +19,12 @@ This documentation provides comprehensive guides for using, configuring, and con ### **⚙️ Configuration & Setup** - **[Configuration Guide](CONFIGURATION.md)** - Detailed configuration options +- **[Multi-Platform Configuration](CONFIGURATION.md#-multi-platform-configuration)** - GitHub, GitLab, and more - **[Environment Variables](CONFIGURATION.md#environment-variables)** - Environment setup - **[SSH Configuration](CONFIGURATION.md#ssh-configuration)** - SSH setup and management ### **🔧 Usage & Features** -- **[Account Management](USER_GUIDE.md#account-management)** - Managing GitHub accounts +- **[Account Management](USER_GUIDE.md#account-management)** - Managing Git accounts across platforms - **[SSH Key Management](USER_GUIDE.md#ssh-key-management)** - SSH key operations - **[Account Switching](USER_GUIDE.md#account-switching)** - Switching between accounts - **[Diagnostics](USER_GUIDE.md#diagnostics--health-checks)** - System health checks diff --git a/examples/config-multi-platform.yaml b/examples/config-multi-platform.yaml new file mode 100644 index 0000000..4990f27 --- /dev/null +++ b/examples/config-multi-platform.yaml @@ -0,0 +1,142 @@ +# Example gitshift configuration with multi-platform support +# This shows how to configure accounts for GitHub, GitLab, and custom Git hosting platforms + +config_version: "1.0.0" +global_git_config: true +auto_detect: true + +accounts: + # GitHub account (default platform) + personal-github: + alias: personal-github + name: John Doe + email: john@personal.com + ssh_key_path: ~/.ssh/id_ed25519_github_personal + platform: github # Explicitly specify GitHub + username: johndoe # GitHub username + domain: github.com # Optional: defaults to github.com for GitHub platform + description: Personal GitHub account + is_default: true + status: active + isolation_level: standard + + # Work GitHub account + work-github: + alias: work-github + name: John Doe + email: john.doe@company.com + ssh_key_path: ~/.ssh/id_ed25519_github_work + platform: github + username: johndoe-work + domain: github.com + description: Work GitHub account + is_default: false + status: active + isolation_level: standard + + # GitHub Enterprise account + enterprise-github: + alias: enterprise-github + name: John Doe + email: john.doe@enterprise.com + ssh_key_path: ~/.ssh/id_ed25519_github_enterprise + platform: github + username: jdoe + domain: github.enterprise.com # Custom GitHub Enterprise domain + api_endpoint: https://github.enterprise.com/api/v3 # Optional: custom API endpoint + description: GitHub Enterprise account + is_default: false + status: active + isolation_level: standard + + # GitLab.com account + personal-gitlab: + alias: personal-gitlab + name: John Doe + email: john@personal.com + ssh_key_path: ~/.ssh/id_ed25519_gitlab_personal + platform: gitlab # GitLab platform + username: johndoe + domain: gitlab.com # Optional: defaults to gitlab.com for GitLab platform + description: Personal GitLab account + is_default: false + status: active + isolation_level: standard + + # Self-hosted GitLab account + company-gitlab: + alias: company-gitlab + name: John Doe + email: john.doe@company.com + ssh_key_path: ~/.ssh/id_ed25519_gitlab_company + platform: gitlab + username: jdoe + domain: gitlab.company.com # Self-hosted GitLab domain + api_endpoint: https://gitlab.company.com/api/v4 # Optional: custom API endpoint + description: Company self-hosted GitLab + is_default: false + status: active + isolation_level: standard + + # Legacy GitHub account (backward compatibility) + # Accounts without platform field default to GitHub + legacy-account: + alias: legacy-account + name: Jane Smith + email: jane@example.com + ssh_key_path: ~/.ssh/id_rsa_github_legacy + github_username: janesmith # Old field name, still supported + description: Legacy GitHub account (backward compatible) + is_default: false + status: active + isolation_level: basic + +# Current active account +current_account: personal-github + +--- + +# Usage Examples: + +# 1. Switch to GitHub account: +# gitshift switch personal-github + +# 2. Switch to GitLab account: +# gitshift switch personal-gitlab + +# 3. Switch to self-hosted GitLab: +# gitshift switch company-gitlab + +# 4. Add new GitHub account: +# gitshift add work-backup --name "John Doe" --email john@work.com --platform github + +# 5. Add new GitLab account: +# gitshift add freelance --name "John Doe" --email john@freelance.com --platform gitlab + +# 6. Add self-hosted GitLab account: +# gitshift add client-gitlab --name "John Doe" --email john@client.com --platform gitlab --domain gitlab.client.com + +# 7. List all accounts (shows platform for each): +# gitshift list + +# 8. Clone repository with specific account (auto-detects platform): +# gitshift clone git@github.com:user/repo.git personal-github +# gitshift clone git@gitlab.com:user/repo.git personal-gitlab + +# Platform Detection: +# - gitshift automatically detects the platform from repository URLs +# - SSH URLs: git@github.com:user/repo.git -> GitHub +# - SSH URLs: git@gitlab.com:user/repo.git -> GitLab +# - HTTPS URLs: https://github.com/user/repo.git -> GitHub +# - HTTPS URLs: https://gitlab.com/user/repo.git -> GitLab +# - Custom domains are detected based on the account configuration + +# SSH Configuration: +# - gitshift creates platform-specific SSH configs for each account +# - Each platform (GitHub, GitLab, etc.) gets its own SSH Host entry +# - Multiple accounts on the same platform are managed via SSH key isolation + +# Backward Compatibility: +# - Existing configurations without 'platform' field default to GitHub +# - 'github_username' field is still supported (mapped to 'username') +# - All existing gitshift commands continue to work as before diff --git a/internal/git/git.go b/internal/git/git.go index 1ddbe76..812a1a8 100644 --- a/internal/git/git.go +++ b/internal/git/git.go @@ -244,31 +244,78 @@ func (m *Manager) SetRemoteURL(remoteName, repoURL string) error { // normalizeURL ensures the URL uses the appropriate protocol func (m *Manager) normalizeURL(url string) string { - // Extract the repo path from any format - var repoPath string - - if strings.HasPrefix(url, "git@github.com:") { - // SSH format: git@github.com:user/repo.git - repoPath = strings.TrimPrefix(url, "git@github.com:") - } else if strings.HasPrefix(url, "https://github.com/") { - // HTTPS format: https://github.com/user/repo.git - repoPath = strings.TrimPrefix(url, "https://github.com/") - } else { + // Detect the platform from the URL + domain := m.extractDomain(url) + if domain == "" { // Unknown format, return as-is return url } + // Extract the repo path from any format + repoPath := m.extractRepoPath(url, domain) + if repoPath == "" { + return url + } + // Remove .git suffix if present repoPath = strings.TrimSuffix(repoPath, ".git") // Return in the appropriate format if m.useSSH { - return fmt.Sprintf("git@github.com:%s.git", repoPath) + return fmt.Sprintf("git@%s:%s.git", domain, repoPath) } else { - return fmt.Sprintf("https://github.com/%s.git", repoPath) + return fmt.Sprintf("https://%s/%s.git", domain, repoPath) } } +// extractDomain extracts the domain from a Git URL +func (m *Manager) extractDomain(url string) string { + // SSH format: git@domain:path + if strings.HasPrefix(url, "git@") { + parts := strings.Split(url, ":") + if len(parts) >= 2 { + return strings.TrimPrefix(parts[0], "git@") + } + } + + // HTTPS format: https://domain/path + if strings.HasPrefix(url, "https://") || strings.HasPrefix(url, "http://") { + // Parse the URL to extract the host + if idx := strings.Index(url[8:], "/"); idx != -1 { + return url[8 : 8+idx] + } + } + + // Common Git hosting platforms + commonDomains := []string{"github.com", "gitlab.com", "bitbucket.org"} + for _, domain := range commonDomains { + if strings.Contains(url, domain) { + return domain + } + } + + return "" +} + +// extractRepoPath extracts the repository path from a URL given a domain +func (m *Manager) extractRepoPath(url, domain string) string { + // SSH format: git@domain:owner/repo.git + if strings.HasPrefix(url, fmt.Sprintf("git@%s:", domain)) { + return strings.TrimPrefix(url, fmt.Sprintf("git@%s:", domain)) + } + + // HTTPS format: https://domain/owner/repo.git + if strings.HasPrefix(url, fmt.Sprintf("https://%s/", domain)) { + return strings.TrimPrefix(url, fmt.Sprintf("https://%s/", domain)) + } + + if strings.HasPrefix(url, fmt.Sprintf("http://%s/", domain)) { + return strings.TrimPrefix(url, fmt.Sprintf("http://%s/", domain)) + } + + return "" +} + // GetCurrentRemoteURL gets the current remote URL func (m *Manager) GetCurrentRemoteURL(remoteName string) (string, error) { cmd := exec.Command("git", "remote", "get-url", remoteName) @@ -338,14 +385,21 @@ func (m *Manager) SafeFetch(remoteName string) error { return nil } -// convertToHTTPS converts any GitHub URL to HTTPS format +// convertToHTTPS converts any Git SSH URL to HTTPS format func (m *Manager) convertToHTTPS(url string) string { - if strings.HasPrefix(url, "git@github.com:") { - repoPath := strings.TrimPrefix(url, "git@github.com:") - repoPath = strings.TrimSuffix(repoPath, ".git") - return fmt.Sprintf("https://github.com/%s.git", repoPath) + // Extract domain and repo path + domain := m.extractDomain(url) + if domain == "" { + return url } - return url + + repoPath := m.extractRepoPath(url, domain) + if repoPath == "" { + return url + } + + repoPath = strings.TrimSuffix(repoPath, ".git") + return fmt.Sprintf("https://%s/%s.git", domain, repoPath) } // SetUserConfig sets the git user configuration diff --git a/internal/models/account.go b/internal/models/account.go index aa3f4ce..d4d01a7 100644 --- a/internal/models/account.go +++ b/internal/models/account.go @@ -22,8 +22,22 @@ type Account struct { // SSHKeyPath is the path to the SSH private key file SSHKeyPath string `json:"ssh_key_path" yaml:"ssh_key_path" mapstructure:"ssh_key_path"` - // GitHubUsername is the GitHub username (required) - GitHubUsername string `json:"github_username" yaml:"github_username" mapstructure:"github_username" validate:"required"` + // GitHubUsername is the GitHub username (required for GitHub platform) + // Deprecated: Use Username instead with Platform field + GitHubUsername string `json:"github_username" yaml:"github_username" mapstructure:"github_username"` + + // Username is the platform-specific username (e.g., GitHub, GitLab username) + Username string `json:"username,omitempty" yaml:"username,omitempty" mapstructure:"username"` + + // Platform is the Git hosting platform type (github, gitlab, bitbucket, custom) + Platform string `json:"platform,omitempty" yaml:"platform,omitempty" mapstructure:"platform"` + + // Domain is the platform domain (e.g., "github.com", "gitlab.com", "custom-gitlab.company.com") + // If empty, defaults to the standard domain for the platform + Domain string `json:"domain,omitempty" yaml:"domain,omitempty" mapstructure:"domain"` + + // APIEndpoint is the API endpoint URL for custom installations (optional) + APIEndpoint string `json:"api_endpoint,omitempty" yaml:"api_endpoint,omitempty" mapstructure:"api_endpoint"` // Description is an optional description of the account Description string `json:"description,omitempty" yaml:"description,omitempty" mapstructure:"description"` @@ -452,3 +466,54 @@ func (a *Account) GetMissingFields() []string { } return a.MissingFields } + +// GetPlatform returns the platform type, defaulting to GitHub for backward compatibility +func (a *Account) GetPlatform() string { + if a.Platform == "" { + return "github" // Default to GitHub for legacy accounts + } + return a.Platform +} + +// GetDomain returns the platform domain, defaulting to platform-specific domains +func (a *Account) GetDomain() string { + if a.Domain != "" { + return a.Domain + } + + // Return default domain based on platform + switch a.GetPlatform() { + case "github": + return "github.com" + case "gitlab": + return "gitlab.com" + case "bitbucket": + return "bitbucket.org" + default: + return "" + } +} + +// GetUsername returns the username, falling back to GitHubUsername for backward compatibility +func (a *Account) GetUsername() string { + if a.Username != "" { + return a.Username + } + // Fallback to GitHubUsername for backward compatibility + return a.GitHubUsername +} + +// SetUsername sets the username and updates GitHubUsername for backward compatibility +func (a *Account) SetUsername(username string) { + a.Username = username + // Keep GitHubUsername in sync for backward compatibility + if a.GetPlatform() == "github" { + a.GitHubUsername = username + } +} + +// IsPlatformSupported checks if the account's platform is supported +func (a *Account) IsPlatformSupported() bool { + platform := a.GetPlatform() + return platform == "github" || platform == "gitlab" || platform == "bitbucket" +} diff --git a/internal/ssh/manager.go b/internal/ssh/manager.go index 74a719e..ca1243c 100644 --- a/internal/ssh/manager.go +++ b/internal/ssh/manager.go @@ -174,24 +174,51 @@ func (m *Manager) addKeyToAgent(keyPath string) error { return nil } -// TestConnection tests the SSH connection to GitHub +// TestConnection tests the SSH connection to GitHub (deprecated, use TestConnectionToPlatform) func (m *Manager) TestConnection() error { - // Test SSH connection to GitHub - testCmd := exec.Command("ssh", "-T", "git@github.com") + return m.TestConnectionToPlatform("github.com") +} + +// TestConnectionToPlatform tests the SSH connection to a specific platform domain +func (m *Manager) TestConnectionToPlatform(domain string) error { + // Test SSH connection to the specified domain + testCmd := exec.Command("ssh", "-T", fmt.Sprintf("git@%s", domain)) output, err := testCmd.CombinedOutput() outputStr := string(output) - // GitHub returns success (0) but with a message when authentication succeeds - // but shell access is not granted (which is the expected behavior) - if err == nil || strings.Contains(outputStr, "successfully authenticated") { + // Different platforms return different success messages + // GitHub: "successfully authenticated" + // GitLab: "Welcome to GitLab" + // Both return non-zero exit codes despite successful authentication + successIndicators := []string{ + "successfully authenticated", + "Welcome to GitLab", + "logged in as", + "authenticated", + } + + for _, indicator := range successIndicators { + if strings.Contains(outputStr, indicator) { + return nil + } + } + + // If no error and output suggests success + if err == nil { return nil } - return fmt.Errorf("SSH connection test failed: %w\nOutput: %s", err, outputStr) + return fmt.Errorf("SSH connection test to %s failed: %w\nOutput: %s", domain, err, outputStr) } // updateGitHubSSHConfigV2 updates the SSH config with improved multi-account isolation +// Deprecated: Use UpdateSSHConfig with platform domain instead func (m *Manager) updateGitHubSSHConfigV2(accountAlias, keyPath string) error { + return m.UpdateSSHConfig(accountAlias, keyPath, "github.com") +} + +// UpdateSSHConfig updates the SSH config for a specific platform domain +func (m *Manager) UpdateSSHConfig(accountAlias, keyPath, domain string) error { // Ensure SSH directory exists sshDir := filepath.Dir(m.configPath) if err := os.MkdirAll(sshDir, 0700); err != nil { @@ -212,7 +239,7 @@ func (m *Manager) updateGitHubSSHConfigV2(accountAlias, keyPath string) error { } // Build the new config - newConfig := m.buildIsolatedSSHConfig(accountAlias, keyPath, existingContent) + newConfig := m.buildIsolatedSSHConfigForPlatform(accountAlias, keyPath, domain, existingContent) // Write the updated config if err := os.WriteFile(m.configPath, []byte(newConfig), 0600); err != nil { @@ -223,66 +250,89 @@ func (m *Manager) updateGitHubSSHConfigV2(accountAlias, keyPath string) error { } // buildIsolatedSSHConfig creates an SSH config with proper multi-account isolation +// Deprecated: Use buildIsolatedSSHConfigForPlatform instead func (m *Manager) buildIsolatedSSHConfig(accountAlias, keyPath, existingConfig string) string { + return m.buildIsolatedSSHConfigForPlatform(accountAlias, keyPath, "github.com", existingConfig) +} + +// buildIsolatedSSHConfigForPlatform creates an SSH config for a specific platform +func (m *Manager) buildIsolatedSSHConfigForPlatform(accountAlias, keyPath, domain, existingConfig string) string { // Start with the gitshift header config := "# gitshift Managed Config - DO NOT EDIT MANUALLY\n" config += "# This file is automatically generated by gitshift\n\n" - // Preserve non-GitHub configurations - config += m.preserveNonGitHubConfig(existingConfig) + // Preserve non-platform configurations + config += m.preserveNonPlatformConfig(existingConfig, domain) + + // Determine platform name for comment + platformName := "Git hosting" + switch domain { + case "github.com": + platformName = "GitHub" + case "gitlab.com": + platformName = "GitLab" + case "bitbucket.org": + platformName = "Bitbucket" + } - // Add GitHub host configuration - config += fmt.Sprintf(`# GitHub account: %s -Host github.com - HostName github.com + // Add platform host configuration + config += fmt.Sprintf(`# %s account: %s +Host %s + HostName %s User git IdentityFile %s IdentitiesOnly yes AddKeysToAgent yes UseKeychain yes -`, accountAlias, keyPath) +`, platformName, accountAlias, domain, domain, keyPath) return config } // preserveNonGitHubConfig extracts and preserves non-GitHub host configurations +// Deprecated: Use preserveNonPlatformConfig instead func (m *Manager) preserveNonGitHubConfig(existingConfig string) string { + return m.preserveNonPlatformConfig(existingConfig, "github.com") +} + +// preserveNonPlatformConfig extracts and preserves configurations not related to the specified domain +func (m *Manager) preserveNonPlatformConfig(existingConfig, targetDomain string) string { if existingConfig == "" { return "" } var preserved []string lines := strings.Split(existingConfig, "\n") - inGitHubSection := false + inTargetSection := false skipUntilNextHost := false for i := 0; i < len(lines); i++ { line := strings.TrimSpace(lines[i]) - // Check if we're entering a GitHub host section + // Check if we're entering a target platform host section if strings.HasPrefix(line, "Host ") { hostLine := strings.TrimSpace(strings.TrimPrefix(line, "Host")) hosts := strings.Fields(hostLine) - // Check if any of the hosts is github.com - isGitHubHost := false + // Check if any of the hosts matches the target domain + isTargetHost := false for _, host := range hosts { - if host == "github.com" || strings.Contains(host, "github") { - isGitHubHost = true + if host == targetDomain || strings.Contains(host, targetDomain) { + isTargetHost = true break } } - if isGitHubHost { - inGitHubSection = true + if isTargetHost { + inTargetSection = true skipUntilNextHost = true continue } - // If we were in a GitHub section and found a new host, we're done - if inGitHubSection { - inGitHubSection = false + // If we were in a target section and found a new host, we're done + if inTargetSection { + inTargetSection = false } // If we were skipping until next host, stop skipping @@ -291,8 +341,8 @@ func (m *Manager) preserveNonGitHubConfig(existingConfig string) string { } } - // Skip lines in GitHub sections or when we're in skip mode - if inGitHubSection || skipUntilNextHost { + // Skip lines in target sections or when we're in skip mode + if inTargetSection || skipUntilNextHost { continue } @@ -301,7 +351,7 @@ func (m *Manager) preserveNonGitHubConfig(existingConfig string) string { } if len(preserved) > 0 { - // Ensure there's a blank line before adding GitHub config + // Ensure there's a blank line before adding platform config if preserved[len(preserved)-1] != "" { preserved = append(preserved, "") } diff --git a/pkg/platform/factory.go b/pkg/platform/factory.go new file mode 100644 index 0000000..487103d --- /dev/null +++ b/pkg/platform/factory.go @@ -0,0 +1,106 @@ +package platform + +import ( + "fmt" +) + +// Factory creates platform instances based on configuration +type Factory struct { + registry *Registry +} + +// NewFactory creates a new platform factory with default platforms registered +func NewFactory() *Factory { + registry := NewRegistry() + + // Register default platforms + registry.Register(NewGitHubPlatform()) + registry.Register(NewGitLabPlatform()) + + return &Factory{ + registry: registry, + } +} + +// GetPlatform returns a platform instance based on type and optional domain +func (f *Factory) GetPlatform(platformType Type, domain string) (Platform, error) { + switch platformType { + case TypeGitHub: + if domain == "" || domain == "github.com" { + return NewGitHubPlatform(), nil + } + // GitHub Enterprise + return NewGitHubEnterprisePlatform(domain, ""), nil + + case TypeGitLab: + if domain == "" || domain == "gitlab.com" { + return NewGitLabPlatform(), nil + } + // Self-hosted GitLab + return NewGitLabSelfHostedPlatform(domain, ""), nil + + case TypeBitbucket: + // TODO: Implement Bitbucket support + return nil, fmt.Errorf("Bitbucket platform not yet implemented") + + case TypeCustom: + if domain == "" { + return nil, fmt.Errorf("custom platform requires domain") + } + // TODO: Implement custom platform support + return nil, fmt.Errorf("custom platform not yet implemented") + + default: + return nil, fmt.Errorf("unsupported platform type: %s", platformType) + } +} + +// GetPlatformByDomain returns a platform instance by auto-detecting from domain +func (f *Factory) GetPlatformByDomain(domain string) (Platform, error) { + platformType := DetectPlatformFromDomain(domain) + return f.GetPlatform(platformType, domain) +} + +// GetRegistry returns the platform registry +func (f *Factory) GetRegistry() *Registry { + return f.registry +} + +// DetectPlatformFromDomain detects the platform type from a domain +func DetectPlatformFromDomain(domain string) Type { + switch { + case domain == "github.com" || containsAny(domain, []string{"github"}): + return TypeGitHub + case domain == "gitlab.com" || containsAny(domain, []string{"gitlab"}): + return TypeGitLab + case domain == "bitbucket.org" || containsAny(domain, []string{"bitbucket"}): + return TypeBitbucket + default: + return TypeCustom + } +} + +// CreatePlatformFromConfig creates a platform instance from configuration +func (f *Factory) CreatePlatformFromConfig(cfg *Config) (Platform, error) { + if cfg == nil { + return nil, fmt.Errorf("platform config cannot be nil") + } + + if !cfg.Type.IsValid() { + return nil, fmt.Errorf("invalid platform type: %s", cfg.Type) + } + + platform, err := f.GetPlatform(cfg.Type, cfg.Domain) + if err != nil { + return nil, err + } + + // TODO: Apply additional config like custom API endpoint, token, etc. + + return platform, nil +} + +// ListSupportedPlatforms returns a list of all supported platform types +func (f *Factory) ListSupportedPlatforms() []Type { + return []Type{TypeGitHub, TypeGitLab} +} diff --git a/pkg/platform/github.go b/pkg/platform/github.go new file mode 100644 index 0000000..893d0d0 --- /dev/null +++ b/pkg/platform/github.go @@ -0,0 +1,223 @@ +package platform + +import ( + "context" + "fmt" + "net/url" + "os/exec" + "strings" + + "github.com/techishthoughts/gitshift/pkg/gh" +) + +// GitHubPlatform implements the Platform interface for GitHub +type GitHubPlatform struct { + domain string + apiEndpoint string + client *gh.Client +} + +// NewGitHubPlatform creates a new GitHub platform instance +func NewGitHubPlatform() *GitHubPlatform { + return &GitHubPlatform{ + domain: "github.com", + apiEndpoint: "https://api.github.com", + } +} + +// NewGitHubEnterprisePlatform creates a new GitHub Enterprise platform instance +func NewGitHubEnterprisePlatform(domain, apiEndpoint string) *GitHubPlatform { + return &GitHubPlatform{ + domain: domain, + apiEndpoint: apiEndpoint, + } +} + +// GetType returns the platform type +func (p *GitHubPlatform) GetType() Type { + return TypeGitHub +} + +// GetDomain returns the platform's domain +func (p *GitHubPlatform) GetDomain() string { + return p.domain +} + +// GetSSHHost returns the SSH host for the platform +func (p *GitHubPlatform) GetSSHHost() string { + return p.domain +} + +// GetSSHUser returns the SSH user for the platform +func (p *GitHubPlatform) GetSSHUser() string { + return "git" +} + +// FormatSSHURL formats a repository path as an SSH URL +func (p *GitHubPlatform) FormatSSHURL(owner, repo string) string { + return fmt.Sprintf("git@%s:%s/%s.git", p.domain, owner, repo) +} + +// FormatHTTPSURL formats a repository path as an HTTPS URL +func (p *GitHubPlatform) FormatHTTPSURL(owner, repo string) string { + return fmt.Sprintf("https://%s/%s/%s.git", p.domain, owner, repo) +} + +// ParseRepositoryURL parses a repository URL and extracts owner and repo name +func (p *GitHubPlatform) ParseRepositoryURL(repoURL string) (owner, repo string, err error) { + // Handle SSH URLs (git@github.com:owner/repo.git) + if strings.HasPrefix(repoURL, "git@") { + parts := strings.Split(repoURL, ":") + if len(parts) != 2 { + return "", "", fmt.Errorf("invalid SSH URL format") + } + + // Verify domain matches + hostPart := strings.TrimPrefix(parts[0], "git@") + if hostPart != p.domain { + return "", "", fmt.Errorf("domain mismatch: expected %s, got %s", p.domain, hostPart) + } + + repoPath := strings.TrimSuffix(parts[1], ".git") + repoParts := strings.Split(repoPath, "/") + if len(repoParts) != 2 { + return "", "", fmt.Errorf("invalid repository path in URL") + } + return repoParts[0], repoParts[1], nil + } + + // Handle HTTPS URLs (https://github.com/owner/repo.git) + if strings.HasPrefix(repoURL, "http") { + parsedURL, err := url.Parse(repoURL) + if err != nil { + return "", "", fmt.Errorf("invalid URL: %w", err) + } + + // Verify domain matches + if parsedURL.Host != p.domain { + return "", "", fmt.Errorf("domain mismatch: expected %s, got %s", p.domain, parsedURL.Host) + } + + pathParts := strings.Split(strings.Trim(parsedURL.Path, "/"), "/") + if len(pathParts) < 2 { + return "", "", fmt.Errorf("invalid repository path in URL") + } + + repoName := strings.TrimSuffix(pathParts[1], ".git") + return pathParts[0], repoName, nil + } + + // Handle shorthand notation (owner/repo) + parts := strings.Split(repoURL, "/") + if len(parts) != 2 { + return "", "", fmt.Errorf("invalid repository format, expected 'owner/repo'") + } + + return parts[0], parts[1], nil +} + +// GetSSHKnownHosts returns the SSH known_hosts entries for GitHub +func (p *GitHubPlatform) GetSSHKnownHosts() []string { + // For GitHub.com, return the official known hosts + if p.domain == "github.com" { + return []string{ + "github.com ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIOMqqnkVzrm0SdG6UOoqKLsabgH5C9okWi0dh2l9GKJl", + "github.com ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBEmKSENjQEezOmxkZMy7opKgwFB9nkt5YRrYMjNuG5N87uRgg6CLrbo5wAdT/y6v0mKV0U2w0WZ2YB/++Tpockg=", + "github.com ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQCj7ndNxQowgcQnjshcLrqPEiiphnt+VTTvDP6mHBL9j1aNUkY4Ue1gvwnGLVlOhGeYrnZaMgRK6+PKCUXaDbC7qtbW8gIkhL7aGCsOr/C56SJMy/BCZfxd1nWzAOxSDPgVsmerOBYfNqltV9/hWCqBywINIR+5dIg6JTJ72pcEpEjcYgXkE2YEFXV1JHnsKgbLWNlhScqb2UmyRkQyytRLtL+38TGxkxCflmO+5Z8CSSNY7GidjMIZ7Q4zMjA2n1nGrlTDkzwDCsw+wqFPGQA1sN5N6Qvma0xPP7y1wZD/mJY4qUQcf4rCZA1BH2S0eRzU5O6a8PLxLk5Zme5n+uGZ5WVJwRzFV5rKqNwO3VLflNL8fFaRrKpjjODZo3RH4T1n3Cxj0LL/XzSl1s2L2PjYbwI1FtvRNmWfQPB5DsQXPLBmYUFY9aIk7Zz0K5TjQN2XQvKxh8a7XHlMF6a7cE0tOb8B9N/nVN8xX6F6dMx+vA8DcY0q0vViE4o2e7Xf7c=", + } + } + + // For GitHub Enterprise, we can't provide known hosts upfront + return []string{} +} + +// TestSSHConnection tests the SSH connection to GitHub +func (p *GitHubPlatform) TestSSHConnection(keyPath string) error { + args := []string{"-T", fmt.Sprintf("git@%s", p.domain)} + + if keyPath != "" { + args = append([]string{"-i", keyPath, "-o", "IdentitiesOnly=yes"}, args...) + } + + testCmd := exec.Command("ssh", args...) + output, err := testCmd.CombinedOutput() + outputStr := string(output) + + // GitHub returns exit code 1 but with a success message when authentication succeeds + // but shell access is not granted (which is the expected behavior) + if err == nil || strings.Contains(outputStr, "successfully authenticated") { + return nil + } + + return fmt.Errorf("SSH connection test failed: %w\nOutput: %s", err, outputStr) +} + +// GetAPIClient returns a GitHub API client +func (p *GitHubPlatform) GetAPIClient() (APIClient, error) { + if p.client != nil { + return &GitHubAPIClient{client: p.client}, nil + } + + // Create a new client using default authentication + client, err := gh.NewClient() + if err != nil { + return nil, fmt.Errorf("failed to create GitHub client: %w", err) + } + + p.client = client + return &GitHubAPIClient{client: client}, nil +} + +// GitHubAPIClient wraps the gh.Client to implement the APIClient interface +type GitHubAPIClient struct { + client *gh.Client +} + +// IsAuthenticated checks if the client is properly authenticated +func (c *GitHubAPIClient) IsAuthenticated() (bool, error) { + return c.client.IsAuthenticated() +} + +// GetAuthenticatedUser returns the username of the authenticated user +func (c *GitHubAPIClient) GetAuthenticatedUser(ctx context.Context) (string, error) { + return c.client.GetAuthenticatedUser(ctx) +} + +// CheckRepoAccess checks if the authenticated user has access to a repository +func (c *GitHubAPIClient) CheckRepoAccess(owner, repo string) (*Repository, error) { + ghRepo, err := c.client.CheckRepoAccess(owner, repo) + if err != nil { + return nil, err + } + + return &Repository{ + FullName: ghRepo.FullName, + Owner: ghRepo.Owner.Login, + Name: repo, + Description: ghRepo.Description, + Private: ghRepo.Private, + Fork: ghRepo.Fork, + SSHURL: ghRepo.SSHURL, + HTTPSURL: ghRepo.CloneURL, + Permissions: &Permissions{ + Admin: ghRepo.Permissions.Admin, + Push: ghRepo.Permissions.Push, + Pull: ghRepo.Permissions.Pull, + }, + }, nil +} + +// GetDefaultBranch gets the default branch for a repository +func (c *GitHubAPIClient) GetDefaultBranch(owner, repo string) (string, error) { + return c.client.GetDefaultBranch(owner, repo) +} + +// VerifySSHKey verifies if an SSH key is added to the user's account +func (c *GitHubAPIClient) VerifySSHKey(ctx context.Context, publicKey string) (bool, error) { + return c.client.VerifySSHKey(ctx, publicKey) +} + +// HasWriteAccess checks if the authenticated user has write access to a repository +func (c *GitHubAPIClient) HasWriteAccess(owner, repo string) (bool, error) { + return c.client.HasWriteAccess(owner, repo) +} diff --git a/pkg/platform/gitlab.go b/pkg/platform/gitlab.go new file mode 100644 index 0000000..4c53008 --- /dev/null +++ b/pkg/platform/gitlab.go @@ -0,0 +1,222 @@ +package platform + +import ( + "context" + "fmt" + "net/url" + "os/exec" + "strings" +) + +// GitLabPlatform implements the Platform interface for GitLab +type GitLabPlatform struct { + domain string + apiEndpoint string + token string +} + +// NewGitLabPlatform creates a new GitLab platform instance +func NewGitLabPlatform() *GitLabPlatform { + return &GitLabPlatform{ + domain: "gitlab.com", + apiEndpoint: "https://gitlab.com/api/v4", + } +} + +// NewGitLabSelfHostedPlatform creates a new self-hosted GitLab platform instance +func NewGitLabSelfHostedPlatform(domain, apiEndpoint string) *GitLabPlatform { + if apiEndpoint == "" { + apiEndpoint = fmt.Sprintf("https://%s/api/v4", domain) + } + return &GitLabPlatform{ + domain: domain, + apiEndpoint: apiEndpoint, + } +} + +// GetType returns the platform type +func (p *GitLabPlatform) GetType() Type { + return TypeGitLab +} + +// GetDomain returns the platform's domain +func (p *GitLabPlatform) GetDomain() string { + return p.domain +} + +// GetSSHHost returns the SSH host for the platform +func (p *GitLabPlatform) GetSSHHost() string { + return p.domain +} + +// GetSSHUser returns the SSH user for the platform +func (p *GitLabPlatform) GetSSHUser() string { + return "git" +} + +// FormatSSHURL formats a repository path as an SSH URL +func (p *GitLabPlatform) FormatSSHURL(owner, repo string) string { + return fmt.Sprintf("git@%s:%s/%s.git", p.domain, owner, repo) +} + +// FormatHTTPSURL formats a repository path as an HTTPS URL +func (p *GitLabPlatform) FormatHTTPSURL(owner, repo string) string { + return fmt.Sprintf("https://%s/%s/%s.git", p.domain, owner, repo) +} + +// ParseRepositoryURL parses a repository URL and extracts owner and repo name +func (p *GitLabPlatform) ParseRepositoryURL(repoURL string) (owner, repo string, err error) { + // Handle SSH URLs (git@gitlab.com:owner/repo.git) + if strings.HasPrefix(repoURL, "git@") { + parts := strings.Split(repoURL, ":") + if len(parts) != 2 { + return "", "", fmt.Errorf("invalid SSH URL format") + } + + // Verify domain matches + hostPart := strings.TrimPrefix(parts[0], "git@") + if hostPart != p.domain { + return "", "", fmt.Errorf("domain mismatch: expected %s, got %s", p.domain, hostPart) + } + + repoPath := strings.TrimSuffix(parts[1], ".git") + + // GitLab supports nested groups (e.g., group/subgroup/repo) + // We need to handle this differently than GitHub + repoParts := strings.Split(repoPath, "/") + if len(repoParts) < 2 { + return "", "", fmt.Errorf("invalid repository path in URL") + } + + // For now, treat everything except the last part as owner + // In GitLab, this could be group/subgroup + repoName := repoParts[len(repoParts)-1] + ownerPath := strings.Join(repoParts[:len(repoParts)-1], "/") + + return ownerPath, repoName, nil + } + + // Handle HTTPS URLs (https://gitlab.com/owner/repo.git) + if strings.HasPrefix(repoURL, "http") { + parsedURL, err := url.Parse(repoURL) + if err != nil { + return "", "", fmt.Errorf("invalid URL: %w", err) + } + + // Verify domain matches + if parsedURL.Host != p.domain { + return "", "", fmt.Errorf("domain mismatch: expected %s, got %s", p.domain, parsedURL.Host) + } + + pathParts := strings.Split(strings.Trim(parsedURL.Path, "/"), "/") + if len(pathParts) < 2 { + return "", "", fmt.Errorf("invalid repository path in URL") + } + + // Handle nested groups + repoName := strings.TrimSuffix(pathParts[len(pathParts)-1], ".git") + ownerPath := strings.Join(pathParts[:len(pathParts)-1], "/") + + return ownerPath, repoName, nil + } + + // Handle shorthand notation (owner/repo or group/subgroup/repo) + parts := strings.Split(repoURL, "/") + if len(parts) < 2 { + return "", "", fmt.Errorf("invalid repository format, expected 'owner/repo'") + } + + // Handle nested groups + repoName := parts[len(parts)-1] + ownerPath := strings.Join(parts[:len(parts)-1], "/") + + return ownerPath, repoName, nil +} + +// GetSSHKnownHosts returns the SSH known_hosts entries for GitLab +func (p *GitLabPlatform) GetSSHKnownHosts() []string { + // For gitlab.com, return the official known hosts + if p.domain == "gitlab.com" { + return []string{ + "gitlab.com ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIAfuCHKVTjquxvt6CM6tdG4SLp1Btn/nOeHHE5UOzRdf", + "gitlab.com ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCsj2bNKTBSpIYDEGk9KxsGh3mySTRgMtXL583qmBpzeQ+jqCMRgBqB98u3z++J1sKlXHWfM9dyhSevkMwSbhoR8XIq/U0tCNyokEi/ueaBMCvbcTHhO7FcwzY92WK4Yt0aGROY5qX2UKSeOvuP4D6TPqKF1onrSzH9bx9XUf2lEdWT/ia1NEKjunUqu1xOB/StKDHMoX4/OKyIzuS0q/T1zOATthvasJFoPrAjkohTyaDUz2LN5JoH839hViyEG82yB+MjcFV5MU3N1l1QL3cVUCh93xSaua1N85qivl+siMkPGbO5xR/En4iEY6K2XPASUEMaieWVNTRCtJ4S8H+9", + "gitlab.com ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBFSMqzJeV9rUzU4kWitGjeR4PWSa29SPqJ1fVkhtj3Hw9xjLVXVYrU9QlYWrOLXBpQ6KWjbjTDTdDkoohFzgbEY=", + } + } + + // For self-hosted GitLab, we can't provide known hosts upfront + return []string{} +} + +// TestSSHConnection tests the SSH connection to GitLab +func (p *GitLabPlatform) TestSSHConnection(keyPath string) error { + args := []string{"-T", fmt.Sprintf("git@%s", p.domain)} + + if keyPath != "" { + args = append([]string{"-i", keyPath, "-o", "IdentitiesOnly=yes"}, args...) + } + + testCmd := exec.Command("ssh", args...) + output, err := testCmd.CombinedOutput() + outputStr := string(output) + + // GitLab returns exit code 1 but with a welcome message when authentication succeeds + // Example: "Welcome to GitLab, @username!" + if err == nil || strings.Contains(outputStr, "Welcome to GitLab") { + return nil + } + + return fmt.Errorf("SSH connection test failed: %w\nOutput: %s", err, outputStr) +} + +// GetAPIClient returns a GitLab API client +func (p *GitLabPlatform) GetAPIClient() (APIClient, error) { + // For now, return a placeholder implementation + // TODO: Implement a full GitLab API client similar to gh.Client + return &GitLabAPIClient{ + platform: p, + }, nil +} + +// GitLabAPIClient implements the APIClient interface for GitLab +type GitLabAPIClient struct { + platform *GitLabPlatform +} + +// IsAuthenticated checks if the client is properly authenticated +func (c *GitLabAPIClient) IsAuthenticated() (bool, error) { + // TODO: Implement GitLab authentication check + // For now, return false to indicate not implemented + return false, fmt.Errorf("GitLab API authentication not yet implemented") +} + +// GetAuthenticatedUser returns the username of the authenticated user +func (c *GitLabAPIClient) GetAuthenticatedUser(ctx context.Context) (string, error) { + // TODO: Implement GitLab user API call + return "", fmt.Errorf("GitLab API not yet implemented") +} + +// CheckRepoAccess checks if the authenticated user has access to a repository +func (c *GitLabAPIClient) CheckRepoAccess(owner, repo string) (*Repository, error) { + // TODO: Implement GitLab repository access check + return nil, fmt.Errorf("GitLab API not yet implemented") +} + +// GetDefaultBranch gets the default branch for a repository +func (c *GitLabAPIClient) GetDefaultBranch(owner, repo string) (string, error) { + // TODO: Implement GitLab default branch API call + // For now, return common defaults + return "main", nil +} + +// VerifySSHKey verifies if an SSH key is added to the user's account +func (c *GitLabAPIClient) VerifySSHKey(ctx context.Context, publicKey string) (bool, error) { + // TODO: Implement GitLab SSH key verification + return false, fmt.Errorf("GitLab API not yet implemented") +} + +// HasWriteAccess checks if the authenticated user has write access to a repository +func (c *GitLabAPIClient) HasWriteAccess(owner, repo string) (bool, error) { + // TODO: Implement GitLab write access check + return false, fmt.Errorf("GitLab API not yet implemented") +} diff --git a/pkg/platform/platform.go b/pkg/platform/platform.go new file mode 100644 index 0000000..c3245c0 --- /dev/null +++ b/pkg/platform/platform.go @@ -0,0 +1,223 @@ +// Package platform provides an abstraction layer for Git hosting platforms +// (GitHub, GitLab, Bitbucket, etc.) +package platform + +import ( + "context" +) + +// Type represents a Git hosting platform type +type Type string + +const ( + // TypeGitHub represents GitHub platform + TypeGitHub Type = "github" + + // TypeGitLab represents GitLab platform + TypeGitLab Type = "gitlab" + + // TypeBitbucket represents Bitbucket platform + TypeBitbucket Type = "bitbucket" + + // TypeCustom represents a custom Git hosting platform + TypeCustom Type = "custom" +) + +// String returns the string representation of a platform type +func (t Type) String() string { + return string(t) +} + +// IsValid checks if the platform type is valid +func (t Type) IsValid() bool { + switch t { + case TypeGitHub, TypeGitLab, TypeBitbucket, TypeCustom: + return true + default: + return false + } +} + +// Platform defines the interface that all Git hosting platforms must implement +type Platform interface { + // GetType returns the platform type + GetType() Type + + // GetDomain returns the platform's domain (e.g., "github.com", "gitlab.com") + GetDomain() string + + // GetSSHHost returns the SSH host for the platform (e.g., "github.com", "gitlab.com") + GetSSHHost() string + + // GetSSHUser returns the SSH user for the platform (usually "git") + GetSSHUser() string + + // FormatSSHURL formats a repository path as an SSH URL + // Example: owner/repo -> git@github.com:owner/repo.git + FormatSSHURL(owner, repo string) string + + // FormatHTTPSURL formats a repository path as an HTTPS URL + // Example: owner/repo -> https://github.com/owner/repo.git + FormatHTTPSURL(owner, repo string) string + + // ParseRepositoryURL parses a repository URL and extracts owner and repo name + // Supports SSH (git@...), HTTPS (https://...), and shorthand (owner/repo) formats + ParseRepositoryURL(url string) (owner, repo string, err error) + + // GetSSHKnownHosts returns the SSH known_hosts entries for this platform + GetSSHKnownHosts() []string + + // TestSSHConnection tests the SSH connection to the platform + TestSSHConnection(keyPath string) error + + // GetAPIClient returns an API client for this platform + GetAPIClient() (APIClient, error) +} + +// APIClient defines the interface for platform API operations +type APIClient interface { + // IsAuthenticated checks if the client is properly authenticated + IsAuthenticated() (bool, error) + + // GetAuthenticatedUser returns the username of the authenticated user + GetAuthenticatedUser(ctx context.Context) (string, error) + + // CheckRepoAccess checks if the authenticated user has access to a repository + CheckRepoAccess(owner, repo string) (*Repository, error) + + // GetDefaultBranch gets the default branch for a repository + GetDefaultBranch(owner, repo string) (string, error) + + // VerifySSHKey verifies if an SSH key is added to the user's account + VerifySSHKey(ctx context.Context, publicKey string) (bool, error) + + // HasWriteAccess checks if the authenticated user has write access to a repository + HasWriteAccess(owner, repo string) (bool, error) +} + +// Repository represents a repository on a Git hosting platform +type Repository struct { + // FullName is the full repository name (owner/repo) + FullName string + + // Owner is the repository owner/organization + Owner string + + // Name is the repository name + Name string + + // Description is the repository description + Description string + + // Private indicates if the repository is private + Private bool + + // Fork indicates if the repository is a fork + Fork bool + + // SSHURL is the SSH clone URL + SSHURL string + + // HTTPSURL is the HTTPS clone URL + HTTPSURL string + + // DefaultBranch is the default branch name + DefaultBranch string + + // Permissions contains the user's permissions for this repository + Permissions *Permissions +} + +// Permissions represents user permissions for a repository +type Permissions struct { + // Admin indicates if the user has admin access + Admin bool + + // Push indicates if the user has push access + Push bool + + // Pull indicates if the user has pull access + Pull bool +} + +// Config represents platform-specific configuration +type Config struct { + // Type is the platform type + Type Type + + // Domain is the platform domain (e.g., "github.com") + Domain string + + // APIEndpoint is the API endpoint URL (optional, for custom installations) + APIEndpoint string + + // SSHHost is the SSH host (optional, defaults to Domain) + SSHHost string + + // SSHPort is the SSH port (optional, defaults to 22) + SSHPort int + + // Token is the authentication token (optional) + Token string +} + +// Registry maintains a registry of available platforms +type Registry struct { + platforms map[Type]Platform +} + +// NewRegistry creates a new platform registry +func NewRegistry() *Registry { + return &Registry{ + platforms: make(map[Type]Platform), + } +} + +// Register registers a platform implementation +func (r *Registry) Register(platform Platform) { + r.platforms[platform.GetType()] = platform +} + +// Get retrieves a platform by type +func (r *Registry) Get(platformType Type) (Platform, bool) { + platform, exists := r.platforms[platformType] + return platform, exists +} + +// List returns all registered platforms +func (r *Registry) List() []Platform { + platforms := make([]Platform, 0, len(r.platforms)) + for _, platform := range r.platforms { + platforms = append(platforms, platform) + } + return platforms +} + +// DetectPlatform attempts to detect the platform from a repository URL +func DetectPlatform(url string) Type { + // Quick domain-based detection + switch { + case containsAny(url, []string{"github.com", "github"}): + return TypeGitHub + case containsAny(url, []string{"gitlab.com", "gitlab"}): + return TypeGitLab + case containsAny(url, []string{"bitbucket.org", "bitbucket"}): + return TypeBitbucket + default: + return TypeCustom + } +} + +// containsAny checks if the string contains any of the given substrings +func containsAny(s string, substrs []string) bool { + for _, substr := range substrs { + if len(s) >= len(substr) { + for i := 0; i <= len(s)-len(substr); i++ { + if s[i:i+len(substr)] == substr { + return true + } + } + } + } + return false +}