common

type APISession interface {
	MultipartRequest(url string, body io.Reader, contentType string, contentLength int64, timeout time.Duration) ([]byte, int, error)
	Delete(url string, rawBody interface{}, timeout time.Duration) ([]byte, int, error)
}

type BaseHandler struct {
	Executor CommandExecutor // Made public
	// contains filtered or unexported fields
}

type CommandArgs struct {
	// Common fields
	SessionID string
	// CommandID is the UUID of the deploy shell Command that originated
	// this execution (propagated from protocol.Command.ID). Empty for
	// non-Command-driven work such as internal collectors.
	CommandID string
	URL       string
	Command   string
	Timeout   time.Duration
	AllowSh   bool

	// User management
	Username                string
	Groupname               string
	Groupnames              []string
	HomeDirectory           string
	HomeDirectoryPermission string
	PurgeHomeDirectory      bool
	UID                     uint64
	GID                     uint64
	Comment                 string
	Shell                   string
	Groups                  []uint64
	IsServiceAccount        bool

	// File operations
	Type           string
	Content        string
	Path           string
	Paths          []string
	Files          []File
	AllowOverwrite bool
	AllowUnzip     bool
	UseBlob        bool

	// Terminal operations
	Rows  uint16
	Cols  uint16
	Input string

	// Tunnel operations
	TargetPort int
	ClientType string // cli, web, editor

	// Environment
	Env map[string]string

	// ChunkCallback, if non-nil, receives streamed stdout/stderr chunks.
	// Sequencing is the caller's responsibility.
	ChunkCallback func(content string)

	// Firewall operations
	Keys         []string
	ChainName    string
	Method       string
	Chain        string
	Protocol     string
	PortStart    int
	PortEnd      int
	DPorts       []int
	ICMPType     string
	Source       string
	Destination  string
	Target       string
	Description  string
	Priority     int
	RuleType     string
	Rules        []FirewallRule
	Operation    string
	RuleID       string
	OldRuleID    string
	AssignmentID string
	ServerID     string
	ChainNames   []string

	// Backend information
	Backend string // Backend type: iptables, nftables, firewalld, ufw
	Table   string // iptables/nftables table: filter, nat, mangle, raw, security
	Family  string // IP family: ip (IPv4), ip6 (IPv6), inet, arp, bridge, netdev

	// Firewalld specific
	Zone              string // Firewalld zone (default, public, etc.)
	Service           string // Firewalld service name
	FirewalldRuleType string // Firewalld rule type: service, port, rich

	// UFW specific
	Direction string // UFW direction: in, out
	Interface string // UFW interface name
}

type CommandExecutor interface {
	// Run executes a command with the given arguments
	Run(ctx context.Context, name string, args ...string) (int, string, error)

	// RunAsUser executes a command as a specific user
	RunAsUser(ctx context.Context, username string, name string, args ...string) (int, string, error)

	// RunWithInput executes a command with stdin input
	RunWithInput(ctx context.Context, input string, name string, args ...string) (int, string, error)

	// RunWithTimeout executes a command with a timeout
	RunWithTimeout(ctx context.Context, timeout time.Duration, name string, args ...string) (int, string, error)

	// Exec executes a command with all options (user, group, env, timeout)
	Exec(ctx context.Context, args []string, username, groupname string, env map[string]string, timeout time.Duration) (int, string, error)

	// ExecWithHook is like Exec but invokes pidHook with the child's pid
	// immediately after the process is started (before it is waited on).
	// Callers use it to register the root pid with the PAM tracker so
	// sudo calls issued by the child can be attributed to the originating
	// deploy shell Command. pidHook may be nil, in which case this
	// behaves identically to Exec.
	ExecWithHook(ctx context.Context, args []string, username, groupname string, env map[string]string, timeout time.Duration, pidHook func(pid int)) (int, string, error)

	// ExecWithStreamingHook is like ExecWithHook with a chunkCallback that
	// receives streamed stdout/stderr chunks. Sequencing is the caller's
	// responsibility.
	ExecWithStreamingHook(ctx context.Context, args []string, username, groupname string, env map[string]string, timeout time.Duration, pidHook func(pid int), chunkCallback func(content string)) (int, string, error)
}

type CommandResult struct {
	ExitCode int
	Output   string
	Err      error
}

type CommandType string

type ExecutedCommand struct {
	Name    string
	Args    []string
	User    string
	Timeout time.Duration
}

type File struct {
	Username       string `json:"username"`
	Groupname      string `json:"groupname"`
	Type           string `json:"type"`
	Content        string `json:"content"`
	Path           string `json:"path"`
	AllowOverwrite bool   `json:"allow_overwrite"`
	AllowUnzip     bool   `json:"allow_unzip"`
	URL            string `json:"url"`
}

type FirewallRule struct {
	ChainName   string `json:"chain_name"`
	Method      string `json:"method"`
	Chain       string `json:"chain"`
	Protocol    string `json:"protocol"`
	PortStart   int    `json:"port_start"`
	PortEnd     int    `json:"port_end"`
	DPorts      []int  `json:"dports"`
	ICMPType    string `json:"icmp_type"`
	Source      string `json:"source"`
	Destination string `json:"destination"`
	Target      string `json:"target"`
	Description string `json:"description"`
	Priority    int    `json:"priority"`
	RuleType    string `json:"rule_type"`
	RuleID      string `json:"rule_id"`
	OldRuleID   string `json:"old_rule_id"`
	Operation   string `json:"operation"`
}

type GroupLookupFunc func(name string) (*user.Group, error)

type Handler interface {
	// Name returns the handler name (e.g., "system", "user", "firewall")
	Name() string

	// Commands returns the list of commands this handler supports
	Commands() []string

	// Execute runs the specified command with the given arguments.
	// Returns exit code, output string, and error if command fails.
	Execute(ctx context.Context, cmd string, args *CommandArgs) (exitCode int, output string, err error)

	// Validate checks if the provided arguments are valid for the command.
	// This allows pre-execution validation without running the command.
	Validate(cmd string, args *CommandArgs) error
}

type HandlerType string

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

type SystemInfoManager interface {
	CommitSystemInfo()
	SyncSystemInfo(keys []string)
}

type UserLookupFunc func(name string) (*user.User, error)

type VersionResolver interface {
	GetLatestVersion() string
	GetPamVersion() string
	InvalidatePamCache()
}

type WSClient interface {
	Restart()
	ShutDown()
	RestartCollector()
}