main.go

package main

import (
	"encoding/json"
	"fmt"
	"strconv"
	"sync"

	squadron "github.com/mlund01/squadron-sdk"
)

var tools = map[string]*squadron.ToolInfo{
	"exec": {
		Name:        "exec",
		Description: "Execute a shell command. The execution target (local, SSH, or Docker) is configured at the plugin level.",
		Schema: squadron.Schema{
			Type: squadron.TypeObject,
			Properties: squadron.PropertyMap{
				"command": {
					Type:        squadron.TypeString,
					Description: "The shell command to execute",
				},
				"timeout": {
					Type:        squadron.TypeInteger,
					Description: "Timeout in seconds. 0 means no timeout. Default: 120",
				},
			},
			Required: []string{"command"},
		},
	},
}

type ShellPlugin struct {
	mu       sync.Mutex
	executor Executor
	mode     string
}

// Configure sets up the executor based on plugin settings.
//
// Settings:
//
//	mode      - "local" (default), "ssh", or "docker"
//	shell     - Shell to use (default: "bash" on unix, "cmd" on windows, "sh" in docker)
//
// SSH mode settings:
//
//	host      - SSH host (required)
//	user      - SSH user (required)
//	port      - SSH port (default: 22)
//	key_file  - Path to SSH private key
//	password  - SSH password (prefer key_file)
//
// Docker mode settings:
//
//	container - Name or ID of running container (use this OR image)
//	image     - Docker image to create a container from (use this OR container)
func (p *ShellPlugin) Configure(settings map[string]string) error {
	p.mu.Lock()
	defer p.mu.Unlock()

	mode := settings["mode"]
	if mode == "" {
		mode = "local"
	}
	p.mode = mode

	shell := settings["shell"]

	switch mode {
	case "local":
		p.executor = NewLocalExecutor(shell)
		return nil

	case "ssh":
		host := settings["host"]
		user := settings["user"]
		if host == "" || user == "" {
			return fmt.Errorf("ssh mode requires 'host' and 'user' settings")
		}
		port := 22
		if portStr := settings["port"]; portStr != "" {
			var err error
			port, err = strconv.Atoi(portStr)
			if err != nil {
				return fmt.Errorf("invalid port: %s", portStr)
			}
		}
		keyFile := settings["key_file"]
		password := settings["password"]

		executor, err := NewSSHExecutor(host, user, keyFile, password, port)
		if err != nil {
			return err
		}
		p.executor = executor
		return nil

	case "docker":
		container := settings["container"]
		image := settings["image"]
		executor, err := NewDockerExecutor(container, image, shell)
		if err != nil {
			return err
		}
		p.executor = executor
		return nil

	default:
		return fmt.Errorf("unknown mode %q: use 'local', 'ssh', or 'docker'", mode)
	}
}

type execParams struct {
	Command string `json:"command"`
	Timeout int    `json:"timeout"`
}

func (p *ShellPlugin) Call(toolName string, payload string) (string, error) {
	if toolName != "exec" {
		return "", fmt.Errorf("unknown tool: %s", toolName)
	}

	var params execParams
	if err := json.Unmarshal([]byte(payload), &params); err != nil {
		return "", fmt.Errorf("invalid parameters: %w", err)
	}
	if params.Command == "" {
		return "", fmt.Errorf("command is required")
	}
	if params.Timeout == 0 {
		params.Timeout = 120
	}

	p.mu.Lock()
	executor := p.executor
	p.mu.Unlock()

	if executor == nil {
		return "", fmt.Errorf("plugin not configured — call Configure first")
	}

	return executor.Exec(params.Command, params.Timeout)
}

func (p *ShellPlugin) GetToolInfo(toolName string) (*squadron.ToolInfo, error) {
	info, ok := tools[toolName]
	if !ok {
		return nil, fmt.Errorf("unknown tool: %s", toolName)
	}
	return info, nil
}

func (p *ShellPlugin) ListTools() ([]*squadron.ToolInfo, error) {
	result := make([]*squadron.ToolInfo, 0, len(tools))
	for _, info := range tools {
		result = append(result, info)
	}
	return result, nil
}

func main() {
	squadron.Serve(&ShellPlugin{})
}