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 ''\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 }