0
0
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
}