~ knotless Search/
↑↓ move↵ open⇧↵ all results

socialweb.computer/socialweb-computer-kcp

socialweb.computer: a compute market on atproto (kcp)

1 collaborator
0
0
190 lines · 6.2 KB Raw History
package main

import (
	"fmt"
	"io"
	"slices"
	"sort"
	"strings"

	"github.com/johnandersen777/socialweb-computer-kcp/internal/app/compose"
	"github.com/johnandersen777/socialweb-computer-kcp/internal/atproto/cloudinit"
	"github.com/johnandersen777/socialweb-computer-kcp/internal/capabilities"
	"github.com/johnandersen777/socialweb-computer-kcp/internal/clicfg"
	"github.com/johnandersen777/socialweb-computer-kcp/internal/stack/request"
)

const (
	parseArgsVerb = "internal parse-args"
	execOpt       = "exec"
	execUsage     = cloudinit.RequestExecUsage
	optionsJSON   = "internal/clicfg/options.json"
)

type verbArgs struct {
	app       []string
	appNames  []string
	appShown  []string
	command   []string
	dashdash  bool
	execValue string
}

func takesCommand(own []string) bool { return slices.Contains(own, execOpt) }

func splitVerbArgs(spec clicfg.Spec, verb string, own []string, app string, args []string) ([]string, verbArgs, error) {
	var out verbArgs
	if app != "" {
		mappings, err := compose.AppOptionMappings(app)
		if err != nil {
			return nil, out, err
		}
		var twice []string
		for _, m := range mappings {
			if slices.Contains(own, m.Name) {
				twice = append(twice, "--"+m.Name)
			}
			out.appNames = append(out.appNames, m.Name)
			if m.To != compose.MapToRemoved {
				out.appShown = append(out.appShown, m.Name)
			}
		}
		if len(twice) > 0 {
			return nil, out, fmt.Errorf("%s: %s defined twice, in %s and in %s (app %s); each option of a verb is defined once", verb, strings.Join(twice, " "), optionsJSON, "deploy/"+compose.OptionMapPath, app)
		}
	}
	known := func(name string) bool {
		_, ok := spec.Options[name]
		return ok || slices.Contains(out.appNames, name)
	}
	var flags, words []string
	for i := 0; i < len(args); i++ {
		arg := args[i]
		if arg == "--" {
			out.dashdash, out.command = true, slices.Clone(args[i+1:])
			break
		}
		if !strings.HasPrefix(arg, "-") || arg == "-" {
			words = append(words, arg)
			continue
		}
		name, value, hasValue := strings.Cut(strings.TrimLeft(arg, "-"), "=")
		if strings.HasPrefix(arg, "--") && slices.Contains(out.appNames, name) {
			out.app = append(out.app, arg)
			if !hasValue && i+1 < len(args) && !strings.HasPrefix(args[i+1], "-") {
				i++
				out.app = append(out.app, args[i])
			}
			continue
		}
		if name == execOpt && takesCommand(own) {
			if hasValue && value != "true" && value != "false" {
				return nil, out, oldExec(verb, value)
			}
			if !hasValue && i+1 < len(args) && !strings.HasPrefix(args[i+1], "-") {
				out.execValue = args[i+1]
			}
		}
		flags = append(flags, arg)
		if o, ok := spec.Options[name]; ok && !hasValue && o.Type != clicfg.TypeBoolean && o.Bare == "" && i+1 < len(args) && args[i+1] != "--" {
			i++
			flags = append(flags, args[i])
		}
	}
	if out.dashdash && len(out.command) > 0 && strings.HasPrefix(out.command[0], "-") {
		name, _, _ := strings.Cut(strings.TrimLeft(out.command[0], "-"), "=")
		if known(name) && out.execValue != "" {
			return nil, out, fmt.Errorf("%s: every option goes before the command, and --exec takes no value; write: %s %s", verb, strings.Join(out.command, " "), execExample(out.execValue))
		}
		if known(name) && !takesCommand(own) {
			return nil, out, fmt.Errorf("%s runs no command: -- ends its options and nothing may follow it; put %s with its other options", verb, strings.Join(out.command, " "))
		}
		if known(name) {
			return nil, out, fmt.Errorf("%s: -- ends the options and what follows it is the command; put %s before --", verb, strings.Join(out.command, " "))
		}
	}
	return append(flags, words...), out, nil
}

func checkCommand(verb string, own []string, vals clicfg.Values, va verbArgs) error {
	switch exec := takesCommand(own) && vals.Bool(execOpt); {
	case !takesCommand(own) && va.dashdash:
		return fmt.Errorf("%s runs no command: -- ends the options and nothing may follow it", verb)
	case !exec && va.dashdash:
		return fmt.Errorf("%s: the command after -- runs with --exec: %s", verb, execUsage)
	case exec && !va.dashdash && va.execValue != "":
		return oldExec(verb, va.execValue)
	case exec && !va.dashdash:
		return fmt.Errorf("%s: --exec runs the command written after --: %s", verb, execUsage)
	case exec && len(va.command) == 0:
		return fmt.Errorf("%s: --exec -- needs a command: %s", verb, execUsage)
	}
	return nil
}

func oldExec(verb, value string) error {
	return fmt.Errorf("%s: --exec takes no value; write the command after --: %s", verb, execExample(value))
}

func execExample(line string) string {
	if strings.ContainsAny(line, " \t\n;|&<>()$`\\\"'*?[]#~=%{}") {
		return "--exec -- sh -c " + request.RemoteCommand([]string{line})
	}
	return "--exec -- " + line
}

func printVerbUsage(w io.Writer, verb string, own []string, va verbArgs, app string) {
	if takesCommand(own) {
		fmt.Fprintf(w, "usage: socialweb-computer %s [options] %s\n  the command and its args go to the guest as that argv, never through a shell; a shell line is --exec -- sh -c '<line>'\n", verb, execUsage)
	}
	if app == "" {
		return
	}
	names := slices.Clone(va.appShown)
	sort.Strings(names)
	fmt.Fprintf(w, "options of the %s application (%s), on the same command line:\n", app, "deploy/"+compose.OptionMapPath)
	line := " "
	for _, n := range names {
		if len(line)+len(n)+3 > 110 {
			fmt.Fprintln(w, line)
			line = " "
		}
		line += " --" + n
	}
	fmt.Fprintln(w, line)
}

type parsedArgs struct {
	Verb    string   `json:"verb"`
	Words   []string `json:"words"`
	App     []string `json:"app"`
	Command []string `json:"command"`
}

func (a *app) parseArgs(args []string) int {
	verb, rest, ok := capabilities.Find(args)
	if !ok {
		return a.fail(exitRefused, "%s: unknown subcommand %q", parseArgsVerb, strings.Join(args, " "))
	}
	if _, folded := foldedVerbs()[verb.Path]; folded {
		return a.fail(exitRefused, "%s: %s parses its own arguments", parseArgsVerb, verb.Path)
	}
	if verb.Path == parseArgsVerb {
		return a.fail(exitRefused, "%s: not of itself", parseArgsVerb)
	}
	p, code, done := a.parseVerb(verb, rest)
	if done {
		return code
	}
	if app := verbApps[verb.Path]; app != "" {
		if _, err := compose.ParseAppArgs(app, a.args.app); err != nil {
			return a.fail(exitRefused, "%s: %v", verb.Path, err)
		}
	}
	out := parsedArgs{Verb: verb.Path, Words: p.rest, App: a.args.app}
	if p.vals.Bool(execOpt) {
		out.Command = a.args.command
	}
	a.printJSON(out)
	return exitOK
}