heyvm 1.0.0

package/core/internal/sftp/manager.go

@@ -0,0 +1,303 @@
+package sftp
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+
+	"github.com/pkg/sftp"
+	"golang.org/x/crypto/ssh"
+)
+
+// Manager handles SFTP file operations
+type Manager struct {
+	client *sftp.Client
+	ssh    *ssh.Client
+}
+
+// NewManager creates a new SFTP manager from an SSH client
+func NewManager(sshClient *ssh.Client) (*Manager, error) {
+	if sshClient == nil {
+		return nil, fmt.Errorf("SSH client cannot be nil")
+	}
+
+	// Create SFTP client
+	client, err := sftp.NewClient(sshClient)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create SFTP client: %w", err)
+	}
+
+	return &Manager{
+		client: client,
+		ssh:    sshClient,
+	}, nil
+}
+
+// List lists files and directories at the specified path
+func (m *Manager) List(path string) ([]FileInfo, error) {
+	if m.client == nil {
+		return nil, ErrSFTPClientNotInitialized
+	}
+
+	// Read directory
+	entries, err := m.client.ReadDir(path)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read directory: %w", err)
+	}
+
+	// Convert to FileInfo
+	files := make([]FileInfo, 0, len(entries))
+	for _, entry := range entries {
+		files = append(files, FileInfo{
+			Name:    entry.Name(),
+			Size:    entry.Size(),
+			Mode:    entry.Mode(),
+			ModTime: entry.ModTime(),
+			IsDir:   entry.IsDir(),
+		})
+	}
+
+	return files, nil
+}
+
+// Upload uploads a local file to a remote path
+func (m *Manager) Upload(localPath, remotePath string, opts *TransferOptions) error {
+	if m.client == nil {
+		return ErrSFTPClientNotInitialized
+	}
+
+	if opts == nil {
+		opts = &TransferOptions{Overwrite: true}
+	}
+
+	// Open local file
+	localFile, err := os.Open(localPath)
+	if err != nil {
+		return fmt.Errorf("failed to open local file: %w", err)
+	}
+	defer localFile.Close()
+
+	// Get file info for size and permissions
+	localInfo, err := localFile.Stat()
+	if err != nil {
+		return fmt.Errorf("failed to stat local file: %w", err)
+	}
+
+	// Check if remote file exists
+	if !opts.Overwrite {
+		if _, err := m.client.Stat(remotePath); err == nil {
+			return ErrFileAlreadyExists
+		}
+	}
+
+	// Create remote file
+	remoteFile, err := m.client.Create(remotePath)
+	if err != nil {
+		return fmt.Errorf("failed to create remote file: %w", err)
+	}
+	defer remoteFile.Close()
+
+	// Copy file with progress tracking
+	totalBytes := localInfo.Size()
+	var bytesTransferred int64
+
+	// Use 128KB buffer for better throughput on large files
+	buf := make([]byte, 128*1024)
+	for {
+		n, err := localFile.Read(buf)
+		if err != nil && err != io.EOF {
+			return fmt.Errorf("%w: %v", ErrTransferFailed, err)
+		}
+
+		if n > 0 {
+			if _, err := remoteFile.Write(buf[:n]); err != nil {
+				return fmt.Errorf("%w: %v", ErrTransferFailed, err)
+			}
+
+			bytesTransferred += int64(n)
+
+			// Report progress
+			if opts.OnProgress != nil {
+				opts.OnProgress(bytesTransferred, totalBytes)
+			}
+		}
+
+		if err == io.EOF {
+			break
+		}
+	}
+
+	// Preserve permissions if requested
+	if opts.PreservePermissions {
+		if err := m.client.Chmod(remotePath, localInfo.Mode()); err != nil {
+			// Don't fail the transfer if chmod fails, just log
+			fmt.Fprintf(os.Stderr, "Warning: failed to set permissions on %s: %v\n", remotePath, err)
+		}
+	}
+
+	return nil
+}
+
+// Download downloads a remote file to a local path
+func (m *Manager) Download(remotePath, localPath string, opts *TransferOptions) error {
+	if m.client == nil {
+		return ErrSFTPClientNotInitialized
+	}
+
+	if opts == nil {
+		opts = &TransferOptions{Overwrite: true}
+	}
+
+	// Open remote file
+	remoteFile, err := m.client.Open(remotePath)
+	if err != nil {
+		return fmt.Errorf("failed to open remote file: %w", err)
+	}
+	defer remoteFile.Close()
+
+	// Get file info for size
+	remoteInfo, err := remoteFile.Stat()
+	if err != nil {
+		return fmt.Errorf("failed to stat remote file: %w", err)
+	}
+
+	if remoteInfo.IsDir() {
+		return ErrIsDirectory
+	}
+
+	// Check if local file exists
+	if !opts.Overwrite {
+		if _, err := os.Stat(localPath); err == nil {
+			return ErrFileAlreadyExists
+		}
+	}
+
+	// Create local file
+	localFile, err := os.Create(localPath)
+	if err != nil {
+		return fmt.Errorf("failed to create local file: %w", err)
+	}
+	defer localFile.Close()
+
+	// Copy file with progress tracking
+	totalBytes := remoteInfo.Size()
+	var bytesTransferred int64
+
+	// Use 128KB buffer for better throughput on large files
+	buf := make([]byte, 128*1024)
+	for {
+		n, err := remoteFile.Read(buf)
+		if err != nil && err != io.EOF {
+			return fmt.Errorf("%w: %v", ErrTransferFailed, err)
+		}
+
+		if n > 0 {
+			if _, err := localFile.Write(buf[:n]); err != nil {
+				return fmt.Errorf("%w: %v", ErrTransferFailed, err)
+			}
+
+			bytesTransferred += int64(n)
+
+			// Report progress
+			if opts.OnProgress != nil {
+				opts.OnProgress(bytesTransferred, totalBytes)
+			}
+		}
+
+		if err == io.EOF {
+			break
+		}
+	}
+
+	// Preserve permissions if requested
+	if opts.PreservePermissions {
+		if err := os.Chmod(localPath, remoteInfo.Mode()); err != nil {
+			// Don't fail the transfer if chmod fails, just log
+			fmt.Fprintf(os.Stderr, "Warning: failed to set permissions on %s: %v\n", localPath, err)
+		}
+	}
+
+	return nil
+}
+
+// Delete deletes a file or directory
+func (m *Manager) Delete(path string) error {
+	if m.client == nil {
+		return ErrSFTPClientNotInitialized
+	}
+
+	// Check if path is a directory
+	info, err := m.client.Stat(path)
+	if err != nil {
+		return fmt.Errorf("failed to stat path: %w", err)
+	}
+
+	if info.IsDir() {
+		// Remove directory (must be empty)
+		if err := m.client.RemoveDirectory(path); err != nil {
+			return fmt.Errorf("failed to remove directory: %w", err)
+		}
+	} else {
+		// Remove file
+		if err := m.client.Remove(path); err != nil {
+			return fmt.Errorf("failed to remove file: %w", err)
+		}
+	}
+
+	return nil
+}
+
+// Rename renames or moves a file/directory
+func (m *Manager) Rename(oldPath, newPath string) error {
+	if m.client == nil {
+		return ErrSFTPClientNotInitialized
+	}
+
+	if err := m.client.Rename(oldPath, newPath); err != nil {
+		return fmt.Errorf("failed to rename: %w", err)
+	}
+
+	return nil
+}
+
+// MkdirAll creates a directory and all necessary parent directories
+func (m *Manager) MkdirAll(path string) error {
+	if m.client == nil {
+		return ErrSFTPClientNotInitialized
+	}
+
+	if err := m.client.MkdirAll(path); err != nil {
+		return fmt.Errorf("failed to create directory: %w", err)
+	}
+
+	return nil
+}
+
+// Stat returns file/directory information
+func (m *Manager) Stat(path string) (*FileInfo, error) {
+	if m.client == nil {
+		return nil, ErrSFTPClientNotInitialized
+	}
+
+	info, err := m.client.Stat(path)
+	if err != nil {
+		return nil, fmt.Errorf("failed to stat path: %w", err)
+	}
+
+	return &FileInfo{
+		Name:    filepath.Base(path),
+		Size:    info.Size(),
+		Mode:    info.Mode(),
+		ModTime: info.ModTime(),
+		IsDir:   info.IsDir(),
+	}, nil
+}
+
+// Close closes the SFTP client
+func (m *Manager) Close() error {
+	if m.client != nil {
+		return m.client.Close()
+	}
+	return nil
+}

package/core/internal/sftp/types.go

@@ -0,0 +1,30 @@
+package sftp
+
+import (
+	"os"
+	"time"
+)
+
+// FileInfo represents information about a file or directory
+type FileInfo struct {
+	Name    string      `json:"name"`
+	Size    int64       `json:"size"`
+	Mode    os.FileMode `json:"mode"`
+	ModTime time.Time   `json:"modTime"`
+	IsDir   bool        `json:"isDir"`
+}
+
+// ProgressCallback is called during file transfers to report progress
+type ProgressCallback func(bytesTransferred, totalBytes int64)
+
+// TransferOptions contains options for file transfers
+type TransferOptions struct {
+	// Progress callback (optional)
+	OnProgress ProgressCallback
+
+	// Overwrite existing files
+	Overwrite bool
+
+	// Preserve file permissions
+	PreservePermissions bool
+}

package/core/internal/ssh/errors.go

@@ -0,0 +1,23 @@
+package ssh
+
+import "errors"
+
+var (
+	// ErrNotConnected is returned when attempting operations on a disconnected client
+	ErrNotConnected = errors.New("SSH client not connected")
+
+	// ErrAlreadyConnected is returned when attempting to connect an already connected client
+	ErrAlreadyConnected = errors.New("SSH client already connected")
+
+	// ErrSessionFailed is returned when SSH session creation fails
+	ErrSessionFailed = errors.New("failed to create SSH session")
+
+	// ErrCommandFailed is returned when command execution fails
+	ErrCommandFailed = errors.New("command execution failed")
+
+	// ErrPTYFailed is returned when PTY allocation fails
+	ErrPTYFailed = errors.New("failed to allocate PTY")
+
+	// ErrSessionClosed is returned when operating on a closed session
+	ErrSessionClosed = errors.New("session is closed")
+)

package/core/internal/ssh/manager.go

@@ -0,0 +1,226 @@
+package ssh
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"sync"
+
+	"github.com/adishm/heyvm/internal/auth"
+	"github.com/adishm/heyvm/internal/vm"
+	"golang.org/x/crypto/ssh"
+)
+
+// Manager manages SSH connections and sessions
+type Manager struct {
+	vm       *vm.VM
+	auth     auth.Provider
+	client   *ssh.Client
+	sessions map[string]*Session
+	mu       sync.RWMutex
+}
+
+// NewManager creates a new SSH manager
+func NewManager(v *vm.VM, authProvider auth.Provider) *Manager {
+	return &Manager{
+		vm:       v,
+		auth:     authProvider,
+		sessions: make(map[string]*Session),
+	}
+}
+
+// Connect establishes an SSH connection
+// This method is idempotent - if already connected, it returns nil
+func (m *Manager) Connect() error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	// Idempotent: if already connected, just return success
+	if m.client != nil {
+		return nil
+	}
+
+	client, err := m.auth.Connect(m.vm)
+	if err != nil {
+		return fmt.Errorf("connection failed: %w", err)
+	}
+
+	m.client = client
+	return nil
+}
+
+// Disconnect closes the SSH connection and all sessions
+func (m *Manager) Disconnect() error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	// Close all sessions
+	for _, session := range m.sessions {
+		session.Close()
+	}
+	m.sessions = make(map[string]*Session)
+
+	// Close client
+	if m.client != nil {
+		if err := m.client.Close(); err != nil {
+			return fmt.Errorf("failed to close SSH client: %w", err)
+		}
+		m.client = nil
+	}
+
+	return nil
+}
+
+// IsConnected returns true if the SSH client is connected
+func (m *Manager) IsConnected() bool {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	return m.client != nil
+}
+
+// ExecuteCommand executes a single command and returns the output
+func (m *Manager) ExecuteCommand(cmd string) (string, error) {
+	m.mu.RLock()
+	client := m.client
+	m.mu.RUnlock()
+
+	if client == nil {
+		return "", ErrNotConnected
+	}
+
+	// Create a new session for this command
+	session, err := client.NewSession()
+	if err != nil {
+		return "", fmt.Errorf("%w: %v", ErrSessionFailed, err)
+	}
+	defer session.Close()
+
+	// Capture output
+	var stdout, stderr bytes.Buffer
+	session.Stdout = &stdout
+	session.Stderr = &stderr
+
+	// Execute command
+	if err := session.Run(cmd); err != nil {
+		// Include stderr in error if command failed
+		if stderr.Len() > 0 {
+			return "", fmt.Errorf("%w: %v (stderr: %s)", ErrCommandFailed, err, stderr.String())
+		}
+		return "", fmt.Errorf("%w: %v", ErrCommandFailed, err)
+	}
+
+	return stdout.String(), nil
+}
+
+// StartPTY starts an interactive PTY session
+func (m *Manager) StartPTY(rows, cols int) (*Session, error) {
+	m.mu.RLock()
+	client := m.client
+	m.mu.RUnlock()
+
+	if client == nil {
+		return nil, ErrNotConnected
+	}
+
+	// Create SSH session
+	sshSession, err := client.NewSession()
+	if err != nil {
+		return nil, fmt.Errorf("%w: %v", ErrSessionFailed, err)
+	}
+
+	// Request PTY
+	modes := ssh.TerminalModes{
+		ssh.ECHO:          1,     // Enable echoing
+		ssh.TTY_OP_ISPEED: 14400, // Input speed = 14.4kbaud
+		ssh.TTY_OP_OSPEED: 14400, // Output speed = 14.4kbaud
+	}
+
+	if err := sshSession.RequestPty("xterm-256color", rows, cols, modes); err != nil {
+		sshSession.Close()
+		return nil, fmt.Errorf("%w: %v", ErrPTYFailed, err)
+	}
+
+	// Get pipes for stdin/stdout/stderr
+	stdin, err := sshSession.StdinPipe()
+	if err != nil {
+		sshSession.Close()
+		return nil, fmt.Errorf("failed to get stdin pipe: %w", err)
+	}
+
+	stdout, err := sshSession.StdoutPipe()
+	if err != nil {
+		sshSession.Close()
+		return nil, fmt.Errorf("failed to get stdout pipe: %w", err)
+	}
+
+	stderr, err := sshSession.StderrPipe()
+	if err != nil {
+		sshSession.Close()
+		return nil, fmt.Errorf("failed to get stderr pipe: %w", err)
+	}
+
+	// Start shell
+	if err := sshSession.Shell(); err != nil {
+		sshSession.Close()
+		return nil, fmt.Errorf("failed to start shell: %w", err)
+	}
+
+	// Merge stdout and stderr into single stream
+	// This prevents SSH deadlocks and ensures all output is captured
+	combinedOutput := io.MultiReader(stdout, stderr)
+
+	// Create session wrapper
+	session := &Session{
+		session:        sshSession,
+		stdin:          stdin,
+		combinedOutput: combinedOutput,
+		rows:           rows,
+		cols:           cols,
+	}
+
+	// Store session
+	m.mu.Lock()
+	m.sessions[session.ID()] = session
+	m.mu.Unlock()
+
+	return session, nil
+}
+
+// GetSession retrieves a session by ID
+func (m *Manager) GetSession(id string) (*Session, error) {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+
+	session, exists := m.sessions[id]
+	if !exists {
+		return nil, fmt.Errorf("session not found: %s", id)
+	}
+
+	return session, nil
+}
+
+// CloseSession closes a specific session
+func (m *Manager) CloseSession(id string) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	session, exists := m.sessions[id]
+	if !exists {
+		return fmt.Errorf("session not found: %s", id)
+	}
+
+	if err := session.Close(); err != nil {
+		return fmt.Errorf("failed to close session: %w", err)
+	}
+
+	delete(m.sessions, id)
+	return nil
+}
+
+// GetClient returns the underlying SSH client
+// This is useful for creating SFTP clients
+func (m *Manager) GetClient() *ssh.Client {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	return m.client
+}

package/core/internal/ssh/session.go

@@ -0,0 +1,105 @@
+package ssh
+
+import (
+	"crypto/rand"
+	"encoding/hex"
+	"fmt"
+	"io"
+	"sync"
+
+	cryptossh "golang.org/x/crypto/ssh"
+)
+
+// Session represents an interactive PTY session
+type Session struct {
+	id             string
+	session        *cryptossh.Session
+	stdin          io.WriteCloser
+	combinedOutput io.Reader // stdout + stderr merged
+	rows           int
+	cols           int
+	closed         bool
+	mu             sync.Mutex
+}
+
+// ID returns the session ID
+func (s *Session) ID() string {
+	if s.id == "" {
+		s.id = generateSessionID()
+	}
+	return s.id
+}
+
+// Write sends data to the session's stdin
+func (s *Session) Write(data []byte) (int, error) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	if s.closed {
+		return 0, ErrSessionClosed
+	}
+
+	return s.stdin.Write(data)
+}
+
+// CombinedOutput returns the merged stdout+stderr reader - for SINGLE goroutine use only
+func (s *Session) CombinedOutput() io.Reader {
+	return s.combinedOutput
+}
+
+// Resize changes the terminal size
+func (s *Session) Resize(rows, cols int) error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	if s.closed {
+		return ErrSessionClosed
+	}
+
+	if err := s.session.WindowChange(rows, cols); err != nil {
+		return fmt.Errorf("failed to resize window: %w", err)
+	}
+
+	s.rows = rows
+	s.cols = cols
+	return nil
+}
+
+// Close closes the session
+func (s *Session) Close() error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	if s.closed {
+		return nil
+	}
+
+	s.closed = true
+
+	if s.session != nil {
+		return s.session.Close()
+	}
+
+	return nil
+}
+
+// IsClosed returns true if the session is closed
+func (s *Session) IsClosed() bool {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	return s.closed
+}
+
+// GetSize returns the current terminal size
+func (s *Session) GetSize() (rows, cols int) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	return s.rows, s.cols
+}
+
+// generateSessionID generates a unique session ID
+func generateSessionID() string {
+	b := make([]byte, 8)
+	rand.Read(b)
+	return hex.EncodeToString(b)
+}

package/core/internal/vm/errors.go

@@ -0,0 +1,35 @@
+package vm
+
+import "errors"
+
+var (
+	// ErrVMNotFound is returned when a VM is not found in the registry
+	ErrVMNotFound = errors.New("VM not found")
+
+	// ErrVMAlreadyExists is returned when trying to add a VM with duplicate ID
+	ErrVMAlreadyExists = errors.New("VM already exists")
+
+	// ErrInvalidVMName is returned when VM name is empty
+	ErrInvalidVMName = errors.New("VM name cannot be empty")
+
+	// ErrInvalidVMHost is returned when VM host is empty
+	ErrInvalidVMHost = errors.New("VM host cannot be empty")
+
+	// ErrInvalidVMPort is returned when VM port is invalid
+	ErrInvalidVMPort = errors.New("VM port must be between 1 and 65535")
+
+	// ErrInvalidVMUsername is returned when VM username is empty
+	ErrInvalidVMUsername = errors.New("VM username cannot be empty")
+
+	// ErrInvalidAuthType is returned when auth type is not recognized
+	ErrInvalidAuthType = errors.New("invalid authentication type")
+
+	// ErrMissingKeyPath is returned when SSH key auth is selected but no key path provided
+	ErrMissingKeyPath = errors.New("SSH key path is required for key authentication")
+
+	// ErrConfigNotFound is returned when config file doesn't exist
+	ErrConfigNotFound = errors.New("configuration file not found")
+
+	// ErrConfigCorrupted is returned when config file is malformed
+	ErrConfigCorrupted = errors.New("configuration file is corrupted")
+)