ssh.go

package xshellz

import (
	"context"
	"errors"
	"fmt"
	"io"
	"net"
	"strconv"
	"time"

	"golang.org/x/crypto/ssh"
)

// commandRunner abstracts the data-plane transport (SSH in v0) so the
// Sandbox exec/file logic is unit-testable without a network.
type commandRunner interface {
	// run executes cmd on the box, wiring the given streams, and returns the
	// remote exit code. A non-zero exit code is NOT an error; err is reserved
	// for transport failures and context cancellation.
	run(ctx context.Context, cmd string, stdin io.Reader, stdout, stderr io.Writer) (int, error)
	close() error
}

// dialFunc creates a commandRunner for a box; swapped out in tests.
type dialFunc func(ctx context.Context, host string, port int, signer ssh.Signer) (commandRunner, error)

// sshRunner is the real SSH data plane: one ssh.Client per sandbox, one
// session per command.
type sshRunner struct {
	client *ssh.Client
}

// dialSSH connects to root@host:port using the sandbox's in-memory key.
// Host-key verification is intentionally disabled (InsecureIgnoreHostKey):
// boxes are ephemeral and generate a fresh host key on every spawn, so there
// is no stable key to pin in v0.
func dialSSH(ctx context.Context, host string, port int, signer ssh.Signer) (commandRunner, error) {
	config := &ssh.ClientConfig{
		User:            "root",
		Auth:            []ssh.AuthMethod{ssh.PublicKeys(signer)},
		HostKeyCallback: ssh.InsecureIgnoreHostKey(), //nolint:gosec // ephemeral boxes, fresh host key per spawn
		Timeout:         15 * time.Second,
	}

	addr := net.JoinHostPort(host, strconv.Itoa(port))
	var d net.Dialer
	conn, err := d.DialContext(ctx, "tcp", addr)
	if err != nil {
		return nil, fmt.Errorf("xshellz: dial %s: %w", addr, err)
	}

	sshConn, chans, reqs, err := ssh.NewClientConn(conn, addr, config)
	if err != nil {
		_ = conn.Close()
		return nil, fmt.Errorf("xshellz: SSH handshake with %s: %w", addr, err)
	}
	return &sshRunner{client: ssh.NewClient(sshConn, chans, reqs)}, nil
}

func (r *sshRunner) run(ctx context.Context, cmd string, stdin io.Reader, stdout, stderr io.Writer) (int, error) {
	session, err := r.client.NewSession()
	if err != nil {
		return -1, fmt.Errorf("xshellz: open SSH session: %w", err)
	}
	defer session.Close()

	session.Stdin = stdin
	session.Stdout = stdout
	session.Stderr = stderr

	if err := session.Start(cmd); err != nil {
		return -1, fmt.Errorf("xshellz: start command: %w", err)
	}

	done := make(chan error, 1)
	go func() { done <- session.Wait() }()

	select {
	case <-ctx.Done():
		_ = session.Signal(ssh.SIGKILL)
		_ = session.Close()
		<-done
		return -1, ctx.Err()
	case err := <-done:
		if err == nil {
			return 0, nil
		}
		var exitErr *ssh.ExitError
		if errors.As(err, &exitErr) {
			return exitErr.ExitStatus(), nil
		}
		return -1, fmt.Errorf("xshellz: command failed: %w", err)
	}
}

func (r *sshRunner) close() error {
	return r.client.Close()
}