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()
+}