heyvm 1.0.0

package/core/internal/ipc/handler.go

@@ -0,0 +1,281 @@
+package ipc
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"os"
+	"sync"
+
+	"github.com/adishm/heyvm/internal/auth"
+	"github.com/adishm/heyvm/internal/sftp"
+	"github.com/adishm/heyvm/internal/ssh"
+	"github.com/adishm/heyvm/internal/vm"
+)
+
+// Handler manages IPC communication and VM operations
+type Handler struct {
+	registry     *vm.Registry
+	sshManagers  map[string]*ssh.Manager  // vmID -> SSH manager
+	sftpManagers map[string]*sftp.Manager // vmID -> SFTP manager
+	authProviders map[string]auth.Provider // vmID -> auth provider
+	mu           sync.RWMutex
+	input        io.Reader
+	output       io.Writer
+	outputMu     sync.Mutex // Protect output writes
+}
+
+// NewHandler creates a new IPC handler
+func NewHandler(registry *vm.Registry) *Handler {
+	return &Handler{
+		registry:      registry,
+		sshManagers:   make(map[string]*ssh.Manager),
+		sftpManagers:  make(map[string]*sftp.Manager),
+		authProviders: make(map[string]auth.Provider),
+		input:         os.Stdin,
+		output:        os.Stdout,
+	}
+}
+
+// Emit sends an event to the UI (non-blocking, fire-and-forget)
+func (h *Handler) Emit(event string, data interface{}) {
+	h.outputMu.Lock()
+	defer h.outputMu.Unlock()
+
+	encoder := json.NewEncoder(h.output)
+	response := NewEvent(event, data)
+	
+	if err := encoder.Encode(response); err != nil {
+		log.Printf("IPC handler: error emitting event %s: %v", event, err)
+	}
+}
+
+// Start begins the IPC request/response loop
+func (h *Handler) Start() error {
+	decoder := json.NewDecoder(h.input)
+	encoder := json.NewEncoder(h.output)
+
+	log.Println("IPC handler started, listening for requests...")
+
+	for {
+		var req Request
+		if err := decoder.Decode(&req); err != nil {
+			if err == io.EOF {
+				log.Println("IPC handler: received EOF, shutting down")
+				break
+			}
+			log.Printf("IPC handler: error decoding request: %v", err)
+			continue
+		}
+
+		log.Printf("IPC handler: received request: %s", req.Action)
+
+		// Handle request
+		resp := h.HandleRequest(req)
+
+		// Skip sending response for fire-and-forget actions (empty response)
+		if resp.Status == "" {
+			log.Printf("IPC handler: fire-and-forget action, no response sent")
+			continue
+		}
+
+		// Send response
+		h.outputMu.Lock()
+		if err := encoder.Encode(resp); err != nil {
+			log.Printf("IPC handler: error encoding response: %v", err)
+			h.outputMu.Unlock()
+			continue
+		}
+		h.outputMu.Unlock()
+
+		log.Printf("IPC handler: sent response: status=%s", resp.Status)
+	}
+
+	// Cleanup on shutdown
+	h.cleanup()
+	return nil
+}
+
+// HandleRequest routes a request to the appropriate action handler
+func (h *Handler) HandleRequest(req Request) Response {
+	var resp Response
+	
+	switch req.Action {
+	case ActionListVMs:
+		resp = h.handleListVMs(req.Params)
+	case ActionAddVM:
+		resp = h.handleAddVM(req.Params)
+	case ActionRemoveVM:
+		resp = h.handleRemoveVM(req.Params)
+	case ActionConnectVM:
+		resp = h.handleConnectVM(req.Params)
+	case ActionDisconnectVM:
+		resp = h.handleDisconnectVM(req.Params)
+	case ActionExecuteCommand:
+		resp = h.handleExecuteCommand(req.Params)
+	case ActionListFiles:
+		resp = h.handleListFiles(req.Params)
+	case ActionUploadFile:
+		resp = h.handleUploadFile(req.Params)
+	case ActionDownloadFile:
+		resp = h.handleDownloadFile(req.Params)
+	case ActionDeleteFile:
+		resp = h.handleDeleteFile(req.Params)
+	case ActionRenameFile:
+		resp = h.handleRenameFile(req.Params)
+	case ActionStorePassword:
+		resp = h.handleStorePassword(req.Params)
+	case ActionTestConnection:
+		resp = h.handleTestConnection(req.Params)
+	case ActionStartPTY:
+		// Fire-and-forget: handle but don't send response
+		go h.handleStartPTY(req.Params)
+		return Response{} // Return empty response (won't be sent)
+	case ActionWriteToPTY:
+		// Fire-and-forget: handle but don't send response
+		go h.handleWriteToPTY(req.Params)
+		return Response{} // Return empty response (won't be sent)
+	case ActionResizePTY:
+		// Fire-and-forget: handle but don't send response
+		go h.handleResizePTY(req.Params)
+		return Response{} // Return empty response (won't be sent)
+	case ActionClosePTY:
+		// Fire-and-forget: handle but don't send response
+		go h.handleClosePTY(req.Params)
+		return Response{} // Return empty response (won't be sent)
+	default:
+		resp = NewErrorResponseWithMessage(fmt.Sprintf("unknown action: %s", req.Action))
+	}
+	
+	// Add request ID to response for proper matching
+	resp.RequestID = req.RequestID
+	return resp
+}
+
+// cleanup closes all active connections
+func (h *Handler) cleanup() {
+	log.Println("IPC handler: cleaning up connections...")
+
+	h.mu.Lock()
+	defer h.mu.Unlock()
+
+	// Close all SFTP managers
+	for vmID, sftpMgr := range h.sftpManagers {
+		if err := sftpMgr.Close(); err != nil {
+			log.Printf("Error closing SFTP manager for VM %s: %v", vmID, err)
+		}
+	}
+
+	// Close all SSH managers
+	for vmID, sshMgr := range h.sshManagers {
+		if err := sshMgr.Disconnect(); err != nil {
+			log.Printf("Error disconnecting SSH manager for VM %s: %v", vmID, err)
+		}
+	}
+
+	// Disconnect all auth providers
+	for vmID, provider := range h.authProviders {
+		if err := provider.Disconnect(); err != nil {
+			log.Printf("Error disconnecting auth provider for VM %s: %v", vmID, err)
+		}
+	}
+
+	log.Println("IPC handler: cleanup complete")
+}
+
+// getSSHManager gets or creates an SSH manager for a VM
+func (h *Handler) getSSHManager(vmID string) (*ssh.Manager, error) {
+	h.mu.RLock()
+	manager, exists := h.sshManagers[vmID]
+	h.mu.RUnlock()
+
+	if exists && manager.IsConnected() {
+		return manager, nil
+	}
+
+	// Get VM from registry
+	v, err := h.registry.Get(vmID)
+	if err != nil {
+		return nil, fmt.Errorf("VM not found: %w", err)
+	}
+
+	// Get or create auth provider
+	provider, err := h.getAuthProvider(vmID, v)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get auth provider: %w", err)
+	}
+
+	// Create SSH manager
+	manager = ssh.NewManager(v, provider)
+
+	h.mu.Lock()
+	h.sshManagers[vmID] = manager
+	h.mu.Unlock()
+
+	return manager, nil
+}
+
+// getSFTPManager gets or creates an SFTP manager for a VM
+func (h *Handler) getSFTPManager(vmID string) (*sftp.Manager, error) {
+	h.mu.RLock()
+	manager, exists := h.sftpManagers[vmID]
+	h.mu.RUnlock()
+
+	if exists {
+		return manager, nil
+	}
+
+	// Get SSH manager first
+	sshMgr, err := h.getSSHManager(vmID)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get SSH manager: %w", err)
+	}
+
+	// Ensure connected
+	if !sshMgr.IsConnected() {
+		if err := sshMgr.Connect(); err != nil {
+			return nil, fmt.Errorf("failed to connect SSH: %w", err)
+		}
+	}
+
+	// Create SFTP manager
+	client := sshMgr.GetClient()
+	if client == nil {
+		return nil, fmt.Errorf("SSH client is nil")
+	}
+
+	manager, err = sftp.NewManager(client)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create SFTP manager: %w", err)
+	}
+
+	h.mu.Lock()
+	h.sftpManagers[vmID] = manager
+	h.mu.Unlock()
+
+	return manager, nil
+}
+
+// getAuthProvider gets or creates an auth provider for a VM
+func (h *Handler) getAuthProvider(vmID string, v *vm.VM) (auth.Provider, error) {
+	h.mu.RLock()
+	provider, exists := h.authProviders[vmID]
+	h.mu.RUnlock()
+
+	if exists {
+		return provider, nil
+	}
+
+	// Create new provider
+	provider, err := auth.NewProvider(v)
+	if err != nil {
+		return nil, err
+	}
+
+	h.mu.Lock()
+	h.authProviders[vmID] = provider
+	h.mu.Unlock()
+
+	return provider, nil
+}

package/core/internal/ipc/protocol.go

@@ -0,0 +1,126 @@
+package ipc
+
+// Request represents an IPC request from the UI
+type Request struct {
+	RequestID int                    `json:"request_id"`
+	Action    string                 `json:"action"`
+	Params    map[string]interface{} `json:"params,omitempty"`
+}
+
+// Response represents an IPC response to the UI
+type Response struct {
+	RequestID int         `json:"request_id"`
+	Status    string      `json:"status"`  // "success" | "error"
+	Message   string      `json:"message,omitempty"`
+	Data      interface{} `json:"data,omitempty"`
+	Event     string      `json:"event,omitempty"` // For event-based messages
+}
+
+// NewSuccessResponse creates a success response
+func NewSuccessResponse(data interface{}) Response {
+	return Response{
+		Status: "success",
+		Data:   data,
+	}
+}
+
+// NewSuccessResponseWithID creates a success response with request ID
+func NewSuccessResponseWithID(requestID int, data interface{}) Response {
+	return Response{
+		RequestID: requestID,
+		Status:    "success",
+		Data:      data,
+	}
+}
+
+// NewSuccessResponseWithMessage creates a success response with a message
+func NewSuccessResponseWithMessage(message string, data interface{}) Response {
+	return Response{
+		Status:  "success",
+		Message: message,
+		Data:    data,
+	}
+}
+
+// NewSuccessResponseWithMessageAndID creates a success response with message and request ID
+func NewSuccessResponseWithMessageAndID(requestID int, message string, data interface{}) Response {
+	return Response{
+		RequestID: requestID,
+		Status:    "success",
+		Message:   message,
+		Data:      data,
+	}
+}
+
+// NewErrorResponse creates an error response
+func NewErrorResponse(err error) Response {
+	return Response{
+		Status:  "error",
+		Message: err.Error(),
+	}
+}
+
+// NewErrorResponseWithID creates an error response with request ID
+func NewErrorResponseWithID(requestID int, err error) Response {
+	return Response{
+		RequestID: requestID,
+		Status:    "error",
+		Message:   err.Error(),
+	}
+}
+
+// NewErrorResponseWithMessage creates an error response with a custom message
+func NewErrorResponseWithMessage(message string) Response {
+	return Response{
+		Status:  "error",
+		Message: message,
+	}
+}
+
+// NewErrorResponseWithMessageAndID creates an error response with custom message and request ID
+func NewErrorResponseWithMessageAndID(requestID int, message string) Response {
+	return Response{
+		RequestID: requestID,
+		Status:    "error",
+		Message:   message,
+	}
+}
+
+// Action constants
+const (
+	ActionListVMs         = "list_vms"
+	ActionAddVM           = "add_vm"
+	ActionRemoveVM        = "remove_vm"
+	ActionConnectVM       = "connect_vm"
+	ActionDisconnectVM    = "disconnect_vm"
+	ActionExecuteCommand  = "execute_command"
+	ActionListFiles       = "list_files"
+	ActionUploadFile      = "upload_file"
+	ActionDownloadFile    = "download_file"
+	ActionDeleteFile      = "delete_file"
+	ActionRenameFile      = "rename_file"
+	ActionStorePassword   = "store_password"
+	ActionTestConnection  = "test_connection"
+	ActionStartPTY        = "start_pty"
+	ActionWriteToPTY      = "write_to_pty"
+	ActionResizePTY       = "resize_pty"
+	ActionClosePTY        = "close_pty"
+)
+
+// Event constants
+const (
+	EventPTYReady         = "PTY_READY"
+	EventPTYOutput        = "PTY_OUTPUT"
+	EventPTYExit          = "PTY_EXIT"
+	EventPTYError         = "PTY_ERROR"
+	EventTransferProgress = "TRANSFER_PROGRESS"
+)
+
+// NewEvent creates an event response (no request ID needed)
+func NewEvent(event string, data interface{}) Response {
+	return Response{
+		Status: "success",
+		Event:  event,
+		Data:   data,
+	}
+}

package/core/internal/sftp/errors.go

@@ -0,0 +1,29 @@
+package sftp
+
+import "errors"
+
+var (
+	// ErrSFTPClientNotInitialized is returned when SFTP client is not initialized
+	ErrSFTPClientNotInitialized = errors.New("SFTP client not initialized")
+
+	// ErrFileNotFound is returned when a file doesn't exist
+	ErrFileNotFound = errors.New("file not found")
+
+	// ErrPermissionDenied is returned when permission is denied
+	ErrPermissionDenied = errors.New("permission denied")
+
+	// ErrFileAlreadyExists is returned when trying to create a file that already exists
+	ErrFileAlreadyExists = errors.New("file already exists")
+
+	// ErrInvalidPath is returned when a path is invalid
+	ErrInvalidPath = errors.New("invalid path")
+
+	// ErrIsDirectory is returned when expecting a file but got a directory
+	ErrIsDirectory = errors.New("path is a directory")
+
+	// ErrNotDirectory is returned when expecting a directory but got a file
+	ErrNotDirectory = errors.New("path is not a directory")
+
+	// ErrTransferFailed is returned when file transfer fails
+	ErrTransferFailed = errors.New("file transfer failed")
+)