Files
skillshare/internal/install/install_git.go
T
Willie de1abd4b33 feat(install): pin project skills to a commit with a lockfile
config.yaml records which skills a project wants, but not which commit
each one resolved to, so two teammates running `install -p` a week apart
could end up with different skill contents.

Project mode now writes .skillshare/skills.lock.json next to the config.
`install -p` checks out the locked commit for skills and tracked repos,
and brings an already installed skill to the lock when they differ.
`update -p` and the dashboard move a pin only for skills whose commit
actually changed, so a stale local copy cannot roll the team back, and
uninstall drops the pin. A locked value is only honoured when it is a
full SHA for the same source, since it ends up as a git argument.
2026-09-21 04:31:22 +08:00

476 lines
15 KiB
Go

package install
import (
"context"
"errors"
"fmt"
"net/url"
"os"
"os/exec"
"path/filepath"
"regexp"
"strings"
"time"
)
var commitSHAPattern = regexp.MustCompile(`^[0-9a-f]{7,40}$`)
// IsCommitSHA reports whether ref looks like an abbreviated or full commit hash
// rather than a branch or tag name.
func IsCommitSHA(ref string) bool {
return commitSHAPattern.MatchString(ref)
}
func isGitInstalled() bool {
_, err := exec.LookPath("git")
return err == nil
}
// IsGitRepo checks if path is a git repository
func IsGitRepo(path string) bool {
gitDir := filepath.Join(path, ".git")
info, err := os.Stat(gitDir)
return err == nil && info.IsDir()
}
// gitCommandTimeout is the maximum time for a git network operation.
// Remote tracked-repo clones can take longer in constrained CI/Docker networks.
const gitCommandTimeout = 180 * time.Second
// gitCommand creates an exec.Cmd for git with GIT_TERMINAL_PROMPT=0
// to prevent interactive credential prompts that hang CLI spinners and web UI.
func gitCommand(ctx context.Context, args ...string) *exec.Cmd {
cmd := exec.CommandContext(ctx, "git", args...)
cmd.Env = append(os.Environ(),
"GIT_TERMINAL_PROMPT=0",
"GIT_ASKPASS=",
"SSH_ASKPASS=",
)
return cmd
}
// runGitCommand runs a git command with timeout, captures stderr for error messages.
func runGitCommand(args []string, dir string) error {
return runGitCommandEnv(args, dir, nil)
}
// runGitCommandEnv is like runGitCommand but accepts extra environment variables.
func runGitCommandEnv(args []string, dir string, extraEnv []string) error {
return runGitCommandWithProgress(args, dir, extraEnv, nil)
}
// UsedTokenAuth reports whether extraEnv contains token-based auth overrides.
func UsedTokenAuth(extraEnv []string) bool {
for _, env := range extraEnv {
if strings.HasPrefix(env, "GIT_CONFIG_KEY_") && strings.Contains(env, ".insteadOf") {
return true
}
}
return false
}
// WrapGitError inspects stderr output to produce actionable error messages.
func WrapGitError(stderr string, err error, tokenAuthAttempted bool) error {
s := sanitizeTokens(strings.TrimSpace(stderr))
if IsSSLError(s) {
return fmt.Errorf("SSL certificate verification failed — options:\n"+
" 1. Custom CA bundle: GIT_SSL_CAINFO=/path/to/ca-bundle.crt skillshare install <url>\n"+
" 2. Skip verification: GIT_SSL_NO_VERIFY=true skillshare install <url>\n"+
" 3. Use SSH instead: git@<host>:<owner>/<repo>.git\n %s", s)
}
if IsAuthError(s) {
if tokenAuthAttempted {
return fmt.Errorf("authentication failed — token rejected, check permissions and expiry\n %s", s)
}
return fmt.Errorf("authentication required — options:\n"+
" 1. SSH URL: git@<host>:<owner>/<repo>.git\n"+
" 2. Token env var: GITHUB_TOKEN, GITLAB_TOKEN, BITBUCKET_TOKEN, AZURE_DEVOPS_TOKEN, CNB_TOKEN, GITEA_TOKEN, or SKILLSHARE_GIT_TOKEN\n"+
" 3. Git credential helper: gh auth login\n %s", s)
}
if s != "" {
// Extract the fatal/error line from verbose git output, strip hint lines
return fmt.Errorf("%s", extractGitFatal(s))
}
// When stderr is empty, extract exit code for a more actionable message
var exitErr *exec.ExitError
if errors.As(err, &exitErr) {
code := exitErr.ExitCode()
switch code {
case 128:
if tokenAuthAttempted {
return fmt.Errorf("git failed (exit 128): authentication token was rejected — check permissions and expiry")
}
return fmt.Errorf("git failed (exit 128): repository not found or authentication required")
case 1:
return fmt.Errorf("git failed (exit 1): command error — check network connectivity and repository URL")
default:
return fmt.Errorf("git failed (exit %d)", code)
}
}
return err
}
// extractGitFatal extracts the "fatal:" or "error:" line from git stderr,
// stripping verbose "hint:" lines. If no fatal/error line is found, returns
// the original text with hint lines removed.
func extractGitFatal(stderr string) string {
var fatal string
var nonHint []string
for _, line := range strings.Split(stderr, "\n") {
trimmed := strings.TrimSpace(line)
if trimmed == "" {
continue
}
if strings.HasPrefix(trimmed, "hint:") {
continue
}
if strings.HasPrefix(trimmed, "fatal: ") {
fatal = strings.TrimPrefix(trimmed, "fatal: ")
} else if strings.HasPrefix(trimmed, "error: ") {
fatal = strings.TrimPrefix(trimmed, "error: ")
}
nonHint = append(nonHint, trimmed)
}
if fatal != "" {
if strings.Contains(fatal, "failed to push some refs") && len(nonHint) > 1 {
return strings.Join(nonHint, "; ")
}
return fatal
}
if len(nonHint) > 0 {
return strings.Join(nonHint, "; ")
}
return stderr
}
// cloneRepo performs a git clone (quiet mode for cleaner output).
// If a token is available in env vars, it injects authentication via
// GIT_CONFIG env vars without modifying the stored remote URL.
// branch specifies the branch to clone; empty string uses the remote default.
func cloneRepo(url, destPath, branch string, shallow bool, onProgress ProgressCallback) error {
return cloneRepoWithEnv(url, destPath, branch, shallow, authEnv(url), onProgress)
}
func cloneRepoWithEnv(url, destPath, branch string, shallow bool, extraEnv []string, onProgress ProgressCallback) error {
// git clone --branch accepts branches and tags but not commit SHAs:
// clone the default branch, then detach HEAD at the pinned commit.
if IsCommitSHA(branch) {
if err := cloneRepoWithEnv(url, destPath, "", shallow, extraEnv, onProgress); err != nil {
return err
}
return checkoutCommit(destPath, branch, shallow, extraEnv, onProgress)
}
args := []string{"clone"}
if onProgress != nil {
args = append(args, "--progress")
} else {
args = append(args, "--quiet")
}
if shallow {
args = append(args, "--depth", "1")
}
if branch != "" {
args = append(args, "--branch", branch)
}
args = append(args, url, destPath)
return runGitCommandWithProgress(args, "", extraEnv, onProgress)
}
// checkoutCommit detaches HEAD at sha. A targeted fetch works for full SHAs on
// GitHub/GitLab; when the server refuses or the SHA is abbreviated, it deepens
// the clone and resolves the commit locally.
func checkoutCommit(repoPath, sha string, shallow bool, extraEnv []string, onProgress ProgressCallback) error {
fetch := []string{"fetch", "--quiet", "origin", sha}
if shallow {
fetch = []string{"fetch", "--quiet", "--depth", "1", "origin", sha}
}
if err := runGitCommandWithProgress(fetch, repoPath, extraEnv, onProgress); err == nil {
return runGitCommandWithProgress([]string{"checkout", "--quiet", "--detach", "FETCH_HEAD"}, repoPath, extraEnv, nil)
}
// clone --depth 1 implies --single-branch, so fetch every branch and tag
// explicitly: the pinned commit may live off the default branch.
full := []string{"fetch", "--quiet", "--tags", "origin", "+refs/heads/*:refs/remotes/origin/*"}
if isShallowRepo(repoPath) {
full = append(full[:2], append([]string{"--unshallow"}, full[2:]...)...)
}
if err := runGitCommandWithProgress(full, repoPath, extraEnv, onProgress); err != nil {
return fmt.Errorf("resolve commit %s: %w", sha, err)
}
return runGitCommandWithProgress([]string{"checkout", "--quiet", "--detach", sha}, repoPath, extraEnv, nil)
}
func isShallowRepo(repoPath string) bool {
cmd := exec.Command("git", "rev-parse", "--is-shallow-repository")
cmd.Dir = repoPath
out, err := cmd.Output()
return err == nil && strings.TrimSpace(string(out)) == "true"
}
// isDetachedHead reports whether HEAD points at a commit rather than a branch.
func isDetachedHead(repoPath string) bool {
cmd := exec.Command("git", "symbolic-ref", "-q", "HEAD")
cmd.Dir = repoPath
return cmd.Run() != nil
}
// ref is what to clone: the locked commit when there is one, else the branch.
func (s *Source) ref() string {
if s.Commit != "" {
return s.Commit
}
return s.Branch
}
// recordCommit notes the full SHA a clone landed on, for the lockfile.
func (s *Source) recordCommit(repoPath string) {
if hash, err := getGitFullHash(repoPath); err == nil {
s.Commit = hash
}
}
func cloneRepoForSource(source *Source, destPath, branch string, shallow bool, onProgress ProgressCallback) error {
if source.Commit != "" {
branch = source.Commit
}
err := cloneSourceWithFallback(source, destPath, branch, shallow, onProgress)
if err == nil {
source.recordCommit(destPath)
}
return err
}
func cloneSourceWithFallback(source *Source, destPath, branch string, shallow bool, onProgress ProgressCallback) error {
err := cloneRepoWithEnv(source.CloneURL, destPath, branch, shallow, source.authEnv(), onProgress)
if err == nil {
return nil
}
if !shouldRetryNestedGitLabURL(err) {
return err
}
var lastErr error
for _, fallback := range cloneFallbackSourcesForNestedGitLabURL(source) {
if cleanupErr := removeAll(destPath); cleanupErr != nil && !os.IsNotExist(cleanupErr) {
return fmt.Errorf("clone failed (%v), and cleanup before fallback failed: %w", err, cleanupErr)
}
if onProgress != nil {
onProgress("Clone failed; retrying as a nested GitLab repository...")
}
fallbackErr := cloneRepoWithEnv(fallback.CloneURL, destPath, branch, shallow, fallback.authEnv(), onProgress)
if fallbackErr == nil {
*source = fallback
return nil
}
lastErr = fallbackErr
}
if lastErr != nil {
return fmt.Errorf("%w (nested GitLab fallback also failed: %v)", err, lastErr)
}
return err
}
func shouldRetryNestedGitLabURL(err error) bool {
if err == nil {
return false
}
if IsAuthError(err.Error()) || IsSSLError(err.Error()) {
return false
}
low := strings.ToLower(err.Error())
blockedHints := []string{
"remote branch",
"could not resolve host",
"failed to connect",
"connection timed out",
"operation timed out",
"network is unreachable",
"permission denied",
}
for _, hint := range blockedHints {
if strings.Contains(low, hint) {
return false
}
}
retryHints := []string{
"repository not found",
"not a git repository",
"not a valid git repo",
"does not appear to be a git repository",
"requested url returned error: 404",
}
for _, hint := range retryHints {
if strings.Contains(low, hint) {
return true
}
}
if strings.Contains(low, "repository") && strings.Contains(low, "not found") {
return true
}
return false
}
func cloneFallbackSourcesForNestedGitLabURL(source *Source) []Source {
if source == nil || source.Type != SourceTypeGitHTTPS || source.Subdir == "" {
return nil
}
u, err := url.Parse(source.CloneURL)
if err != nil || u.Scheme == "" || u.Host == "" {
return nil
}
repoPath := strings.Trim(strings.TrimSuffix(u.Path, ".git"), "/")
if repoPath == "" || strings.Contains(repoPath, "/-/") {
return nil
}
subdirParts := strings.Split(strings.Trim(source.Subdir, "/"), "/")
if len(subdirParts) == 0 {
return nil
}
fallbacks := make([]Source, 0, len(subdirParts))
for i := 1; i <= len(subdirParts); i++ {
candidate := *source
candidateRepoPath := repoPath + "/" + strings.Join(subdirParts[:i], "/")
remaining := strings.Join(subdirParts[i:], "/")
candidateURL := *u
candidateURL.Path = "/" + candidateRepoPath + ".git"
candidate.CloneURL = candidateURL.String()
candidate.Subdir = remaining
if remaining == "" {
candidate.Name = filepath.Base(candidateRepoPath)
} else {
candidate.Name = filepath.Base(remaining)
}
fallbacks = append(fallbacks, candidate)
}
return fallbacks
}
// ShallowCloneToTemp clones cloneURL into a fresh temporary directory using a
// shallow (depth 1) clone, injecting auth env for the URL. The caller owns the
// returned directory and must remove it. branch may be empty to use the remote
// default. On error the temp directory is removed and an empty path returned.
func ShallowCloneToTemp(cloneURL, branch string) (string, error) {
dir, err := os.MkdirTemp("", "skillshare-clone-*")
if err != nil {
return "", err
}
if err := cloneRepo(cloneURL, dir, branch, true, nil); err != nil {
cleanupTempRepo(dir)
return "", err
}
return dir, nil
}
// gitPull performs a git pull (quiet mode).
// If the remote uses HTTPS and a token is available, it injects
// authentication via GIT_CONFIG env vars (same mechanism as cloneRepo).
func gitPull(repoPath string, onProgress ProgressCallback) error {
remoteURL := getRemoteURL(repoPath)
args := []string{"pull", "--quiet"}
if onProgress != nil {
args = []string{"pull", "--progress"}
}
return runGitCommandWithProgress(args, repoPath, authEnv(remoteURL), onProgress)
}
// getRemoteURL returns the fetch URL for the "origin" remote, or "".
func getRemoteURL(repoPath string) string {
cmd := exec.Command("git", "remote", "get-url", "origin")
cmd.Dir = repoPath
out, err := cmd.Output()
if err != nil {
return ""
}
return strings.TrimSpace(string(out))
}
// getGitCommit returns the current HEAD commit hash
func getGitCommit(repoPath string) (string, error) {
cmd := exec.Command("git", "rev-parse", "--short", "HEAD")
cmd.Dir = repoPath
output, err := cmd.Output()
if err != nil {
return "", err
}
return string(output[:len(output)-1]), nil // Remove trailing newline
}
// getGitFullHash returns the full HEAD commit hash for reliable rollback.
// NOTE: duplicates git.GetCurrentFullHash — kept here because internal/git
// imports internal/install (for AuthEnvForURL), so the reverse import would
// create a cycle.
func getGitFullHash(repoPath string) (string, error) {
cmd := exec.Command("git", "rev-parse", "HEAD")
cmd.Dir = repoPath
out, err := cmd.Output()
if err != nil {
return "", err
}
return strings.TrimSpace(string(out)), nil
}
func shortHash(hash string) string {
if len(hash) <= 12 {
return hash
}
return hash[:12]
}
func validateTrackedRepoDirName(name string) error {
if strings.TrimSpace(name) == "" {
return fmt.Errorf("tracked repo name cannot be empty")
}
if !strings.HasPrefix(name, "_") || len(name) < 2 {
return fmt.Errorf("tracked repo name must start with '_' and include at least one additional character")
}
if strings.Contains(name, "..") {
return fmt.Errorf("tracked repo name cannot contain '..'")
}
if strings.Contains(name, "/") || strings.Contains(name, "\\") {
return fmt.Errorf("tracked repo name cannot contain path separators")
}
if filepath.Clean(name) != name {
return fmt.Errorf("tracked repo name contains invalid path segments")
}
return nil
}
// gitResetHard resets the working tree to the given revision.
// NOTE: duplicates git.ResetHard — kept here to avoid import cycle
// (internal/git imports internal/install).
func gitResetHard(repoPath, rev string) error {
cmd := exec.Command("git", "reset", "--hard", rev)
cmd.Dir = repoPath
return cmd.Run()
}
// getSubdirTreeHash returns the git tree hash for a subdirectory within a repo.
// This is the SHA of the tree object for that directory — it changes only when
// files inside the subdir change, even if the repo HEAD moves.
// Returns "" on any error (no .git, subdir not found, etc.).
func getSubdirTreeHash(repoPath, subdir string) string {
if subdir == "" {
return ""
}
// Strip leading "/" from subdir — git rev-parse doesn't accept absolute paths
subdir = strings.TrimPrefix(subdir, "/")
cmd := exec.Command("git", "rev-parse", "HEAD:"+subdir)
cmd.Dir = repoPath
out, err := cmd.Output()
if err != nil {
return ""
}
return strings.TrimSpace(string(out))
}
// copyDir copies a directory recursively