Add deploy command and fix static site naming

Static sites now default to using the domain as the name instead of
the source directory basename, preventing conflicts when multiple
sites use the same directory name (e.g., dist).

Also fixes .gitignore to not exclude cmd/deploy/ directory.

1 files changed, 494 insertions, 0 deletions

diff --git a/cmd/deploy/deploy.go b/cmd/deploy/deploy.go
new file mode 100644
index 0000000..2b3ab4a
--- /dev/null
+++ b/cmd/deploy/deploy.go
@@ -0,0 +1,494 @@
+package main
+
+import (
+        "bufio"
+        "flag"
+        "fmt"
+        "os"
+        "path/filepath"
+        "strconv"
+        "strings"
+
+        "github.com/bdw/deploy/internal/config"
+        "github.com/bdw/deploy/internal/ssh"
+        "github.com/bdw/deploy/internal/state"
+        "github.com/bdw/deploy/internal/templates"
+)
+
+type envFlags []string
+
+func (e *envFlags) String() string {
+        return strings.Join(*e, ",")
+}
+
+func (e *envFlags) Set(value string) error {
+        *e = append(*e, value)
+        return nil
+}
+
+type fileFlags []string
+
+func (f *fileFlags) String() string {
+        return strings.Join(*f, ",")
+}
+
+func (f *fileFlags) Set(value string) error {
+        *f = append(*f, value)
+        return nil
+}
+
+func runDeploy(args []string) {
+        fs := flag.NewFlagSet("deploy", flag.ExitOnError)
+        host := fs.String("host", "", "VPS host (SSH config alias or user@host)")
+        domain := fs.String("domain", "", "Domain name (required)")
+        name := fs.String("name", "", "App name (default: inferred from binary or directory)")
+        binary := fs.String("binary", "", "Path to Go binary (for app deployment)")
+        static := fs.Bool("static", false, "Deploy as static site")
+        dir := fs.String("dir", ".", "Directory to deploy (for static sites)")
+        port := fs.Int("port", 0, "Port override (default: auto-allocate)")
+        var envVars envFlags
+        fs.Var(&envVars, "env", "Environment variable (KEY=VALUE, can be specified multiple times)")
+        envFile := fs.String("env-file", "", "Path to .env file")
+        binaryArgs := fs.String("args", "", "Arguments to pass to binary")
+        var files fileFlags
+        fs.Var(&files, "file", "Config file to upload to working directory (can be specified multiple times)")
+
+        fs.Parse(args)
+
+        // Get host from flag or config
+        if *host == "" {
+                cfg, err := config.Load()
+                if err != nil {
+                        fmt.Fprintf(os.Stderr, "Error loading config: %v\n", err)
+                        os.Exit(1)
+                }
+                *host = cfg.Host
+        }
+
+        if *host == "" || *domain == "" {
+                fmt.Fprintf(os.Stderr, "Error: --host and --domain are required\n")
+                fs.Usage()
+                os.Exit(1)
+        }
+
+        if *static {
+                deployStatic(*host, *domain, *name, *dir)
+        } else {
+                deployApp(*host, *domain, *name, *binary, *port, envVars, *envFile, *binaryArgs, files)
+        }
+}
+
+func deployApp(host, domain, name, binaryPath string, portOverride int, envVars []string, envFile, args string, files []string) {
+        // Determine app name
+        if name == "" {
+                if binaryPath != "" {
+                        name = filepath.Base(binaryPath)
+                } else {
+                        // Try to find a binary in current directory
+                        cwd, _ := os.Getwd()
+                        name = filepath.Base(cwd)
+                }
+        }
+
+        // Find binary if not specified
+        if binaryPath == "" {
+                // Look for binary with same name as directory
+                if _, err := os.Stat(name); err == nil {
+                        binaryPath = name
+                } else {
+                        fmt.Fprintf(os.Stderr, "Error: --binary is required (could not find binary in current directory)\n")
+                        os.Exit(1)
+                }
+        }
+
+        // Verify binary exists
+        if _, err := os.Stat(binaryPath); err != nil {
+                fmt.Fprintf(os.Stderr, "Error: binary not found: %s\n", binaryPath)
+                os.Exit(1)
+        }
+
+        fmt.Printf("Deploying app: %s\n", name)
+        fmt.Printf("  Domain: %s\n", domain)
+        fmt.Printf("  Binary: %s\n", binaryPath)
+
+        // Load state
+        st, err := state.Load()
+        if err != nil {
+                fmt.Fprintf(os.Stderr, "Error loading state: %v\n", err)
+                os.Exit(1)
+        }
+
+        // Check if app already exists (update) or new deployment
+        existingApp, _ := st.GetApp(host, name)
+        var port int
+        if existingApp != nil {
+                port = existingApp.Port
+                fmt.Printf("  Updating existing deployment (port %d)\n", port)
+        } else {
+                if portOverride > 0 {
+                        port = portOverride
+                } else {
+                        port = st.AllocatePort(host)
+                }
+                fmt.Printf("  Allocated port: %d\n", port)
+        }
+
+        // Parse environment variables
+        env := make(map[string]string)
+        if existingApp != nil {
+                // Preserve existing env vars
+                for k, v := range existingApp.Env {
+                        env[k] = v
+                }
+                // Preserve existing args if not provided
+                if args == "" && existingApp.Args != "" {
+                        args = existingApp.Args
+                }
+                // Preserve existing files if not provided
+                if len(files) == 0 && len(existingApp.Files) > 0 {
+                        files = existingApp.Files
+                }
+        }
+
+        // Add/override from flags
+        for _, e := range envVars {
+                parts := strings.SplitN(e, "=", 2)
+                if len(parts) == 2 {
+                        env[parts[0]] = parts[1]
+                }
+        }
+
+        // Add/override from file
+        if envFile != "" {
+                fileEnv, err := parseEnvFile(envFile)
+                if err != nil {
+                        fmt.Fprintf(os.Stderr, "Error reading env file: %v\n", err)
+                        os.Exit(1)
+                }
+                for k, v := range fileEnv {
+                        env[k] = v
+                }
+        }
+
+        // Always set PORT
+        env["PORT"] = strconv.Itoa(port)
+
+        // Connect to VPS
+        client, err := ssh.Connect(host)
+        if err != nil {
+                fmt.Fprintf(os.Stderr, "Error connecting to VPS: %v\n", err)
+                os.Exit(1)
+        }
+        defer client.Close()
+
+        // Upload binary
+        fmt.Println("→ Uploading binary...")
+        remoteTmpPath := fmt.Sprintf("/tmp/%s", name)
+        if err := client.Upload(binaryPath, remoteTmpPath); err != nil {
+                fmt.Fprintf(os.Stderr, "Error uploading binary: %v\n", err)
+                os.Exit(1)
+        }
+
+        // Create user (ignore error if already exists)
+        fmt.Println("→ Creating system user...")
+        client.RunSudo(fmt.Sprintf("useradd -r -s /bin/false %s", name))
+
+        // Create working directory
+        fmt.Println("→ Setting up directories...")
+        workDir := fmt.Sprintf("/var/lib/%s", name)
+        if _, err := client.RunSudo(fmt.Sprintf("mkdir -p %s", workDir)); err != nil {
+                fmt.Fprintf(os.Stderr, "Error creating work directory: %v\n", err)
+                os.Exit(1)
+        }
+        if _, err := client.RunSudo(fmt.Sprintf("chown %s:%s %s", name, name, workDir)); err != nil {
+                fmt.Fprintf(os.Stderr, "Error setting work directory ownership: %v\n", err)
+                os.Exit(1)
+        }
+
+        // Move binary to /usr/local/bin
+        fmt.Println("→ Installing binary...")
+        binaryDest := fmt.Sprintf("/usr/local/bin/%s", name)
+        if _, err := client.RunSudo(fmt.Sprintf("mv %s %s", remoteTmpPath, binaryDest)); err != nil {
+                fmt.Fprintf(os.Stderr, "Error moving binary: %v\n", err)
+                os.Exit(1)
+        }
+        if _, err := client.RunSudo(fmt.Sprintf("chmod +x %s", binaryDest)); err != nil {
+                fmt.Fprintf(os.Stderr, "Error making binary executable: %v\n", err)
+                os.Exit(1)
+        }
+
+        // Upload config files to working directory
+        if len(files) > 0 {
+                fmt.Println("→ Uploading config files...")
+                for _, file := range files {
+                        // Verify file exists locally
+                        if _, err := os.Stat(file); err != nil {
+                                fmt.Fprintf(os.Stderr, "Error: config file not found: %s\n", file)
+                                os.Exit(1)
+                        }
+
+                        // Determine remote path (preserve filename)
+                        remotePath := fmt.Sprintf("%s/%s", workDir, filepath.Base(file))
+                        remoteTmpPath := fmt.Sprintf("/tmp/%s_%s", name, filepath.Base(file))
+
+                        // Upload to tmp first
+                        if err := client.Upload(file, remoteTmpPath); err != nil {
+                                fmt.Fprintf(os.Stderr, "Error uploading config file %s: %v\n", file, err)
+                                os.Exit(1)
+                        }
+
+                        // Move to working directory
+                        if _, err := client.RunSudo(fmt.Sprintf("mv %s %s", remoteTmpPath, remotePath)); err != nil {
+                                fmt.Fprintf(os.Stderr, "Error moving config file %s: %v\n", file, err)
+                                os.Exit(1)
+                        }
+
+                        // Set ownership
+                        if _, err := client.RunSudo(fmt.Sprintf("chown %s:%s %s", name, name, remotePath)); err != nil {
+                                fmt.Fprintf(os.Stderr, "Error setting config file ownership %s: %v\n", file, err)
+                                os.Exit(1)
+                        }
+
+                        fmt.Printf("  Uploaded: %s\n", file)
+                }
+        }
+
+        // Create env file
+        fmt.Println("→ Creating environment file...")
+        envFilePath := fmt.Sprintf("/etc/deploy/env/%s.env", name)
+        envContent := ""
+        for k, v := range env {
+                envContent += fmt.Sprintf("%s=%s\n", k, v)
+        }
+        if err := client.WriteSudoFile(envFilePath, envContent); err != nil {
+                fmt.Fprintf(os.Stderr, "Error creating env file: %v\n", err)
+                os.Exit(1)
+        }
+        if _, err := client.RunSudo(fmt.Sprintf("chmod 600 %s", envFilePath)); err != nil {
+                fmt.Fprintf(os.Stderr, "Error setting env file permissions: %v\n", err)
+                os.Exit(1)
+        }
+        if _, err := client.RunSudo(fmt.Sprintf("chown %s:%s %s", name, name, envFilePath)); err != nil {
+                fmt.Fprintf(os.Stderr, "Error setting env file ownership: %v\n", err)
+                os.Exit(1)
+        }
+
+        // Generate systemd unit
+        fmt.Println("→ Creating systemd service...")
+        serviceContent, err := templates.SystemdService(map[string]string{
+                "Name":       name,
+                "User":       name,
+                "WorkDir":    workDir,
+                "BinaryPath": binaryDest,
+                "Port":       strconv.Itoa(port),
+                "EnvFile":    envFilePath,
+                "Args":       args,
+        })
+        if err != nil {
+                fmt.Fprintf(os.Stderr, "Error generating systemd unit: %v\n", err)
+                os.Exit(1)
+        }
+
+        servicePath := fmt.Sprintf("/etc/systemd/system/%s.service", name)
+        if err := client.WriteSudoFile(servicePath, serviceContent); err != nil {
+                fmt.Fprintf(os.Stderr, "Error creating systemd unit: %v\n", err)
+                os.Exit(1)
+        }
+
+        // Generate Caddy config
+        fmt.Println("→ Configuring Caddy...")
+        caddyContent, err := templates.AppCaddy(map[string]string{
+                "Domain": domain,
+                "Port":   strconv.Itoa(port),
+        })
+        if err != nil {
+                fmt.Fprintf(os.Stderr, "Error generating Caddy config: %v\n", err)
+                os.Exit(1)
+        }
+
+        caddyPath := fmt.Sprintf("/etc/caddy/sites-enabled/%s.caddy", name)
+        if err := client.WriteSudoFile(caddyPath, caddyContent); err != nil {
+                fmt.Fprintf(os.Stderr, "Error creating Caddy config: %v\n", err)
+                os.Exit(1)
+        }
+
+        // Reload systemd
+        fmt.Println("→ Reloading systemd...")
+        if _, err := client.RunSudo("systemctl daemon-reload"); err != nil {
+                fmt.Fprintf(os.Stderr, "Error reloading systemd: %v\n", err)
+                os.Exit(1)
+        }
+
+        // Enable and start service
+        fmt.Println("→ Starting service...")
+        if _, err := client.RunSudo(fmt.Sprintf("systemctl enable %s", name)); err != nil {
+                fmt.Fprintf(os.Stderr, "Error enabling service: %v\n", err)
+                os.Exit(1)
+        }
+        if _, err := client.RunSudo(fmt.Sprintf("systemctl restart %s", name)); err != nil {
+                fmt.Fprintf(os.Stderr, "Error starting service: %v\n", err)
+                os.Exit(1)
+        }
+
+        // Reload Caddy
+        fmt.Println("→ Reloading Caddy...")
+        if _, err := client.RunSudo("systemctl reload caddy"); err != nil {
+                fmt.Fprintf(os.Stderr, "Error reloading Caddy: %v\n", err)
+                os.Exit(1)
+        }
+
+        // Update state
+        st.AddApp(host, name, &state.App{
+                Type:   "app",
+                Domain: domain,
+                Port:   port,
+                Env:    env,
+                Args:   args,
+                Files:  files,
+        })
+        if err := st.Save(); err != nil {
+                fmt.Fprintf(os.Stderr, "Error saving state: %v\n", err)
+                os.Exit(1)
+        }
+
+        fmt.Printf("\n✓ App deployed successfully!\n")
+        fmt.Printf("  https://%s (may take a minute for HTTPS cert)\n", domain)
+}
+
+func deployStatic(host, domain, name, dir string) {
+        // Determine site name (default to domain to avoid conflicts)
+        if name == "" {
+                name = domain
+        }
+
+        // Verify directory exists
+        if _, err := os.Stat(dir); err != nil {
+                fmt.Fprintf(os.Stderr, "Error: directory not found: %s\n", dir)
+                os.Exit(1)
+        }
+
+        fmt.Printf("Deploying static site: %s\n", name)
+        fmt.Printf("  Domain: %s\n", domain)
+        fmt.Printf("  Directory: %s\n", dir)
+
+        // Load state
+        st, err := state.Load()
+        if err != nil {
+                fmt.Fprintf(os.Stderr, "Error loading state: %v\n", err)
+                os.Exit(1)
+        }
+
+        // Connect to VPS
+        client, err := ssh.Connect(host)
+        if err != nil {
+                fmt.Fprintf(os.Stderr, "Error connecting to VPS: %v\n", err)
+                os.Exit(1)
+        }
+        defer client.Close()
+
+        // Create remote directory
+        remoteDir := fmt.Sprintf("/var/www/%s", name)
+        fmt.Println("→ Creating remote directory...")
+        if _, err := client.RunSudo(fmt.Sprintf("mkdir -p %s", remoteDir)); err != nil {
+                fmt.Fprintf(os.Stderr, "Error creating remote directory: %v\n", err)
+                os.Exit(1)
+        }
+
+        // Get current user for temporary ownership during upload
+        currentUser, err := client.Run("whoami")
+        if err != nil {
+                fmt.Fprintf(os.Stderr, "Error getting current user: %v\n", err)
+                os.Exit(1)
+        }
+        currentUser = strings.TrimSpace(currentUser)
+
+        // Set ownership to current user for upload
+        if _, err := client.RunSudo(fmt.Sprintf("chown -R %s:%s %s", currentUser, currentUser, remoteDir)); err != nil {
+                fmt.Fprintf(os.Stderr, "Error setting temporary ownership: %v\n", err)
+                os.Exit(1)
+        }
+
+        // Upload files
+        fmt.Println("→ Uploading files...")
+        if err := client.UploadDir(dir, remoteDir); err != nil {
+                fmt.Fprintf(os.Stderr, "Error uploading files: %v\n", err)
+                os.Exit(1)
+        }
+
+        // Set ownership and permissions
+        fmt.Println("→ Setting permissions...")
+        if _, err := client.RunSudo(fmt.Sprintf("chown -R www-data:www-data %s", remoteDir)); err != nil {
+                fmt.Fprintf(os.Stderr, "Error setting ownership: %v\n", err)
+                os.Exit(1)
+        }
+        // Make files readable by all (755 for dirs, 644 for files)
+        if _, err := client.RunSudo(fmt.Sprintf("chmod -R 755 %s", remoteDir)); err != nil {
+                fmt.Fprintf(os.Stderr, "Error setting directory permissions: %v\n", err)
+                os.Exit(1)
+        }
+        if _, err := client.RunSudo(fmt.Sprintf("find %s -type f -exec chmod 644 {} \\;", remoteDir)); err != nil {
+                fmt.Fprintf(os.Stderr, "Error setting file permissions: %v\n", err)
+                os.Exit(1)
+        }
+
+        // Generate Caddy config
+        fmt.Println("→ Configuring Caddy...")
+        caddyContent, err := templates.StaticCaddy(map[string]string{
+                "Domain":  domain,
+                "RootDir": remoteDir,
+        })
+        if err != nil {
+                fmt.Fprintf(os.Stderr, "Error generating Caddy config: %v\n", err)
+                os.Exit(1)
+        }
+
+        caddyPath := fmt.Sprintf("/etc/caddy/sites-enabled/%s.caddy", name)
+        if err := client.WriteSudoFile(caddyPath, caddyContent); err != nil {
+                fmt.Fprintf(os.Stderr, "Error creating Caddy config: %v\n", err)
+                os.Exit(1)
+        }
+
+        // Reload Caddy
+        fmt.Println("→ Reloading Caddy...")
+        if _, err := client.RunSudo("systemctl reload caddy"); err != nil {
+                fmt.Fprintf(os.Stderr, "Error reloading Caddy: %v\n", err)
+                os.Exit(1)
+        }
+
+        // Update state
+        st.AddApp(host, name, &state.App{
+                Type:   "static",
+                Domain: domain,
+        })
+        if err := st.Save(); err != nil {
+                fmt.Fprintf(os.Stderr, "Error saving state: %v\n", err)
+                os.Exit(1)
+        }
+
+        fmt.Printf("\n✓ Static site deployed successfully!\n")
+        fmt.Printf("  https://%s (may take a minute for HTTPS cert)\n", domain)
+}
+
+func parseEnvFile(path string) (map[string]string, error) {
+        file, err := os.Open(path)
+        if err != nil {
+                return nil, err
+        }
+        defer file.Close()
+
+        env := make(map[string]string)
+        scanner := bufio.NewScanner(file)
+        for scanner.Scan() {
+                line := strings.TrimSpace(scanner.Text())
+                if line == "" || strings.HasPrefix(line, "#") {
+                        continue
+                }
+
+                parts := strings.SplitN(line, "=", 2)
+                if len(parts) == 2 {
+                        env[parts[0]] = parts[1]
+                }
+        }
+
+        return env, scanner.Err()
+}