# ADR 0001: Self-Update Mechanism for OpenPass

**Date:** 2026-04-23  
**Status:** Proposed  
**Author:** OpenPass Team  
**Issue:** PNEOS-428

## Context

OpenPass currently implements update checking via `internal/update/checker.go`, which queries the GitHub Releases API and compares semantic versions. However, the tool does not provide a self-update mechanism. When updates are available, users are directed to manually download new binaries from GitHub or use their original installation channel.

This ADR addresses the design of a self-update feature, carefully considering the security implications and the diverse installation methods users employ.

### Current State

The existing update checker:
- Fetches latest release metadata from GitHub API
- Compares current version against latest using semantic versioning
- Handles rate limiting and API errors gracefully
- Returns a `Result` struct indicating update availability

What's missing:
- Binary download and verification
- Safe file replacement with rollback capability
- Installation method detection
- Security verification (checksums, signatures)

### Installation Methods in Use

Based on README.md and `.goreleaser.yml`, OpenPass is distributed via:

1. **Direct binary download** from GitHub Releases (tar.gz for macOS/Linux, zip for Windows)
2. **Go install** (`go install github.com/danieljustus/OpenPass@latest`)
3. **Build from source** (manual `go build`)
4. **Package managers** (DEB, RPM, APK via GoReleaser nfpms)
5. **Manual copies** (user-built binary placed in custom PATH location)

## Problem Statement

Implementing self-update naively creates significant risks:

1. **Security**: Downloading and executing remote binaries is a high-risk operation. A compromised update mechanism could distribute malicious code to all users.

2. **Installation conflicts**: Self-update may conflict with package managers (Homebrew, APT, RPM), which expect to manage their own installed files.

3. **Permission issues**: Writing to system directories (e.g., `/usr/local/bin`, `/usr/bin`) requires elevated privileges.

4. **Platform differences**: Windows file locking, macOS notarization, Linux permissions all require different handling.

5. **Rollback complexity**: Failed updates must not leave the system in a broken state.

## Decision

### 1. Capability Matrix

| Installation Method | Self-Update Supported | Rationale |
|---------------------|----------------------|-----------|
| **Direct binary download** (GitHub Releases) | **YES** | User explicitly chose manual management; binary is in user-writable location |
| **Go install** (`go install`) | **NO** | Binary owned by Go toolchain; updating via self-update breaks Go's module cache tracking |
| **Package manager** (Homebrew, APT, RPM, APK) | **NO** | Package manager owns the installation; self-update would break package database |
| **Build from source** (manual) | **NO** | User maintains their own build; self-update would replace with upstream binary |
| **Manual copy** (custom PATH) | **NO** | Cannot reliably detect; user may have custom modifications |

**Decision:** Self-update is **only** supported for binaries downloaded directly from GitHub Releases where:
- Binary is located in a user-writable directory
- No package manager metadata is present
- Installation path matches common user directories (e.g., `~/bin`, `~/.local/bin`, `$HOME/bin`)

### 2. Install Method Detection

Detection uses a layered heuristic approach, evaluated in order:

#### 2.1 Environment Variable Detection

```go
// Check for package manager markers
if os.Getenv("HOMEBREW_PREFIX") != "" && strings.HasPrefix(binaryPath, os.Getenv("HOMEBREW_PREFIX")) {
    return InstallMethodHomebrew, nil
}
```

#### 2.2 Path Analysis

```go
// Common package manager paths
packageManagerPaths := []string{
    "/usr/bin/", "/usr/local/bin/", "/opt/homebrew/bin/",  // System
    "/var/lib/apt/", "/usr/lib/rpm/",                       // Linux package DBs
}

// User-controlled paths (self-update allowed)
userPaths := []string{
    os.ExpandEnv("$HOME/bin/"),
    os.ExpandEnv("$HOME/.local/bin/"),
    os.ExpandEnv("$HOME/.cargo/bin/"),  // Common cross-tool location
}
```

#### 2.3 Metadata Detection

Check for package manager receipt files:
- Homebrew: `/usr/local/Homebrew/Cellar/openpass/*/INSTALL_RECEIPT.json`
- APT: `/var/lib/dpkg/info/openpass.list`
- RPM: Query `rpm -ql openpass` (if available)

#### 2.4 Go Install Detection

Detect `go install` installations by checking if binary path contains Go module cache:
```go
if strings.Contains(binaryPath, "/go/pkg/mod/") || strings.Contains(binaryPath, "/go/bin/") {
    return InstallMethodGoInstall, nil
}
```

#### 2.5 Fallback Behavior

When detection fails to conclusively identify installation method:
1. Check if binary directory is user-writable
2. If writable and not in known system paths: allow self-update with warning
3. If unwritable or in system path: deny self-update with guidance

```go
func isUserWritable(path string) bool {
    info, err := os.Stat(filepath.Dir(path))
    if err != nil {
        return false
    }
    return info.Mode().Perm()&0200 != 0  // User write permission
}
```

### 3. Security Considerations

#### 3.1 Checksum Verification (SHA256)

**Requirement:** All downloaded archives must be verified against the official `OpenPass_{version}_checksums.txt` file.

**Implementation:**
```go
// Download checksums file over HTTPS
checksumsURL := fmt.Sprintf(
    "https://github.com/danieljustus/OpenPass/releases/download/v%s/OpenPass_%s_checksums.txt",
    version, version,
)

// Parse checksums file (format: "sha256  filename")
expectedSHA256 := parseChecksumsFile(checksumsContent, archiveName)

// Verify downloaded archive
actualSHA256 := computeSHA256(downloadedArchive)
if actualSHA256 != expectedSHA256 {
    return fmt.Errorf("checksum mismatch: expected %s, got %s", expectedSHA256, actualSHA256)
}
```

#### 3.2 Signature Verification (Cosign/Keyless Signing)

**Future consideration:** Implement Sigstore cosign keyless signing for release artifacts.

**Current decision:** Defer to next release cycle. Rationale:
- Adds complexity to release pipeline
- Requires GitHub Actions OIDC integration
- Checksum verification provides baseline security for initial implementation

**Future implementation path:**
```yaml
# .goreleaser.yml addition
signs:
  - cmd: cosign
    args:
      - "sign-blob"
      - "--output-signature"
      - "${artifact}.sig"
      - "${artifact}"
      - "--output-certificate"
      - "${artifact}.cert"
    artifacts: all
```

#### 3.3 Path Traversal Prevention

**Risk:** Malicious or corrupted archives could contain paths like `../../etc/passwd`.

**Mitigation:** Validate all extracted paths before writing:

```go
func safeExtract(archive *tar.Reader, destDir string) error {
    for {
        header, err := archive.Next()
        if err == io.EOF {
            break
        }
        
        // Normalize and validate path
        cleanPath := filepath.Clean(filepath.Join(destDir, header.Name))
        
        // Ensure path is within destination directory
        if !strings.HasPrefix(cleanPath, filepath.Clean(destDir)) {
            return fmt.Errorf("path traversal detected: %s", header.Name)
        }
        
        // Extract file...
    }
}
```

#### 3.4 HTTPS-Only Downloads

**Requirement:** All update artifacts must be downloaded over HTTPS.

**Implementation:**
```go
if !strings.HasPrefix(downloadURL, "https://") {
    return fmt.Errorf("insecure download URL: must use HTTPS")
}

client := &http.Client{
    Timeout: 30 * time.Second,
    Transport: &http.Transport{
        TLSHandshakeTimeout: 10 * time.Second,
        ForceAttemptHTTP2:   true,
    },
}
```

#### 3.5 Rate Limiting and Timeout Handling

**GitHub API rate limits:** 60 requests/hour for unauthenticated, 5000/hour for authenticated.

**Mitigation strategies:**
1. Cache last check timestamp (store in `~/.openpass/update-cache.json`)
2. Enforce minimum 1-hour interval between checks
3. Exponential backoff on HTTP errors
4. Clear error messages on rate limit:

```go
if resp.StatusCode == http.StatusForbidden && resp.Header.Get("X-RateLimit-Remaining") == "0" {
    resetTime := resp.Header.Get("X-RateLimit-Reset")
    return fmt.Errorf(
        "GitHub API rate limit exceeded. Try again after %s",
        formatUnixTimestamp(resetTime),
    )
}
```

### 4. Binary Replacement Strategy

#### 4.1 Atomic Replace vs In-Place Overwrite

**Decision:** Use atomic replacement via temporary file + rename.

**Rationale:**
- In-place overwrite risks corruption if process is interrupted
- Rename is atomic on POSIX systems
- Allows rollback if verification fails

**Implementation:**
```go
func atomicReplace(oldBinary, newBinary string) error {
    // Create temp file in same directory (same filesystem for atomic rename)
    tempFile, err := os.CreateTemp(filepath.Dir(oldBinary), "openpass-update-*"))
    if err != nil {
        return err
    }
    tempPath := tempFile.Name()
    
    // Write new binary
    if _, err := io.Copy(tempFile, newBinaryReader); err != nil {
        os.Remove(tempPath)  // Cleanup on failure
        return err
    }
    tempFile.Close()
    
    // Preserve permissions
    oldInfo, err := os.Stat(oldBinary)
    if err == nil {
        os.Chmod(tempPath, oldInfo.Mode())
    }
    
    // Atomic rename
    if err := os.Rename(tempPath, oldBinary); err != nil {
        os.Remove(tempPath)
        return err
    }
    
    return nil
}
```

#### 4.2 Backup and Rollback

**Requirement:** Maintain backup of previous binary until new binary is verified working.

**Implementation:**
```go
func createBackup(binaryPath string) (string, error) {
    backupPath := binaryPath + ".backup"
    if err := copyFile(binaryPath, backupPath); err != nil {
        return "", err
    }
    return backupPath, nil
}

func rollback(backupPath, originalPath string) error {
    if err := atomicReplace(originalPath, backupPath); err != nil {
        return fmt.Errorf("rollback failed: %w", err)
    }
    return nil
}
```

**Post-update verification:** After successful update, run `openpass --version` to verify new binary executes correctly before removing backup.

#### 4.3 Windows-Specific Handling

**Challenge:** Windows locks running executables, preventing replacement.

**Solution:** Use the "move-rename-delete" pattern:

```go
// Windows-specific update flow
func updateOnWindows(currentBinary, newBinary string) error {
    // 1. Rename current binary to .old
    oldBinary := currentBinary + ".old"
    if err := os.Rename(currentBinary, oldBinary); err != nil {
        return err
    }
    
    // 2. Move new binary into place
    if err := os.Rename(newBinary, currentBinary); err != nil {
        // Rollback: restore old binary
        os.Rename(oldBinary, currentBinary)
        return err
    }
    
    // 3. Schedule .old for deletion on next boot (handles locked files)
    // Use MoveFileEx with MOVEFILE_DELAY_UNTIL_REBOOT via Windows API
    scheduleDeleteOnReboot(oldBinary)
    
    return nil
}
```

#### 4.4 Permission Preservation

**Requirement:** New binary must have same permissions as old binary.

**Implementation:**
```go
func preservePermissions(source, dest string) error {
    info, err := os.Stat(source)
    if err != nil {
        return err
    }
    return os.Chmod(dest, info.Mode())
}
```

**Special case:** If binary has setuid/setgid bits, warn user and require explicit confirmation.

### 5. UX for Unsupported Cases

#### 5.1 Clear Messaging

When self-update is unavailable, provide actionable guidance:

```
$ openpass update apply

Self-update is not available for your installation method.

Detected: Homebrew installation
Location: /opt/homebrew/bin/openpass

To update OpenPass, use your package manager:

  brew upgrade openpass

Alternatively, download the latest release manually:
https://github.com/danieljustus/OpenPass/releases/tag/v1.2.3
```

#### 5.2 Installation-Specific Guidance

| Installation Method | Message |
|---------------------|---------|
| Homebrew | `brew upgrade openpass` |
| APT | `sudo apt update && sudo apt install openpass` |
| RPM | `sudo dnf update openpass` or `sudo yum update openpass` |
| Go install | `go install github.com/danieljustus/OpenPass@latest` |
| Package manager (unknown) | "Use your package manager to update OpenPass" |
| Manual build | "Rebuild from source or download binary from GitHub Releases" |

#### 5.3 No Silent Failures

**Rule:** Never silently skip update. Always inform user:
- Why self-update is unavailable
- What installation method was detected
- Exact command to run for their installation method
- Link to manual download as fallback

### 6. Implementation Scope Decision

#### 6.1 Recommended for Next Cycle: YES (Limited Scope)

**In scope for initial implementation:**
- Self-update for direct GitHub Releases downloads only
- SHA256 checksum verification
- Atomic binary replacement with backup/rollback
- Clear messaging for unsupported installation methods
- Windows, macOS, Linux support

**Out of scope (deferred):**
- Cosign/keyless signature verification (add in v1.3.0)
- Package manager integration (never; use native package managers)
- Delta updates (binary patching for smaller downloads)
- Background/auto-update (security risk; always require explicit user action)

#### 6.2 Command Structure

```bash
# Check for updates (already exists)
openpass update check

# Apply update (new)
openpass update apply

# Show installation method (new, for debugging)
openpass update info
```

#### 6.3 Risk Assessment

| Risk | Likelihood | Impact | Mitigation |
|------|------------|--------|------------|
| Compromised release | Low | Critical | SHA256 verification, HTTPS-only downloads |
| Corrupted download | Medium | High | Checksum verification, retry logic |
| Permission denied | Medium | Medium | Clear error message, guidance |
| Bricked installation | Low | High | Backup + rollback mechanism |
| Package manager conflict | Medium | Medium | Detection + refusal to update |

## Consequences

### Positive

1. **Improved UX:** Users with direct binary installations get one-command updates
2. **Security:** Verified downloads with checksum validation reduce tampering risk
3. **Clarity:** Explicit messaging for all installation methods eliminates confusion
4. **Safety:** Rollback mechanism prevents bricked installations

### Negative

1. **Complexity:** Update logic adds ~500-800 lines of code to maintain
2. **Testing burden:** Requires extensive cross-platform testing (Windows file locking, macOS permissions, Linux SELinux/AppArmor)
3. **Support overhead:** Users may attempt self-update on unsupported installations

### Neutral

1. **Documentation requirement:** Must clearly document supported installation methods
2. **Release process:** GoReleaser configuration must ensure checksums file is always generated

## Compliance with Best Practices

This design follows patterns from established Go CLIs:

### GitHub CLI (`gh`)
- Checks for package manager installations before offering update
- Uses atomic replacement with rollback
- Provides installation-specific guidance

### HashiCorp Tools (Terraform, Vault)
- SHA256 checksum verification against official hash file
- HTTPS-only downloads from releases.hashicorp.com

### kubectl
- Verifies checksums
- Supports multiple installation methods with appropriate update paths

## References

1. **go-selfupdate library:** https://github.com/sanposhiho/go-selfupdate
   - Provides installation detection patterns
   - Implements atomic replacement strategy

2. **GitHub CLI update mechanism:** https://github.com/cli/cli/blob/trunk/cmd/gh/main.go
   - Homebrew detection logic
   - User guidance for unsupported methods

3. **Sigstore Cosign:** https://docs.sigstore.dev/cosign/overview/
   - Keyless signing for release artifacts
   - Future enhancement path

4. **GoReleaser signing:** https://goreleaser.com/customization/sign/
   - Integration with cosign for artifact signing

## Future Considerations

1. **Automatic signature verification:** Once GoReleaser + cosign integration is complete, add mandatory signature verification before accepting updates.

2. **Update channel support:** Allow users to opt into beta/stable channels via config:
   ```yaml
   update:
     channel: stable  # or "beta", "nightly"
   ```

3. **Enterprise proxy support:** Add configuration for corporate proxy environments:
   ```bash
   openpass update apply --proxy https://proxy.company.com
   ```

## Decision Record

- **2026-04-23:** ADR created for team review
- **Pending:** Team approval
- **Pending:** Implementation in next development cycle

---

*This ADR is ready for team review. All security risks are explicitly named, implementation scope is clearly bounded, and references to industry best practices are provided.*
