cmd

type ContextRunner interface {
	fmt.Stringer
	WindowsChecker
	ExecContext(ctx context.Context, command string, opts ...ExecOption) error
	ExecOutputContext(ctx context.Context, command string, opts ...ExecOption) (string, error)
	ExecReaderContext(ctx context.Context, command string, opts ...ExecOption) io.Reader
	Start(ctx context.Context, command string, opts ...ExecOption) (protocol.Waiter, error)
}

type DecorateFunc func(string) string

type ErrorExecutor struct {
	Err error
}

type ExecOption func(*ExecOptions)

type ExecOptions struct {
	log.LoggerInjectable
	// contains filtered or unexported fields
}

type Executor struct {
	log.LoggerInjectable
	// contains filtered or unexported fields
}

type Explanation struct {
	// Formatted is the command string after all global and per-call
	// decorators, sudo wrapping, and any OS-specific prefixes that can be
	// determined without probing the connection (e.g. "cmd.exe /C"). When
	// OSWrappingKnown is false, OS-specific prefixes are omitted.
	Formatted string
	// Decoded is the human-readable form of Formatted. PowerShell
	// EncodedCommand payloads are decoded so you can read the actual script.
	Decoded string
	// Logged is the command as it appears in debug log lines: Decoded with
	// any strings registered via [Redact] replaced by the redact mask. It is
	// empty when command logging is disabled.
	Logged string
	// CommandLogged reports whether Logged would be emitted by command logging.
	CommandLogged bool
	// OSWrappingKnown reports whether Formatted could include OS-specific
	// command wrapping without probing the connection.
	OSWrappingKnown bool
}

type Formatter interface {
	Format(cmd string) string
}

type OutputTracer interface {
	Tracer
	// StdoutLine fires for each line written to stdout. The line does not
	// include a trailing newline character.
	StdoutLine(host, line string)
	// StderrLine fires for each line written to stderr. The line does not
	// include a trailing newline character.
	StderrLine(host, line string)
}

type Proc struct {
	Stdin  io.Reader
	Stdout io.Writer
	Stderr io.Writer
	// contains filtered or unexported fields
}

type Runner interface {
	Formatter
	WindowsChecker
	SimpleRunner
	ContextRunner
	Proc(cmd string) *Proc
	// Explain returns an [Explanation] describing how the command would be processed,
	// without actually running it. The Explanation includes the fully decorated
	// command string (Formatted), the decoded/human-readable form (Decoded), the
	// redacted version that would appear in logs (Logged), and whether the OS
	// wrapping decision was known (OSWrappingKnown). Use this to inspect the effect of
	// decorators, sudo wrapping, PowerShell encoding, and redaction.
	Explain(cmd string, opts ...ExecOption) Explanation
	// ProcessStarter is included to allow runners to accept another runner as their connection for chaining.
	protocol.ProcessStarter
}

type SimpleRunner interface {
	fmt.Stringer
	WindowsChecker
	Exec(command string, opts ...ExecOption) error
	ExecOutput(command string, opts ...ExecOption) (string, error)
	ExecReader(command string, opts ...ExecOption) io.Reader
	ExecScanner(command string, opts ...ExecOption) *bufio.Scanner
	StartBackground(command string, opts ...ExecOption) (protocol.Waiter, error)
}

type Tracer interface {
	// CommandFormatted fires just before a process is started, with the final
	// command string after all decorators and OS-specific wrapping.
	CommandFormatted(host, formatted string)
	// ProcessStarted fires after the underlying process starts successfully.
	ProcessStarted(host, formatted string)
	// ProcessFinished fires after the process exits.
	// duration is the wall-clock time since ProcessStarted. err is nil on success.
	ProcessFinished(host, formatted string, duration time.Duration, err error)
}

type WindowsChecker interface {
	IsWindows() bool
}