init

4 files changed, 650 insertions, 0 deletions

diff --git a/internal/config/config.go b/internal/config/config.go
new file mode 100644
index 0000000..8651aa8
--- /dev/null
+++ b/internal/config/config.go
@@ -0,0 +1,65 @@
+package config
+
+import (
+        "bufio"
+        "os"
+        "path/filepath"
+        "strings"
+)
+
+// Config represents the user's configuration
+type Config struct {
+        Host string
+}
+
+// Load reads config from ~/.config/deploy/config
+func Load() (*Config, error) {
+        path := configPath()
+
+        // If file doesn't exist, return empty config
+        if _, err := os.Stat(path); os.IsNotExist(err) {
+                return &Config{}, nil
+        }
+
+        file, err := os.Open(path)
+        if err != nil {
+                return nil, err
+        }
+        defer file.Close()
+
+        cfg := &Config{}
+        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 {
+                        continue
+                }
+
+                key := strings.TrimSpace(parts[0])
+                value := strings.TrimSpace(parts[1])
+
+                switch key {
+                case "host":
+                        cfg.Host = value
+                }
+        }
+
+        if err := scanner.Err(); err != nil {
+                return nil, err
+        }
+
+        return cfg, nil
+}
+
+func configPath() string {
+        home, err := os.UserHomeDir()
+        if err != nil {
+                return ".deploy-config"
+        }
+        return filepath.Join(home, ".config", "deploy", "config")
+}
diff --git a/internal/ssh/client.go b/internal/ssh/client.go
new file mode 100644
index 0000000..1cd336c
--- /dev/null
+++ b/internal/ssh/client.go
@@ -0,0 +1,357 @@
+package ssh
+
+import (
+        "bufio"
+        "bytes"
+        "fmt"
+        "net"
+        "os"
+        "os/exec"
+        "path/filepath"
+        "strings"
+
+        "golang.org/x/crypto/ssh"
+        "golang.org/x/crypto/ssh/agent"
+)
+
+// Client represents an SSH connection to a remote host
+type Client struct {
+        host   string
+        client *ssh.Client
+}
+
+// sshConfig holds SSH configuration for a host
+type sshConfig struct {
+        Host         string
+        HostName     string
+        User         string
+        Port         string
+        IdentityFile string
+}
+
+// Connect establishes an SSH connection to the remote host
+// Supports both SSH config aliases (e.g., "myserver") and user@host format
+func Connect(host string) (*Client, error) {
+        var user, addr string
+        var identityFile string
+
+        // Try to read SSH config first
+        cfg, err := readSSHConfig(host)
+        if err == nil && cfg.HostName != "" {
+                // Use SSH config
+                user = cfg.User
+                addr = cfg.HostName
+                if cfg.Port != "" {
+                        addr = addr + ":" + cfg.Port
+                } else {
+                        addr = addr + ":22"
+                }
+                identityFile = cfg.IdentityFile
+        } else {
+                // Fall back to parsing user@host format
+                parts := strings.SplitN(host, "@", 2)
+                if len(parts) != 2 {
+                        return nil, fmt.Errorf("host '%s' not found in SSH config and not in user@host format", host)
+                }
+                user = parts[0]
+                addr = parts[1]
+
+                // Add default port if not specified
+                if !strings.Contains(addr, ":") {
+                        addr = addr + ":22"
+                }
+        }
+
+        // Build authentication methods
+        var authMethods []ssh.AuthMethod
+
+        // Try identity file from SSH config first
+        if identityFile != "" {
+                if authMethod, err := publicKeyFromFile(identityFile); err == nil {
+                        authMethods = append(authMethods, authMethod)
+                }
+        }
+
+        // Try SSH agent
+        if authMethod, err := sshAgent(); err == nil {
+                authMethods = append(authMethods, authMethod)
+        }
+
+        // Try default key files
+        if authMethod, err := publicKeyFile(); err == nil {
+                authMethods = append(authMethods, authMethod)
+        }
+
+        if len(authMethods) == 0 {
+                return nil, fmt.Errorf("no SSH authentication method available")
+        }
+
+        config := &ssh.ClientConfig{
+                User:            user,
+                Auth:            authMethods,
+                HostKeyCallback: ssh.InsecureIgnoreHostKey(), // TODO: Consider using known_hosts
+        }
+
+        client, err := ssh.Dial("tcp", addr, config)
+        if err != nil {
+                return nil, fmt.Errorf("failed to connect to %s: %w", host, err)
+        }
+
+        return &Client{
+                host:   host,
+                client: client,
+        }, nil
+}
+
+// Close closes the SSH connection
+func (c *Client) Close() error {
+        return c.client.Close()
+}
+
+// Run executes a command on the remote host and returns the output
+func (c *Client) Run(cmd string) (string, error) {
+        session, err := c.client.NewSession()
+        if err != nil {
+                return "", err
+        }
+        defer session.Close()
+
+        var stdout, stderr bytes.Buffer
+        session.Stdout = &stdout
+        session.Stderr = &stderr
+
+        if err := session.Run(cmd); err != nil {
+                return "", fmt.Errorf("command failed: %w\nstderr: %s", err, stderr.String())
+        }
+
+        return stdout.String(), nil
+}
+
+// RunSudo executes a command with sudo on the remote host
+func (c *Client) RunSudo(cmd string) (string, error) {
+        return c.Run("sudo " + cmd)
+}
+
+// Upload copies a local file to the remote host using scp
+func (c *Client) Upload(localPath, remotePath string) error {
+        // Use external scp command for simplicity
+        // Format: scp -o StrictHostKeyChecking=no localPath user@host:remotePath
+        cmd := exec.Command("scp", "-o", "StrictHostKeyChecking=no", localPath, c.host+":"+remotePath)
+
+        var stderr bytes.Buffer
+        cmd.Stderr = &stderr
+
+        if err := cmd.Run(); err != nil {
+                return fmt.Errorf("scp failed: %w\nstderr: %s", err, stderr.String())
+        }
+
+        return nil
+}
+
+// UploadDir copies a local directory to the remote host using rsync
+func (c *Client) UploadDir(localDir, remoteDir string) error {
+        // Use rsync for directory uploads
+        // Format: rsync -avz --delete localDir/ user@host:remoteDir/
+        localDir = strings.TrimSuffix(localDir, "/") + "/"
+        remoteDir = strings.TrimSuffix(remoteDir, "/") + "/"
+
+        cmd := exec.Command("rsync", "-avz", "--delete",
+                "-e", "ssh -o StrictHostKeyChecking=no",
+                localDir, c.host+":"+remoteDir)
+
+        var stderr bytes.Buffer
+        cmd.Stderr = &stderr
+
+        if err := cmd.Run(); err != nil {
+                return fmt.Errorf("rsync failed: %w\nstderr: %s", err, stderr.String())
+        }
+
+        return nil
+}
+
+// WriteFile creates a file with the given content on the remote host
+func (c *Client) WriteFile(remotePath, content string) error {
+        session, err := c.client.NewSession()
+        if err != nil {
+                return err
+        }
+        defer session.Close()
+
+        // Use cat to write content to file
+        cmd := fmt.Sprintf("cat > %s", remotePath)
+        session.Stdin = strings.NewReader(content)
+
+        var stderr bytes.Buffer
+        session.Stderr = &stderr
+
+        if err := session.Run(cmd); err != nil {
+                return fmt.Errorf("write file failed: %w\nstderr: %s", err, stderr.String())
+        }
+
+        return nil
+}
+
+// WriteSudoFile creates a file with the given content using sudo
+func (c *Client) WriteSudoFile(remotePath, content string) error {
+        session, err := c.client.NewSession()
+        if err != nil {
+                return err
+        }
+        defer session.Close()
+
+        // Use sudo tee to write content to file
+        cmd := fmt.Sprintf("sudo tee %s > /dev/null", remotePath)
+        session.Stdin = strings.NewReader(content)
+
+        var stderr bytes.Buffer
+        session.Stderr = &stderr
+
+        if err := session.Run(cmd); err != nil {
+                return fmt.Errorf("write file with sudo failed: %w\nstderr: %s", err, stderr.String())
+        }
+
+        return nil
+}
+
+// readSSHConfig reads and parses the SSH config file for a given host
+func readSSHConfig(host string) (*sshConfig, error) {
+        home, err := os.UserHomeDir()
+        if err != nil {
+                return nil, err
+        }
+
+        configPath := filepath.Join(home, ".ssh", "config")
+        file, err := os.Open(configPath)
+        if err != nil {
+                return nil, err
+        }
+        defer file.Close()
+
+        cfg := &sshConfig{}
+        var currentHost string
+        var matchedHost bool
+
+        scanner := bufio.NewScanner(file)
+        for scanner.Scan() {
+                line := strings.TrimSpace(scanner.Text())
+
+                // Skip comments and empty lines
+                if line == "" || strings.HasPrefix(line, "#") {
+                        continue
+                }
+
+                fields := strings.Fields(line)
+                if len(fields) < 2 {
+                        continue
+                }
+
+                key := strings.ToLower(fields[0])
+                value := fields[1]
+
+                // Expand ~ in paths
+                if strings.HasPrefix(value, "~/") {
+                        value = filepath.Join(home, value[2:])
+                }
+
+                switch key {
+                case "host":
+                        currentHost = value
+                        if currentHost == host {
+                                matchedHost = true
+                                cfg.Host = host
+                        } else {
+                                matchedHost = false
+                        }
+                case "hostname":
+                        if matchedHost {
+                                cfg.HostName = value
+                        }
+                case "user":
+                        if matchedHost {
+                                cfg.User = value
+                        }
+                case "port":
+                        if matchedHost {
+                                cfg.Port = value
+                        }
+                case "identityfile":
+                        if matchedHost {
+                                cfg.IdentityFile = value
+                        }
+                }
+        }
+
+        if err := scanner.Err(); err != nil {
+                return nil, err
+        }
+
+        if cfg.Host == "" {
+                return nil, fmt.Errorf("host %s not found in SSH config", host)
+        }
+
+        return cfg, nil
+}
+
+// sshAgent returns an auth method using SSH agent
+func sshAgent() (ssh.AuthMethod, error) {
+        socket := os.Getenv("SSH_AUTH_SOCK")
+        if socket == "" {
+                return nil, fmt.Errorf("SSH_AUTH_SOCK not set")
+        }
+
+        conn, err := net.Dial("unix", socket)
+        if err != nil {
+                return nil, fmt.Errorf("failed to connect to SSH agent: %w", err)
+        }
+
+        agentClient := agent.NewClient(conn)
+        return ssh.PublicKeysCallback(agentClient.Signers), nil
+}
+
+// publicKeyFromFile returns an auth method from a specific private key file
+func publicKeyFromFile(keyPath string) (ssh.AuthMethod, error) {
+        key, err := os.ReadFile(keyPath)
+        if err != nil {
+                return nil, err
+        }
+
+        signer, err := ssh.ParsePrivateKey(key)
+        if err != nil {
+                return nil, err
+        }
+
+        return ssh.PublicKeys(signer), nil
+}
+
+// publicKeyFile returns an auth method using a private key file
+func publicKeyFile() (ssh.AuthMethod, error) {
+        home, err := os.UserHomeDir()
+        if err != nil {
+                return nil, err
+        }
+
+        // Try common key locations
+        keyPaths := []string{
+                filepath.Join(home, ".ssh", "id_rsa"),
+                filepath.Join(home, ".ssh", "id_ed25519"),
+                filepath.Join(home, ".ssh", "id_ecdsa"),
+        }
+
+        for _, keyPath := range keyPaths {
+                if _, err := os.Stat(keyPath); err == nil {
+                        key, err := os.ReadFile(keyPath)
+                        if err != nil {
+                                continue
+                        }
+
+                        signer, err := ssh.ParsePrivateKey(key)
+                        if err != nil {
+                                continue
+                        }
+
+                        return ssh.PublicKeys(signer), nil
+                }
+        }
+
+        return nil, fmt.Errorf("no SSH private key found")
+}
diff --git a/internal/state/state.go b/internal/state/state.go
new file mode 100644
index 0000000..c7c7dd4
--- /dev/null
+++ b/internal/state/state.go
@@ -0,0 +1,146 @@
+package state
+
+import (
+        "encoding/json"
+        "fmt"
+        "os"
+        "path/filepath"
+)
+
+// State represents the entire local deployment state
+type State struct {
+        Hosts map[string]*Host `json:"hosts"`
+}
+
+// Host represents deployment state for a single VPS
+type Host struct {
+        NextPort int             `json:"next_port"`
+        Apps     map[string]*App `json:"apps"`
+}
+
+// App represents a deployed application or static site
+type App struct {
+        Type   string            `json:"type"` // "app" or "static"
+        Domain string            `json:"domain"`
+        Port   int               `json:"port,omitempty"` // only for type="app"
+        Env    map[string]string `json:"env,omitempty"`  // only for type="app"
+}
+
+const (
+        startPort = 8001
+)
+
+// Load reads state from ~/.config/deploy/state.json
+func Load() (*State, error) {
+        path := statePath()
+
+        // If file doesn't exist, return empty state
+        if _, err := os.Stat(path); os.IsNotExist(err) {
+                return &State{
+                        Hosts: make(map[string]*Host),
+                }, nil
+        }
+
+        data, err := os.ReadFile(path)
+        if err != nil {
+                return nil, fmt.Errorf("failed to read state file: %w", err)
+        }
+
+        var state State
+        if err := json.Unmarshal(data, &state); err != nil {
+                return nil, fmt.Errorf("failed to parse state file: %w", err)
+        }
+
+        // Initialize maps if nil
+        if state.Hosts == nil {
+                state.Hosts = make(map[string]*Host)
+        }
+
+        return &state, nil
+}
+
+// Save writes state to ~/.config/deploy/state.json
+func (s *State) Save() error {
+        path := statePath()
+
+        // Ensure directory exists
+        dir := filepath.Dir(path)
+        if err := os.MkdirAll(dir, 0755); err != nil {
+                return fmt.Errorf("failed to create config directory: %w", err)
+        }
+
+        data, err := json.MarshalIndent(s, "", "  ")
+        if err != nil {
+                return fmt.Errorf("failed to marshal state: %w", err)
+        }
+
+        if err := os.WriteFile(path, data, 0600); err != nil {
+                return fmt.Errorf("failed to write state file: %w", err)
+        }
+
+        return nil
+}
+
+// GetHost returns the host state, creating it if it doesn't exist
+func (s *State) GetHost(host string) *Host {
+        if s.Hosts[host] == nil {
+                s.Hosts[host] = &Host{
+                        NextPort: startPort,
+                        Apps:     make(map[string]*App),
+                }
+        }
+        if s.Hosts[host].Apps == nil {
+                s.Hosts[host].Apps = make(map[string]*App)
+        }
+        return s.Hosts[host]
+}
+
+// AllocatePort returns the next available port for a host
+func (s *State) AllocatePort(host string) int {
+        h := s.GetHost(host)
+        port := h.NextPort
+        h.NextPort++
+        return port
+}
+
+// AddApp adds or updates an app in the state
+func (s *State) AddApp(host, name string, app *App) {
+        h := s.GetHost(host)
+        h.Apps[name] = app
+}
+
+// RemoveApp removes an app from the state
+func (s *State) RemoveApp(host, name string) error {
+        h := s.GetHost(host)
+        if _, exists := h.Apps[name]; !exists {
+                return fmt.Errorf("app %s not found", name)
+        }
+        delete(h.Apps, name)
+        return nil
+}
+
+// GetApp returns an app from the state
+func (s *State) GetApp(host, name string) (*App, error) {
+        h := s.GetHost(host)
+        app, exists := h.Apps[name]
+        if !exists {
+                return nil, fmt.Errorf("app %s not found", name)
+        }
+        return app, nil
+}
+
+// ListApps returns all apps for a host
+func (s *State) ListApps(host string) map[string]*App {
+        h := s.GetHost(host)
+        return h.Apps
+}
+
+// statePath returns the path to the state file
+func statePath() string {
+        home, err := os.UserHomeDir()
+        if err != nil {
+                // Fallback to current directory (should rarely happen)
+                return ".deploy-state.json"
+        }
+        return filepath.Join(home, ".config", "deploy", "state.json")
+}
diff --git a/internal/templates/templates.go b/internal/templates/templates.go
new file mode 100644
index 0000000..d90163d
--- /dev/null
+++ b/internal/templates/templates.go
@@ -0,0 +1,82 @@
+package templates
+
+import (
+        "bytes"
+        "text/template"
+)
+
+var serviceTemplate = `[Unit]
+Description={{.Name}}
+After=network.target
+
+[Service]
+Type=simple
+User={{.User}}
+WorkingDirectory={{.WorkDir}}
+EnvironmentFile={{.EnvFile}}
+ExecStart={{.BinaryPath}} --port={{.Port}}
+Restart=always
+RestartSec=5s
+NoNewPrivileges=true
+PrivateTmp=true
+
+[Install]
+WantedBy=multi-user.target
+`
+
+var appCaddyTemplate = `{{.Domain}} {
+    reverse_proxy 127.0.0.1:{{.Port}}
+}
+`
+
+var staticCaddyTemplate = `{{.Domain}} {
+    root * {{.RootDir}}
+    file_server
+    encode gzip
+}
+`
+
+// SystemdService generates a systemd service unit file
+func SystemdService(data map[string]string) (string, error) {
+        tmpl, err := template.New("service").Parse(serviceTemplate)
+        if err != nil {
+                return "", err
+        }
+
+        var buf bytes.Buffer
+        if err := tmpl.Execute(&buf, data); err != nil {
+                return "", err
+        }
+
+        return buf.String(), nil
+}
+
+// AppCaddy generates a Caddy config for a Go app
+func AppCaddy(data map[string]string) (string, error) {
+        tmpl, err := template.New("caddy").Parse(appCaddyTemplate)
+        if err != nil {
+                return "", err
+        }
+
+        var buf bytes.Buffer
+        if err := tmpl.Execute(&buf, data); err != nil {
+                return "", err
+        }
+
+        return buf.String(), nil
+}
+
+// StaticCaddy generates a Caddy config for a static site
+func StaticCaddy(data map[string]string) (string, error) {
+        tmpl, err := template.New("caddy").Parse(staticCaddyTemplate)
+        if err != nil {
+                return "", err
+        }
+
+        var buf bytes.Buffer
+        if err := tmpl.Execute(&buf, data); err != nil {
+                return "", err
+        }
+
+        return buf.String(), nil
+}