gosftp

type AuthMethod string

type Client struct {
	// contains filtered or unexported fields
}

type ClientInterface interface {
	// Close closes the SSH connection.
	Close() error
	// UploadFile uploads a local file to the remote host.
	UploadFile(ctx context.Context, localPath, remotePath string) error
	// GetFileHash returns the SHA256 hash of a remote file.
	GetFileHash(ctx context.Context, remotePath string) (string, error)
	// SetFileAttributes sets ownership and permissions on a remote file.
	SetFileAttributes(ctx context.Context, remotePath, owner, group, mode string) error
	// DeleteFile removes a file from the remote host.
	DeleteFile(ctx context.Context, remotePath string) error
	// FileExists checks if a file exists on the remote host.
	FileExists(ctx context.Context, remotePath string) (bool, error)
	// GetFileInfo returns information about a remote file.
	GetFileInfo(ctx context.Context, remotePath string) (os.FileInfo, error)
	// ReadFileContent reads the content of a remote file.
	ReadFileContent(ctx context.Context, remotePath string, maxBytes int64) ([]byte, error)
}

type Config struct {
	// Host is the target SSH server hostname or IP address.
	Host string

	// Port is the SSH port (default 22).
	Port int

	// User is the SSH username.
	User string

	// AuthMethod specifies which authentication method to use.
	// If not set, it will be inferred from the provided credentials.
	AuthMethod AuthMethod

	// PrivateKey is the SSH private key content (PEM encoded).
	// Mutually exclusive with KeyPath.
	PrivateKey string

	// KeyPath is the path to the SSH private key file.
	// Mutually exclusive with PrivateKey.
	KeyPath string

	// Password is the SSH password for password authentication.
	Password string

	// Certificate is the SSH certificate content.
	// Used with PrivateKey or KeyPath for certificate authentication.
	Certificate string

	// CertificatePath is the path to the SSH certificate file.
	// Used with PrivateKey or KeyPath for certificate authentication.
	CertificatePath string

	// Timeout is the connection timeout (default 30s).
	Timeout time.Duration

	// KnownHostsFile is the path to a known_hosts file for host key verification.
	// If not set, defaults to ~/.ssh/known_hosts if it exists.
	KnownHostsFile string

	// InsecureIgnoreHostKey skips host key verification.
	// WARNING: This is insecure and should only be used for testing.
	// Deprecated: Use StrictHostKeyChecking = "no" instead.
	InsecureIgnoreHostKey bool

	// StrictHostKeyChecking controls host key verification behavior.
	// Valid values: "yes" (default), "no", "accept-new".
	// Takes precedence over InsecureIgnoreHostKey if set.
	StrictHostKeyChecking StrictHostKeyChecking

	// BastionHost is the hostname or IP of a bastion/jump host.
	BastionHost string

	// BastionPort is the SSH port of the bastion host (default 22).
	BastionPort int

	// BastionUser is the SSH username for the bastion host.
	// Falls back to User if not set.
	BastionUser string

	// BastionKey is the private key content for the bastion host.
	// Falls back to PrivateKey if not set.
	BastionKey string

	// BastionKeyPath is the path to the private key for the bastion host.
	// Falls back to KeyPath if not set.
	BastionKeyPath string

	// BastionPassword is the password for the bastion host.
	BastionPassword string

	// AgentForwarding enables SSH agent forwarding.
	AgentForwarding bool

	// ProxyURL is the URL of a SOCKS5 proxy to dial through (e.g. "socks5://127.0.0.1:1080").
	// When set, all SSH connections (direct and bastion) are established through the proxy.
	// If empty, connections are made directly.
	ProxyURL string

	// Logger is the logger to use for debug and info messages.
	// If not set, a no-op logger is used (all messages discarded).
	Logger Logger
}

type ConnectionPool struct {
	// contains filtered or unexported fields
}

type DirectorySyncResult struct {
	// Files contains the result for each file.
	Files []SyncResult

	// TotalSize is the total size of all synced files.
	TotalSize int64

	// CombinedHash is a combined hash of all file hashes.
	CombinedHash string

	// Uploaded is the number of files uploaded.
	Uploaded int

	// Skipped is the number of files skipped (unchanged).
	Skipped int

	// Deleted is the number of files deleted.
	Deleted int

	// Errors is the number of files that failed.
	Errors int
}

type FileAttributes struct {
	// Owner is the file owner (username or UID).
	Owner string

	// Group is the file group (group name or GID).
	Group string

	// Mode is the file permissions in octal (e.g., "0644").
	Mode string
}

type FileInfo struct {
	RelPath       string
	Hash          string
	Size          int64
	IsSymlink     bool
	SymlinkTarget string
}

type Logger interface {
	// Debugf logs a debug message.
	Debugf(format string, args ...interface{})
	// Infof logs an info message.
	Infof(format string, args ...interface{})
	// Warnf logs a warning message.
	Warnf(format string, args ...interface{})
	// Errorf logs an error message.
	Errorf(format string, args ...interface{})
}

type NoOpLogger struct{}

type PoolStats struct {
	Total int
	InUse int
	Idle  int
}

type RetryConfig struct {
	// MaxRetries is the maximum number of retry attempts (0 = no retries).
	MaxRetries int

	// InitialDelay is the initial delay between retries.
	InitialDelay time.Duration

	// MaxDelay is the maximum delay between retries.
	MaxDelay time.Duration

	// Multiplier is the backoff multiplier (e.g., 2.0 = double delay each retry).
	Multiplier float64

	// JitterFactor adds randomness to delay (0.0 = no jitter, 0.5 = ±50% jitter).
	JitterFactor float64

	// Logger is the logger to use for retry messages.
	// If not set, a no-op logger is used (all messages discarded).
	Logger Logger
}

type RetryableFunc func() error

type SFTPClientInterface interface {
	Open(path string) (SFTPFile, error)
	Create(path string) (SFTPFile, error)
	Remove(path string) error
	Stat(path string) (os.FileInfo, error)
	Chmod(path string, mode os.FileMode) error
	MkdirAll(path string) error
	Close() error
}

type SFTPClientWrapper struct {
	// contains filtered or unexported fields
}

type SFTPFile interface {
	io.Reader
	io.Writer
	io.Closer
}

type StrictHostKeyChecking string

type SyncOptions struct {
	// Attributes specifies file ownership and permissions to set.
	Attributes *FileAttributes

	// ExcludePatterns is a list of glob patterns to exclude from sync.
	// Example: []string{"*.tmp", ".git", "node_modules"}
	ExcludePatterns []string

	// SymlinkPolicy specifies how to handle symlinks: "follow", "skip", or "preserve".
	// Default is "follow".
	SymlinkPolicy string

	// Parallelism is the number of concurrent uploads for directory sync.
	// Default is 4.
	Parallelism int

	// DryRun only reports what would be synced without making changes.
	DryRun bool
}

type SyncResult struct {
	// LocalPath is the source file path.
	LocalPath string

	// RemotePath is the destination file path.
	RemotePath string

	// Hash is the SHA256 hash of the file content.
	Hash string

	// Size is the file size in bytes.
	Size int64

	// Changed indicates if the file was uploaded (true) or unchanged (false).
	Changed bool

	// Deleted indicates if the file was deleted from the remote.
	Deleted bool

	// Error contains any error that occurred during sync.
	Error error
}

type Syncer struct {
	// contains filtered or unexported fields
}

type SyncerOption func(*Syncer)