diff --git a/internal/generator/generator.go b/internal/generator/generator.go
index a55e54efa..c5c1a6ba9 100644
--- a/internal/generator/generator.go
+++ b/internal/generator/generator.go
@@ -2496,6 +2496,12 @@ func (g *Generator) renderOptionalSupportFiles() error {
}
}
+ if g.Spec.HasXMLResponse() {
+ if err := g.renderTemplate("cliutil_xml_parse.go.tmpl", filepath.Join("internal", "cliutil", "xml_parse.go"), g.Spec); err != nil {
+ return fmt.Errorf("rendering cliutil xml parse: %w", err)
+ }
+ }
+
// Emit the cliutil proxypath helper only for proxy-envelope clients —
// the BuildPath function is the only caller of net/url.Values in the
// cliutil package, and there's no point shipping it (and its tests)
diff --git a/internal/generator/templates/client.go.tmpl b/internal/generator/templates/client.go.tmpl
index e181afaad..ab384e3c9 100644
--- a/internal/generator/templates/client.go.tmpl
+++ b/internal/generator/templates/client.go.tmpl
@@ -1631,6 +1631,14 @@ func (c *Client) doInternal(ctx context.Context, method, path string, params map
}
return env, resp.StatusCode, nil
}
+{{- if .HasXMLResponse}}
+ // XML endpoints carry an application/xml Accept override. Use that
+ // per-request signal so mixed XML/JSON specs normalize only the XML
+ // endpoint's success body. A decode failure returns the raw bytes.
+ if isXMLRequest(req.Header.Get("Accept")) && isXMLResponseContentType(resp.Header.Get("Content-Type")) {
+ return cliutil.XMLToJSON(json.RawMessage(respBody)), resp.StatusCode, nil
+ }
+{{- end}}
return json.RawMessage(sanitizeJSONResponse(respBody)), resp.StatusCode, nil
}
@@ -2388,6 +2396,32 @@ func isBinaryResponseContentType(ct string) bool {
}
return true
}
+{{- if .HasXMLResponse}}
+
+func isXMLRequest(accept string) bool {
+ for value := range strings.SplitSeq(accept, ",") {
+ mt := strings.ToLower(strings.TrimSpace(strings.SplitN(value, ";", 2)[0]))
+ if mt == "application/xml" || mt == "text/xml" || (strings.HasSuffix(mt, "+xml") && mt != "application/xhtml+xml") {
+ return true
+ }
+ }
+ return false
+}
+
+// isXMLResponseContentType reports whether a success response should be
+// normalized from XML to JSON. application/xhtml+xml is excluded: it is
+// HTML-shaped and belongs to the html response path.
+func isXMLResponseContentType(ct string) bool {
+ mt := strings.ToLower(strings.TrimSpace(ct))
+ if i := strings.IndexByte(mt, ';'); i >= 0 {
+ mt = strings.TrimSpace(mt[:i])
+ }
+ if mt == "" || mt == "application/xhtml+xml" {
+ return false
+ }
+ return mt == "application/xml" || mt == "text/xml" || strings.HasSuffix(mt, "+xml")
+}
+{{- end}}
// wrapBinaryResponse marshals body into a self-describing base64 envelope.
func wrapBinaryResponse(ct string, body []byte) (json.RawMessage, error) {
diff --git a/internal/generator/templates/cliutil_xml_parse.go.tmpl b/internal/generator/templates/cliutil_xml_parse.go.tmpl
new file mode 100644
index 000000000..9e4b54a91
--- /dev/null
+++ b/internal/generator/templates/cliutil_xml_parse.go.tmpl
@@ -0,0 +1,127 @@
+// Copyright {{currentYear}} {{copyrightHolder}}. Licensed under Apache-2.0. See LICENSE.
+// Generated by CLI Printing Press (https://github.com/mvanhorn/cli-printing-press). DO NOT EDIT.
+
+package cliutil
+
+import (
+ "bytes"
+ "encoding/json"
+ "encoding/xml"
+ "errors"
+ "io"
+ "strings"
+)
+
+// XMLToJSON normalizes an XML response body into a generic JSON document so
+// every downstream consumer (--json, --select, table output, MCP tools) treats
+// it like any JSON API. The mapping is BadgerFish-lite:
+//
+// - the root element name becomes the single top-level key
+// - attributes become "@name" string keys
+// - element text becomes the element's string value, or "#text" when the
+// element also carries attributes or child elements
+// - repeated sibling elements collapse into a JSON array
+//
+// On any decode failure the original bytes are returned unchanged, so a body
+// is never corrupted — callers can still inspect the raw XML.
+func XMLToJSON(raw json.RawMessage) json.RawMessage {
+ dec := xml.NewDecoder(bytes.NewReader(raw))
+ dec.Strict = false
+ dec.CharsetReader = xmlCharsetReader
+
+ for {
+ tok, err := dec.Token()
+ if err != nil {
+ return raw
+ }
+ start, ok := tok.(xml.StartElement)
+ if !ok {
+ continue
+ }
+ value, err := decodeXMLElement(dec, start)
+ if err != nil {
+ return raw
+ }
+ out, err := json.Marshal(map[string]any{start.Name.Local: value})
+ if err != nil {
+ return raw
+ }
+ return json.RawMessage(out)
+ }
+}
+
+// decodeXMLElement consumes tokens through the end of start and returns its
+// value: a plain string for a text-only element, or a map for an element with
+// attributes and/or child elements.
+func decodeXMLElement(dec *xml.Decoder, start xml.StartElement) (any, error) {
+ attrs := make(map[string]any, len(start.Attr))
+ for _, attr := range start.Attr {
+ attrs["@"+attr.Name.Local] = attr.Value
+ }
+
+ children := map[string][]any{}
+ childOrder := []string{}
+ var text strings.Builder
+
+ for {
+ tok, err := dec.Token()
+ if err != nil {
+ return nil, err
+ }
+ switch t := tok.(type) {
+ case xml.StartElement:
+ child, err := decodeXMLElement(dec, t)
+ if err != nil {
+ return nil, err
+ }
+ key := t.Name.Local
+ if _, seen := children[key]; !seen {
+ childOrder = append(childOrder, key)
+ }
+ children[key] = append(children[key], child)
+ case xml.CharData:
+ text.Write(t)
+ case xml.EndElement:
+ return assembleXMLValue(attrs, children, childOrder, strings.TrimSpace(text.String())), nil
+ }
+ }
+}
+
+// assembleXMLValue collapses a decoded element into its final JSON value. A
+// bare text element returns its string; otherwise it returns a map merging
+// attributes, children (single child → scalar, repeated → array), and any
+// non-empty text under "#text".
+func assembleXMLValue(attrs map[string]any, children map[string][]any, childOrder []string, text string) any {
+ if len(attrs) == 0 && len(children) == 0 {
+ return text
+ }
+ obj := make(map[string]any, len(attrs)+len(children)+1)
+ for k, v := range attrs {
+ obj[k] = v
+ }
+ for _, key := range childOrder {
+ vals := children[key]
+ if len(vals) == 1 {
+ obj[key] = vals[0]
+ } else {
+ obj[key] = vals
+ }
+ }
+ if text != "" {
+ obj["#text"] = text
+ }
+ return obj
+}
+
+// xmlCharsetReader keeps the decoder dependency-free: UTF-8, ASCII, and an
+// absent charset are read as-is. Any other declared charset returns an error,
+// which XMLToJSON turns into a graceful raw-bytes pass-through rather than a
+// corrupted decode.
+func xmlCharsetReader(charset string, input io.Reader) (io.Reader, error) {
+ switch strings.ToLower(strings.TrimSpace(charset)) {
+ case "", "utf-8", "utf8", "us-ascii", "ascii":
+ return input, nil
+ default:
+ return nil, errors.New("unsupported XML charset: " + charset)
+ }
+}
diff --git a/internal/generator/xml_response_test.go b/internal/generator/xml_response_test.go
new file mode 100644
index 000000000..ee90ac10d
--- /dev/null
+++ b/internal/generator/xml_response_test.go
@@ -0,0 +1,144 @@
+package generator
+
+import (
+ "os"
+ "path/filepath"
+ "testing"
+
+ "github.com/mvanhorn/cli-printing-press/v4/internal/spec"
+ "github.com/stretchr/testify/require"
+)
+
+func TestGenerateXMLResponseParseHelper(t *testing.T) {
+ t.Parallel()
+
+ apiSpec := minimalSpec("xml-response")
+ apiSpec.Resources["things"] = spec.Resource{
+ Description: "Things",
+ Endpoints: map[string]spec.Endpoint{
+ "get": {
+ Method: "GET",
+ Path: "/thing/{id}",
+ Description: "Get a thing",
+ ResponseFormat: spec.ResponseFormatXML,
+ },
+ },
+ }
+
+ outputDir := filepath.Join(t.TempDir(), "xml-response-pp-cli")
+ require.NoError(t, New(apiSpec, outputDir).Generate())
+ requireGeneratedCompiles(t, outputDir)
+
+ helper, err := os.ReadFile(filepath.Join(outputDir, "internal", "cliutil", "xml_parse.go"))
+ require.NoError(t, err)
+ require.Contains(t, string(helper), `func XMLToJSON(raw json.RawMessage) json.RawMessage`)
+
+ testSrc := []byte(`package cliutil
+
+import (
+ "encoding/json"
+ "reflect"
+ "testing"
+)
+
+func decode(t *testing.T, in string) map[string]any {
+ t.Helper()
+ out := XMLToJSON(json.RawMessage(in))
+ var got map[string]any
+ if err := json.Unmarshal(out, &got); err != nil {
+ t.Fatalf("result is not valid JSON: %v (%s)", err, string(out))
+ }
+ return got
+}
+
+func TestXMLToJSONAttributesAndNesting(t *testing.T) {
+ got := decode(t, ` + "`" + `