Support local managment for embedded agent on nginx

external/yq/cmd/constant.go

@@ -0,0 +1,33 @@
+package cmd
+
+var unwrapScalarFlag = newUnwrapFlag()
+
+var unwrapScalar = false
+
+var writeInplace = false
+var outputToJSON = false
+var outputFormat = "yaml"
+var inputFormat = "yaml"
+
+var exitStatus = false
+var forceColor = false
+var forceNoColor = false
+var colorsEnabled = false
+var indent = 2
+var noDocSeparators = false
+var nullInput = false
+var verbose = false
+var version = false
+var prettyPrint = false
+
+// can be either "" (off), "extract" or "process"
+var frontMatter = ""
+
+var splitFileExp = ""
+var splitFileExpFile = ""
+
+var completedSuccessfully = false
+
+var forceExpression = ""
+
+var expressionFile = ""

external/yq/cmd/evaluate_all_command.go

@@ -0,0 +1,128 @@
+package cmd
+
+import (
+	"errors"
+
+	"github.com/mikefarah/yq/v4/pkg/yqlib"
+	"github.com/spf13/cobra"
+)
+
+func createEvaluateAllCommand() *cobra.Command {
+	var cmdEvalAll = &cobra.Command{
+		Use:     "eval-all [expression] [yaml_file1]...",
+		Aliases: []string{"ea"},
+		Short:   "Loads _all_ yaml documents of _all_ yaml files and runs expression once",
+		Example: `
+# Merge f2.yml into f1.yml (inplace)
+yq eval-all --inplace 'select(fileIndex == 0) * select(fileIndex == 1)' f1.yml f2.yml
+## the same command and expression using shortened names:
+yq ea -i 'select(fi == 0) * select(fi == 1)' f1.yml f2.yml
+
+
+# Merge all given files
+yq ea '. as $item ireduce ({}; . * $item )' file1.yml file2.yml ...
+
+# Pipe from STDIN
+## use '-' as a filename to pipe from STDIN
+cat file2.yml | yq ea '.a.b' file1.yml - file3.yml
+`,
+		Long: `yq is a portable command-line YAML processor (https://github.com/mikefarah/yq/) 
+See https://mikefarah.gitbook.io/yq/ for detailed documentation and examples.
+
+## Evaluate All ##
+This command loads _all_ yaml documents of _all_ yaml files and runs expression once
+Useful when you need to run an expression across several yaml documents or files (like merge).
+Note that it consumes more memory than eval.
+`,
+		RunE: evaluateAll,
+	}
+	return cmdEvalAll
+}
+func evaluateAll(cmd *cobra.Command, args []string) (cmdError error) {
+	// 0 args, read std in
+	// 1 arg, null input, process expression
+	// 1 arg, read file in sequence
+	// 2+ args, [0] = expression, file the rest
+
+	var err error
+
+	expression, args, err := initCommand(cmd, args)
+	if err != nil {
+		return err
+	}
+
+	out := cmd.OutOrStdout()
+
+	if writeInplace {
+		// only use colors if its forced
+		colorsEnabled = forceColor
+		writeInPlaceHandler := yqlib.NewWriteInPlaceHandler(args[0])
+		out, err = writeInPlaceHandler.CreateTempFile()
+		if err != nil {
+			return err
+		}
+		// need to indirectly call the function so  that completedSuccessfully is
+		// passed when we finish execution as opposed to now
+		defer func() {
+			if cmdError == nil {
+				cmdError = writeInPlaceHandler.FinishWriteInPlace(completedSuccessfully)
+			}
+		}()
+	}
+
+	format, err := yqlib.OutputFormatFromString(outputFormat)
+	if err != nil {
+		return err
+	}
+
+	decoder, err := configureDecoder(true)
+	if err != nil {
+		return err
+	}
+
+	printerWriter, err := configurePrinterWriter(format, out)
+	if err != nil {
+		return err
+	}
+	encoder := configureEncoder(format)
+
+	printer := yqlib.NewPrinter(encoder, printerWriter)
+
+	if frontMatter != "" {
+		frontMatterHandler := yqlib.NewFrontMatterHandler(args[0])
+		err = frontMatterHandler.Split()
+		if err != nil {
+			return err
+		}
+		args[0] = frontMatterHandler.GetYamlFrontMatterFilename()
+
+		if frontMatter == "process" {
+			reader := frontMatterHandler.GetContentReader()
+			printer.SetAppendix(reader)
+			defer yqlib.SafelyCloseReader(reader)
+		}
+		defer frontMatterHandler.CleanUp()
+	}
+
+	allAtOnceEvaluator := yqlib.NewAllAtOnceEvaluator()
+
+	switch len(args) {
+	case 0:
+		if nullInput {
+			err = yqlib.NewStreamEvaluator().EvaluateNew(processExpression(expression), printer)
+		} else {
+			cmd.Println(cmd.UsageString())
+			return nil
+		}
+	default:
+		err = allAtOnceEvaluator.EvaluateFiles(processExpression(expression), args, printer, decoder)
+	}
+
+	completedSuccessfully = err == nil
+
+	if err == nil && exitStatus && !printer.PrintedAnything() {
+		return errors.New("no matches found")
+	}
+
+	return err
+}

external/yq/cmd/evalute_sequence_command.go

@@ -0,0 +1,141 @@
+package cmd
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/mikefarah/yq/v4/pkg/yqlib"
+	"github.com/spf13/cobra"
+)
+
+func createEvaluateSequenceCommand() *cobra.Command {
+	var cmdEvalSequence = &cobra.Command{
+		Use:     "eval [expression] [yaml_file1]...",
+		Aliases: []string{"e"},
+		Short:   "(default) Apply the expression to each document in each yaml file in sequence",
+		Example: `
+# Reads field under the given path for each file
+yq e '.a.b' f1.yml f2.yml 
+
+# Prints out the file
+yq e sample.yaml 
+
+# Pipe from STDIN
+## use '-' as a filename to pipe from STDIN
+cat file2.yml | yq e '.a.b' file1.yml - file3.yml
+
+# Creates a new yaml document
+## Note that editing an empty file does not work.
+yq e -n '.a.b.c = "cat"' 
+
+# Update a file inplace
+yq e '.a.b = "cool"' -i file.yaml 
+`,
+		Long: `yq is a portable command-line YAML processor (https://github.com/mikefarah/yq/) 
+See https://mikefarah.gitbook.io/yq/ for detailed documentation and examples.
+
+## Evaluate Sequence ##
+This command iterates over each yaml document from each given file, applies the 
+expression and prints the result in sequence.`,
+		RunE: evaluateSequence,
+	}
+	return cmdEvalSequence
+}
+
+func processExpression(expression string) string {
+
+	if prettyPrint && expression == "" {
+		return yqlib.PrettyPrintExp
+	} else if prettyPrint {
+		return fmt.Sprintf("%v | %v", expression, yqlib.PrettyPrintExp)
+	}
+	return expression
+}
+
+func evaluateSequence(cmd *cobra.Command, args []string) (cmdError error) {
+	// 0 args, read std in
+	// 1 arg, null input, process expression
+	// 1 arg, read file in sequence
+	// 2+ args, [0] = expression, file the rest
+
+	out := cmd.OutOrStdout()
+
+	var err error
+
+	expression, args, err := initCommand(cmd, args)
+	if err != nil {
+		return err
+	}
+
+	if writeInplace {
+		// only use colors if its forced
+		colorsEnabled = forceColor
+		writeInPlaceHandler := yqlib.NewWriteInPlaceHandler(args[0])
+		out, err = writeInPlaceHandler.CreateTempFile()
+		if err != nil {
+			return err
+		}
+		// need to indirectly call the function so  that completedSuccessfully is
+		// passed when we finish execution as opposed to now
+		defer func() {
+			if cmdError == nil {
+				cmdError = writeInPlaceHandler.FinishWriteInPlace(completedSuccessfully)
+			}
+		}()
+	}
+
+	format, err := yqlib.OutputFormatFromString(outputFormat)
+	if err != nil {
+		return err
+	}
+
+	printerWriter, err := configurePrinterWriter(format, out)
+	if err != nil {
+		return err
+	}
+	encoder := configureEncoder(format)
+
+	printer := yqlib.NewPrinter(encoder, printerWriter)
+
+	decoder, err := configureDecoder(false)
+	if err != nil {
+		return err
+	}
+	streamEvaluator := yqlib.NewStreamEvaluator()
+
+	if frontMatter != "" {
+		yqlib.GetLogger().Debug("using front matter handler")
+		frontMatterHandler := yqlib.NewFrontMatterHandler(args[0])
+		err = frontMatterHandler.Split()
+		if err != nil {
+			return err
+		}
+		args[0] = frontMatterHandler.GetYamlFrontMatterFilename()
+
+		if frontMatter == "process" {
+			reader := frontMatterHandler.GetContentReader()
+			printer.SetAppendix(reader)
+			defer yqlib.SafelyCloseReader(reader)
+		}
+		defer frontMatterHandler.CleanUp()
+	}
+
+	switch len(args) {
+	case 0:
+		if nullInput {
+			err = streamEvaluator.EvaluateNew(processExpression(expression), printer)
+		} else {
+			cmd.Println(cmd.UsageString())
+			return nil
+		}
+	default:
+		err = streamEvaluator.EvaluateFiles(processExpression(expression), args, printer, decoder)
+	}
+	completedSuccessfully = err == nil
+
+	if err == nil && exitStatus && !printer.PrintedAnything() {
+		return errors.New("no matches found")
+	}
+
+	return err
+}

external/yq/cmd/root.go

@@ -0,0 +1,145 @@
+package cmd
+
+import (
+	"os"
+
+	"github.com/mikefarah/yq/v4/pkg/yqlib"
+	"github.com/spf13/cobra"
+	logging "gopkg.in/op/go-logging.v1"
+)
+
+func New() *cobra.Command {
+	var rootCmd = &cobra.Command{
+		Use:   "yq",
+		Short: "yq is a lightweight and portable command-line YAML processor.",
+		Long: `yq is a portable command-line YAML processor (https://github.com/mikefarah/yq/) 
+See https://mikefarah.gitbook.io/yq/ for detailed documentation and examples.`,
+		Example: `
+# yq defaults to 'eval' command if no command is specified. See "yq eval --help" for more examples.
+
+# read the "stuff" node from "myfile.yml"
+yq '.stuff' < myfile.yml
+
+# update myfile.yml in place
+yq -i '.stuff = "foo"' myfile.yml
+
+# print contents of sample.json as idiomatic YAML
+yq -P sample.json
+`,
+
+		RunE: func(cmd *cobra.Command, args []string) error {
+			if version {
+				cmd.Print(GetVersionDisplay())
+				return nil
+			}
+			return evaluateSequence(cmd, args)
+
+		},
+		PersistentPreRunE: func(cmd *cobra.Command, args []string) error {
+			cmd.SetOut(cmd.OutOrStdout())
+
+			var format = logging.MustStringFormatter(
+				`%{color}%{time:15:04:05} %{shortfunc} [%{level:.4s}]%{color:reset} %{message}`,
+			)
+			var backend = logging.AddModuleLevel(
+				logging.NewBackendFormatter(logging.NewLogBackend(os.Stderr, "", 0), format))
+
+			if verbose {
+				backend.SetLevel(logging.DEBUG, "")
+			} else {
+				backend.SetLevel(logging.WARNING, "")
+			}
+
+			logging.SetBackend(backend)
+			yqlib.InitExpressionParser()
+
+			outputFormatType, err := yqlib.OutputFormatFromString(outputFormat)
+
+			if err != nil {
+				return err
+			}
+
+			inputFormatType, err := yqlib.InputFormatFromString(inputFormat)
+
+			if err != nil {
+				return err
+			}
+
+			if (inputFormatType == yqlib.XMLInputFormat &&
+				outputFormatType != yqlib.XMLOutputFormat ||
+				inputFormatType != yqlib.XMLInputFormat &&
+					outputFormatType == yqlib.XMLOutputFormat) &&
+				yqlib.ConfiguredXMLPreferences.AttributePrefix == "+@" {
+				yqlib.GetLogger().Warning("The default xml-attribute-prefix has changed in the v4.30 to `+@` to avoid " +
+					"naming conflicts with the default content name, directive name and proc inst prefix. If you need to keep " +
+					"`+` please set that value explicityly with --xml-attribute-prefix.")
+			}
+
+			if outputFormatType == yqlib.YamlOutputFormat ||
+				outputFormatType == yqlib.PropsOutputFormat {
+				unwrapScalar = true
+			}
+			if unwrapScalarFlag.IsExplicitySet() {
+				unwrapScalar = unwrapScalarFlag.IsSet()
+			}
+
+			//copy preference form global setting
+			yqlib.ConfiguredYamlPreferences.UnwrapScalar = unwrapScalar
+
+			yqlib.ConfiguredYamlPreferences.PrintDocSeparators = !noDocSeparators
+
+			return nil
+		},
+	}
+
+	rootCmd.PersistentFlags().BoolVarP(&verbose, "verbose", "v", false, "verbose mode")
+
+	rootCmd.PersistentFlags().BoolVarP(&outputToJSON, "tojson", "j", false, "(deprecated) output as json. Set indent to 0 to print json in one line.")
+	err := rootCmd.PersistentFlags().MarkDeprecated("tojson", "please use -o=json instead")
+	if err != nil {
+		panic(err)
+	}
+
+	rootCmd.PersistentFlags().StringVarP(&outputFormat, "output-format", "o", "yaml", "[yaml|y|json|j|props|p|xml|x] output format type.")
+	rootCmd.PersistentFlags().StringVarP(&inputFormat, "input-format", "p", "yaml", "[yaml|y|props|p|xml|x] parse format for input. Note that json is a subset of yaml.")
+
+	rootCmd.PersistentFlags().StringVar(&yqlib.ConfiguredXMLPreferences.AttributePrefix, "xml-attribute-prefix", yqlib.ConfiguredXMLPreferences.AttributePrefix, "prefix for xml attributes")
+	rootCmd.PersistentFlags().StringVar(&yqlib.ConfiguredXMLPreferences.ContentName, "xml-content-name", yqlib.ConfiguredXMLPreferences.ContentName, "name for xml content (if no attribute name is present).")
+	rootCmd.PersistentFlags().BoolVar(&yqlib.ConfiguredXMLPreferences.StrictMode, "xml-strict-mode", yqlib.ConfiguredXMLPreferences.StrictMode, "enables strict parsing of XML. See https://pkg.go.dev/encoding/xml for more details.")
+	rootCmd.PersistentFlags().BoolVar(&yqlib.ConfiguredXMLPreferences.KeepNamespace, "xml-keep-namespace", yqlib.ConfiguredXMLPreferences.KeepNamespace, "enables keeping namespace after parsing attributes")
+	rootCmd.PersistentFlags().BoolVar(&yqlib.ConfiguredXMLPreferences.UseRawToken, "xml-raw-token", yqlib.ConfiguredXMLPreferences.UseRawToken, "enables using RawToken method instead Token. Commonly disables namespace translations. See https://pkg.go.dev/encoding/xml#Decoder.RawToken for details.")
+	rootCmd.PersistentFlags().StringVar(&yqlib.ConfiguredXMLPreferences.ProcInstPrefix, "xml-proc-inst-prefix", yqlib.ConfiguredXMLPreferences.ProcInstPrefix, "prefix for xml processing instructions (e.g. <?xml version=\"1\"?>)")
+	rootCmd.PersistentFlags().StringVar(&yqlib.ConfiguredXMLPreferences.DirectiveName, "xml-directive-name", yqlib.ConfiguredXMLPreferences.DirectiveName, "name for xml directives (e.g. <!DOCTYPE thing cat>)")
+	rootCmd.PersistentFlags().BoolVar(&yqlib.ConfiguredXMLPreferences.SkipProcInst, "xml-skip-proc-inst", yqlib.ConfiguredXMLPreferences.SkipProcInst, "skip over process instructions (e.g. <?xml version=\"1\"?>)")
+	rootCmd.PersistentFlags().BoolVar(&yqlib.ConfiguredXMLPreferences.SkipDirectives, "xml-skip-directives", yqlib.ConfiguredXMLPreferences.SkipDirectives, "skip over directives (e.g. <!DOCTYPE thing cat>)")
+
+	rootCmd.PersistentFlags().BoolVarP(&nullInput, "null-input", "n", false, "Don't read input, simply evaluate the expression given. Useful for creating docs from scratch.")
+	rootCmd.PersistentFlags().BoolVarP(&noDocSeparators, "no-doc", "N", false, "Don't print document separators (---)")
+
+	rootCmd.PersistentFlags().IntVarP(&indent, "indent", "I", 2, "sets indent level for output")
+	rootCmd.Flags().BoolVarP(&version, "version", "V", false, "Print version information and quit")
+	rootCmd.PersistentFlags().BoolVarP(&writeInplace, "inplace", "i", false, "update the file inplace of first file given.")
+	rootCmd.PersistentFlags().VarP(unwrapScalarFlag, "unwrapScalar", "r", "unwrap scalar, print the value with no quotes, colors or comments. Defaults to true for yaml")
+	rootCmd.PersistentFlags().Lookup("unwrapScalar").NoOptDefVal = "true"
+
+	rootCmd.PersistentFlags().BoolVarP(&prettyPrint, "prettyPrint", "P", false, "pretty print, shorthand for '... style = \"\"'")
+	rootCmd.PersistentFlags().BoolVarP(&exitStatus, "exit-status", "e", false, "set exit status if there are no matches or null or false is returned")
+
+	rootCmd.PersistentFlags().BoolVarP(&forceColor, "colors", "C", false, "force print with colors")
+	rootCmd.PersistentFlags().BoolVarP(&forceNoColor, "no-colors", "M", false, "force print with no colors")
+	rootCmd.PersistentFlags().StringVarP(&frontMatter, "front-matter", "f", "", "(extract|process) first input as yaml front-matter. Extract will pull out the yaml content, process will run the expression against the yaml content, leaving the remaining data intact")
+	rootCmd.PersistentFlags().StringVarP(&forceExpression, "expression", "", "", "forcibly set the expression argument. Useful when yq argument detection thinks your expression is a file.")
+	rootCmd.PersistentFlags().BoolVarP(&yqlib.ConfiguredYamlPreferences.LeadingContentPreProcessing, "header-preprocess", "", true, "Slurp any header comments and separators before processing expression.")
+
+	rootCmd.PersistentFlags().StringVarP(&splitFileExp, "split-exp", "s", "", "print each result (or doc) into a file named (exp). [exp] argument must return a string. You can use $index in the expression as the result counter.")
+	rootCmd.PersistentFlags().StringVarP(&splitFileExpFile, "split-exp-file", "", "", "Use a file to specify the split-exp expression.")
+
+	rootCmd.PersistentFlags().StringVarP(&expressionFile, "from-file", "", "", "Load expression from specified file.")
+
+	rootCmd.AddCommand(
+		createEvaluateSequenceCommand(),
+		createEvaluateAllCommand(),
+		completionCmd,
+	)
+	return rootCmd
+}

external/yq/cmd/shell-completion.go

@@ -0,0 +1,61 @@
+package cmd
+
+import (
+	"os"
+
+	"github.com/spf13/cobra"
+)
+
+var completionCmd = &cobra.Command{
+	Use:   "shell-completion [bash|zsh|fish|powershell]",
+	Short: "Generate completion script",
+	Long: `To load completions:
+
+Bash:
+
+$ source <(yq shell-completion bash)
+
+# To load completions for each session, execute once:
+Linux:
+  $ yq shell-completion bash > /etc/bash_completion.d/yq
+MacOS:
+  $ yq shell-completion bash > /usr/local/etc/bash_completion.d/yq
+
+Zsh:
+
+# If shell completion is not already enabled in your environment you will need
+# to enable it.  You can execute the following once:
+
+$ echo "autoload -U compinit; compinit" >> ~/.zshrc
+
+# To load completions for each session, execute once:
+$ yq shell-completion zsh > "${fpath[1]}/_yq"
+
+# You will need to start a new shell for this setup to take effect.
+
+Fish:
+
+$ yq shell-completion fish | source
+
+# To load completions for each session, execute once:
+$ yq shell-completion fish > ~/.config/fish/completions/yq.fish
+`,
+	DisableFlagsInUseLine: true,
+	ValidArgs:             []string{"bash", "zsh", "fish", "powershell"},
+	Args:                  cobra.MatchAll(cobra.ExactArgs(1), cobra.OnlyValidArgs),
+	RunE: func(cmd *cobra.Command, args []string) error {
+		var err error = nil
+		switch args[0] {
+		case "bash":
+			err = cmd.Root().GenBashCompletion(os.Stdout)
+		case "zsh":
+			err = cmd.Root().GenZshCompletion(os.Stdout)
+		case "fish":
+			err = cmd.Root().GenFishCompletion(os.Stdout, true)
+		case "powershell":
+			err = cmd.Root().GenPowerShellCompletion(os.Stdout)
+		}
+		return err
+
+	},
+}

external/yq/cmd/unwrap_flag.go

@@ -0,0 +1,46 @@
+package cmd
+
+import (
+	"strconv"
+
+	"github.com/spf13/pflag"
+)
+
+type boolFlag interface {
+	pflag.Value
+	IsExplicitySet() bool
+	IsSet() bool
+}
+
+type unwrapScalarFlagStrc struct {
+	explicitySet bool
+	value        bool
+}
+
+func newUnwrapFlag() boolFlag {
+	return &unwrapScalarFlagStrc{value: true}
+}
+
+func (f *unwrapScalarFlagStrc) IsExplicitySet() bool {
+	return f.explicitySet
+}
+
+func (f *unwrapScalarFlagStrc) IsSet() bool {
+	return f.value
+}
+
+func (f *unwrapScalarFlagStrc) String() string {
+	return strconv.FormatBool(f.value)
+}
+
+func (f *unwrapScalarFlagStrc) Set(value string) error {
+
+	v, err := strconv.ParseBool(value)
+	f.value = v
+	f.explicitySet = true
+	return err
+}
+
+func (*unwrapScalarFlagStrc) Type() string {
+	return "bool"
+}

external/yq/cmd/utils.go

@@ -0,0 +1,178 @@
+package cmd
+
+import (
+	"fmt"
+	"io"
+	"os"
+
+	"github.com/mikefarah/yq/v4/pkg/yqlib"
+	"github.com/spf13/cobra"
+	"gopkg.in/op/go-logging.v1"
+)
+
+func initCommand(cmd *cobra.Command, args []string) (string, []string, error) {
+	cmd.SilenceUsage = true
+
+	fileInfo, _ := os.Stdout.Stat()
+
+	if forceColor || (!forceNoColor && (fileInfo.Mode()&os.ModeCharDevice) != 0) {
+		colorsEnabled = true
+	}
+
+	expression, args, err := processArgs(args)
+	if err != nil {
+		return "", nil, err
+	}
+
+	if splitFileExpFile != "" {
+		splitExpressionBytes, err := os.ReadFile(splitFileExpFile)
+		if err != nil {
+			return "", nil, err
+		}
+		splitFileExp = string(splitExpressionBytes)
+	}
+
+	// backwards compatibility
+	if outputToJSON {
+		outputFormat = "json"
+	}
+
+	if writeInplace && (len(args) == 0 || args[0] == "-") {
+		return "", nil, fmt.Errorf("write inplace flag only applicable when giving an expression and at least one file")
+	}
+
+	if frontMatter != "" && len(args) == 0 {
+		return "", nil, fmt.Errorf("front matter flag only applicable when giving an expression and at least one file")
+	}
+
+	if writeInplace && splitFileExp != "" {
+		return "", nil, fmt.Errorf("write inplace cannot be used with split file")
+	}
+
+	if nullInput && len(args) > 0 {
+		return "", nil, fmt.Errorf("cannot pass files in when using null-input flag")
+	}
+
+	return expression, args, nil
+}
+
+func configureDecoder(evaluateTogether bool) (yqlib.Decoder, error) {
+	yqlibInputFormat, err := yqlib.InputFormatFromString(inputFormat)
+	if err != nil {
+		return nil, err
+	}
+	switch yqlibInputFormat {
+	case yqlib.XMLInputFormat:
+		return yqlib.NewXMLDecoder(yqlib.ConfiguredXMLPreferences), nil
+	case yqlib.PropertiesInputFormat:
+		return yqlib.NewPropertiesDecoder(), nil
+	case yqlib.JsonInputFormat:
+		return yqlib.NewJSONDecoder(), nil
+	case yqlib.CSVObjectInputFormat:
+		return yqlib.NewCSVObjectDecoder(','), nil
+	case yqlib.TSVObjectInputFormat:
+		return yqlib.NewCSVObjectDecoder('\t'), nil
+	}
+	prefs := yqlib.ConfiguredYamlPreferences
+	prefs.EvaluateTogether = evaluateTogether
+	return yqlib.NewYamlDecoder(prefs), nil
+}
+
+func configurePrinterWriter(format yqlib.PrinterOutputFormat, out io.Writer) (yqlib.PrinterWriter, error) {
+
+	var printerWriter yqlib.PrinterWriter
+
+	if splitFileExp != "" {
+		colorsEnabled = forceColor
+		splitExp, err := yqlib.ExpressionParser.ParseExpression(splitFileExp)
+		if err != nil {
+			return nil, fmt.Errorf("bad split document expression: %w", err)
+		}
+		printerWriter = yqlib.NewMultiPrinterWriter(splitExp, format)
+	} else {
+		printerWriter = yqlib.NewSinglePrinterWriter(out)
+	}
+	return printerWriter, nil
+}
+
+func configureEncoder(format yqlib.PrinterOutputFormat) yqlib.Encoder {
+	switch format {
+	case yqlib.JSONOutputFormat:
+		return yqlib.NewJSONEncoder(indent, colorsEnabled, unwrapScalar)
+	case yqlib.PropsOutputFormat:
+		return yqlib.NewPropertiesEncoder(unwrapScalar)
+	case yqlib.CSVOutputFormat:
+		return yqlib.NewCsvEncoder(',')
+	case yqlib.TSVOutputFormat:
+		return yqlib.NewCsvEncoder('\t')
+	case yqlib.YamlOutputFormat:
+		return yqlib.NewYamlEncoder(indent, colorsEnabled, yqlib.ConfiguredYamlPreferences)
+	case yqlib.XMLOutputFormat:
+		return yqlib.NewXMLEncoder(indent, yqlib.ConfiguredXMLPreferences)
+	}
+	panic("invalid encoder")
+}
+
+// this is a hack to enable backwards compatibility with githubactions (which pipe /dev/null into everything)
+// and being able to call yq with the filename as a single parameter
+//
+// without this - yq detects there is stdin (thanks githubactions),
+// then tries to parse the filename as an expression
+func maybeFile(str string) bool {
+	yqlib.GetLogger().Debugf("checking '%v' is a file", str)
+	stat, err := os.Stat(str) // #nosec
+	result := err == nil && !stat.IsDir()
+	if yqlib.GetLogger().IsEnabledFor(logging.DEBUG) {
+		if err != nil {
+			yqlib.GetLogger().Debugf("error: %v", err)
+		} else {
+			yqlib.GetLogger().Debugf("error: %v, dir: %v", err, stat.IsDir())
+		}
+		yqlib.GetLogger().Debugf("result: %v", result)
+	}
+	return result
+}
+
+func processStdInArgs(args []string) []string {
+	stat, _ := os.Stdin.Stat()
+	pipingStdin := (stat.Mode() & os.ModeCharDevice) == 0
+
+	// if we've been given a file, don't automatically
+	// read from stdin.
+	// this happens if there is more than one argument
+	// or only one argument and its a file
+	if nullInput || !pipingStdin || len(args) > 1 || (len(args) > 0 && maybeFile(args[0])) {
+		return args
+	}
+
+	for _, arg := range args {
+		if arg == "-" {
+			return args
+		}
+	}
+	yqlib.GetLogger().Debugf("missing '-', adding it to the end")
+
+	// we're piping from stdin, but there's no '-' arg
+	// lets add one to the end
+	return append(args, "-")
+}
+
+func processArgs(originalArgs []string) (string, []string, error) {
+	expression := forceExpression
+	if expressionFile != "" {
+		expressionBytes, err := os.ReadFile(expressionFile)
+		if err != nil {
+			return "", nil, err
+		}
+		expression = string(expressionBytes)
+	}
+
+	args := processStdInArgs(originalArgs)
+	yqlib.GetLogger().Debugf("processed args: %v", args)
+	if expression == "" && len(args) > 0 && args[0] != "-" && !maybeFile(args[0]) {
+		yqlib.GetLogger().Debug("assuming expression is '%v'", args[0])
+		expression = args[0]
+		args = args[1:]
+	}
+	return expression, args, nil
+}

external/yq/cmd/version.go

@@ -0,0 +1,49 @@
+package cmd
+
+import (
+	"fmt"
+	"strings"
+)
+
+// The git commit that was compiled. This will be filled in by the compiler.
+var (
+	GitCommit   string
+	GitDescribe string
+
+	// Version is main version number that is being run at the moment.
+	Version = "4.30.1"
+
+	// VersionPrerelease is a pre-release marker for the version. If this is "" (empty string)
+	// then it means that it is a final release. Otherwise, this is a pre-release
+	// such as "dev" (in development), "beta", "rc1", etc.
+	VersionPrerelease = ""
+)
+
+// ProductName is the name of the product
+const ProductName = "yq"
+
+// GetVersionDisplay composes the parts of the version in a way that's suitable
+// for displaying to humans.
+func GetVersionDisplay() string {
+	return fmt.Sprintf("yq (https://github.com/mikefarah/yq/) version %s\n", getHumanVersion())
+}
+
+func getHumanVersion() string {
+	version := Version
+	if GitDescribe != "" {
+		version = GitDescribe
+	}
+
+	release := VersionPrerelease
+	if release != "" {
+		if !strings.Contains(version, release) {
+			version += fmt.Sprintf("-%s", release)
+		}
+		if GitCommit != "" {
+			version += fmt.Sprintf(" (%s)", GitCommit)
+		}
+	}
+
+	// Strip off any single quotes added by the git information.
+	return strings.Replace(version, "'", "", -1)
+}

external/yq/cmd/version_test.go

@@ -0,0 +1,51 @@
+package cmd
+
+import "testing"
+
+func TestGetVersionDisplay(t *testing.T) {
+	var expectedVersion = ProductName + " (https://github.com/mikefarah/yq/) version " + Version
+	if VersionPrerelease != "" {
+		expectedVersion = expectedVersion + "-" + VersionPrerelease
+	}
+	expectedVersion = expectedVersion + "\n"
+	tests := []struct {
+		name string
+		want string
+	}{
+		{
+			name: "Display Version",
+			want: expectedVersion,
+		},
+	}
+	for _, tt := range tests {
+		if got := GetVersionDisplay(); got != tt.want {
+			t.Errorf("%q. GetVersionDisplay() = %v, want %v", tt.name, got, tt.want)
+		}
+	}
+}
+
+func Test_getHumanVersion(t *testing.T) {
+	GitDescribe = "e42813d"
+	GitCommit = "e42813d+CHANGES"
+	var wanted string
+	if VersionPrerelease == "" {
+		wanted = GitDescribe
+	} else {
+		wanted = "e42813d-" + VersionPrerelease + " (e42813d+CHANGES)"
+	}
+
+	tests := []struct {
+		name string
+		want string
+	}{
+		{
+			name: "Git Variables defined",
+			want: wanted,
+		},
+	}
+	for _, tt := range tests {
+		if got := getHumanVersion(); got != tt.want {
+			t.Errorf("%q. getHumanVersion() = %v, want %v", tt.name, got, tt.want)
+		}
+	}
+}