fix: prevent silent exits on error (#1139) and fix whiteboard API encoding (#1155)

cmd/root.go

@@ -214,7 +214,15 @@ func configureFlagCompletions(args []string) {
 //     per-domain typed migration in stage 2+.
 //  4. Cobra errors (required flags, unknown commands, etc.): plain text.
 func handleRootError(f *cmdutil.Factory, err error) int {
-	errOut := f.IOStreams.ErrOut
+	// Defensive: f or its IOStreams may be nil in exceptional situations
+	// (e.g. early bootstrap failure, plugin corruption). Guarantee stderr
+	// is always a valid writer so diagnostics are never swallowed.
+	var errOut io.Writer
+	if f != nil && f.IOStreams != nil && f.IOStreams.ErrOut != nil {
+		errOut = f.IOStreams.ErrOut
+	} else {
+		errOut = os.Stderr
+	}
 
 	// SecurityPolicyError keeps the legacy custom envelope (string codes,
 	// challenge_url, retryable) and exit code 1 — its wire shape predates the

internal/client/encoding.go

@@ -0,0 +1,46 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package client
+
+import (
+	"bytes"
+	"unicode/utf8"
+
+	"golang.org/x/text/encoding"
+	"golang.org/x/text/encoding/simplifiedchinese"
+	"golang.org/x/text/encoding/unicode"
+)
+
+// autoDecodeBody attempts to detect and convert non-UTF-8 response bodies to
+// valid UTF-8. Some Lark APIs (e.g. whiteboard) occasionally return JSON with
+// Chinese characters in encodings other than UTF-8 despite the Content-Type
+// header claiming otherwise. See https://github.com/larksuite/cli/issues/1155
+func autoDecodeBody(body []byte) []byte {
+	// Fast path: already valid UTF-8 (common case).
+	if utf8.Valid(body) {
+		return body
+	}
+
+	// Strip UTF-8 BOM if present.
+	body = bytes.TrimPrefix(body, unicode.UTF8BOM)
+
+	// Try encodings in order of likelihood for Lark/Feishu APIs.
+	candidates := []struct {
+		enc encoding.Encoding
+		name string
+	}{
+		{simplifiedchinese.GBK, "GBK"},
+		{simplifiedchinese.GB18030, "GB18030"},
+		{simplifiedchinese.HZGB2312, "HZ-GB2312"},
+	}
+
+	for _, c := range candidates {
+		if decoded, err := c.enc.NewDecoder().Bytes(body); err == nil && utf8.Valid(decoded) {
+			return decoded
+		}
+	}
+
+	// Return original unchanged if no conversion succeeded.
+	return body
+}

internal/client/response.go

@@ -136,12 +136,15 @@ func IsJSONContentType(ct string) bool {
 
 // ParseJSONResponse decodes a raw SDK response body as JSON.
 // CallAPI and HandleResponse both delegate to this function.
+// It automatically detects and converts non-UTF-8 encodings (e.g. GBK) that
+// some APIs return despite claiming UTF-8 in the Content-Type header.
 func ParseJSONResponse(resp *larkcore.ApiResp) (interface{}, error) {
+	body := autoDecodeBody(resp.RawBody)
 	var result interface{}
-	dec := json.NewDecoder(bytes.NewReader(resp.RawBody))
+	dec := json.NewDecoder(bytes.NewReader(body))
 	dec.UseNumber()
 	if err := dec.Decode(&result); err != nil {
-		return nil, fmt.Errorf("response parse error: %w (body: %s)", err, util.TruncateStr(string(resp.RawBody), 500))
+		return nil, fmt.Errorf("response parse error: %w (body: %s)", err, util.TruncateStr(string(body), 500))
 	}
 	return result, nil
 }

internal/output/errors.go

@@ -72,6 +72,13 @@ func MarkRaw(err error) error {
 // to the typed surface.
 func WriteErrorEnvelope(w io.Writer, err *ExitError, identity string) {
 	if err.Detail == nil {
+		// Even without structured detail, emit a minimal envelope so callers
+		// never see a completely empty stderr (https://github.com/larksuite/cli/issues/1139).
+		msg := err.Error()
+		if msg == "" {
+			msg = fmt.Sprintf("exit %d", err.Code)
+		}
+		fmt.Fprintf(w, `{"ok":false,"identity":%q,"error":{"type":"internal","message":%q}}`+"\n", identity, msg)
 		return
 	}
 	env := &ErrorEnvelope{

main.go

@@ -5,13 +5,25 @@
 package main
 
 import (
+	"fmt"
 	"os"
+	"runtime/debug"
 
 	"github.com/larksuite/cli/cmd"
 
 	_ "github.com/larksuite/cli/extension/credential/env" // activate env credential provider
 )
 
 func main() {
+	// Recover from any unhandled panics to ensure stderr always receives
+	// diagnostics instead of crashing silently (especially in automation/
+	// CI contexts where a panic without stack trace looks like exit 1 with
+	// empty stdout/stderr). See https://github.com/larksuite/cli/issues/1139
+	defer func() {
+		if r := recover(); r != nil {
+			fmt.Fprintf(os.Stderr, "panic: %v\n%s\n", r, debug.Stack())
+			os.Exit(1)
+		}
+	}()
 	os.Exit(cmd.Execute())
 }