feat: unify output surface contract for flags, formats and errors

Consolidate the CLI output/error contract so agents can predict behavior
from a command's declaration:

- --json / --format resolved through a single FormatCapabilities set;
  explicit --format wins over --json across api, service, shortcut and
  auth scopes
- --format pretty renders as indented JSON via its own Format case,
  no longer aliased to table
- a single root FlagErrorFunc classifies pflag typed errors; the mail
  and sheets local FlagErrorFunc hooks are removed
- cobra argument, required-flag and flag-group errors are typed at their
  validation stage; the usage-error text markers are removed
- root and group unknown commands return structured suggestions
- manifest-export marks pure group nodes as non-runnable

.github/workflows/ci.yml

@@ -47,34 +47,6 @@ jobs:
             exit 1
           fi
 
-  plugin-integration:
-    needs: fast-gate
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5
-        with:
-          persist-credentials: false
-      - uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6
-        with:
-          go-version-file: go.mod
-      # No fetch_meta: the git-archive clean tree must embed only the
-      # committed meta_data stub (reproduces the bare-module customer state).
-      - name: Run plugin-integration L4 tests
-        run: go test -count=1 -timeout=15m ./tests/plugin_e2e/...
-
-  sidecar-integration:
-    needs: fast-gate
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5
-        with:
-          persist-credentials: false
-      - uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6
-        with:
-          go-version-file: go.mod
-      - name: Run sidecar tag build + HMAC round-trip
-        run: make sidecar-test
-
   # ── Layer 2: Quality Gate ──────────────────────────────────────────
   unit-test:
     needs: fast-gate
@@ -204,11 +176,7 @@ jobs:
         run: python3 scripts/fetch_meta.py
       - name: Run tests with coverage
         run: |
-          # tests/ holds only L3/L4 suites (cli_e2e, plugin_e2e, sidecar_e2e) that
-          # have dedicated jobs; exclude the whole subtree so none of them runs a
-          # second time here — and, crucially, so an observe-only suite's failure
-          # can never block merges through coverage's spot in the results loop.
-          packages=$(go list ./... | grep -v '^github.com/larksuite/cli/tests/')
+          packages=$(go list ./... | grep -v '^github.com/larksuite/cli/tests/cli_e2e$' | grep -v '^github.com/larksuite/cli/tests/cli_e2e/')
           go test -race -coverprofile=coverage.txt -covermode=atomic $packages
       - name: Upload coverage to Codecov
         if: ${{ github.event_name != 'pull_request' || !github.event.pull_request.head.repo.fork }}
@@ -448,7 +416,7 @@ jobs:
   # ── Results Gate (single required check for branch protection) ─────
   results:
     if: ${{ always() }}
-    needs: [fast-gate, unit-test, lint, script-test, deterministic-gate, coverage, deadcode, e2e-dry-run, e2e-live, security, license-header, plugin-integration, sidecar-integration]
+    needs: [fast-gate, unit-test, lint, script-test, deterministic-gate, coverage, deadcode, e2e-dry-run, e2e-live, security, license-header]
     runs-on: ubuntu-latest
     steps:
       - name: Evaluate results
@@ -468,19 +436,10 @@ jobs:
           echo "| L3 | e2e-live | ${{ needs.e2e-live.result }} |" >> $GITHUB_STEP_SUMMARY
           echo "| L4 | security | ${{ needs.security.result }} |" >> $GITHUB_STEP_SUMMARY
           echo "| L4 | license-header | ${{ needs.license-header.result }} |" >> $GITHUB_STEP_SUMMARY
-          echo "| L4 | plugin-integration (observe-only) | ${{ needs.plugin-integration.result }} |" >> $GITHUB_STEP_SUMMARY
-          echo "| L4 | sidecar-integration (observe-only) | ${{ needs.sidecar-integration.result }} |" >> $GITHUB_STEP_SUMMARY
 
           # Any failure or cancellation in any job blocks the merge.
           # Legitimately skipped jobs (deadcode on push, e2e-live on fork,
           # license-header on push) are OK.
-          #
-          # plugin-integration and sidecar-integration are intentionally NOT
-          # in this loop yet: they run on every PR and their status is shown
-          # in the table above, but a failure is observe-only (non-blocking)
-          # during the initial soak. Graduation to required is tracked in
-          # https://github.com/larksuite/cli/issues/1894 (criteria: 4
-          # consecutive weeks with zero false positives).
           FAILED=0
           for result in \
             "${{ needs.fast-gate.result }}" \

CHANGELOG.md

@@ -2,64 +2,6 @@
 
 All notable changes to this project will be documented in this file.
 
-## [v1.0.71] - 2026-07-16
-
-### Features
-
-- add wiki move-to-drive shortcut (#1869)
-- **apps**: add role management shortcuts (#1881)
-- **drive**: add secure label support and clarify comment location API (#1913)
-
-### Bug Fixes
-
-- **base**: improve dashboard shortcut guidance (#1787)
-
-### Documentation
-
-- **apps**: add platform SQL authoring guide to the db-execute skill (#1912)
-
-### Misc
-
-- add L4 plugin-integration and sidecar-integration CI jobs (#1840)
-- **drive**: optimize drive +delete workflow (#1909)
-
-## [v1.0.70] - 2026-07-15
-
-### Features
-
-- add minutes permission application shortcut (#1876)
-- **drive**: support apps in list comments (#1877)
-- slide style
-- edit ppt template
-- **slides**: add sxsd validation to slides lint
-- **slides**: validate iconpark icon types in slides lint
-- **slides**: lint before create
-- **apps**: add automation trigger commands for Miaoda (#1886)
-
-### Bug Fixes
-
-- unify dry-run output contract (#1870)
-- **skills**: align skill guidance with the typed error contract (#1786)
-- **slides**: limit slides screenshot page requests
-- **slides**: detect lark slides text overflow overlap
-- **vc**: align meeting query scopes by identity (#1850)
-
-### Documentation
-
-- clarify task search relevance filters (#1884)
-- surface minutes permission application in skill description (#1890)
-- clarify okr progress children (#1861)
-- **slides**: prefer slides xml-get shortcut
-- **calendar**: document setting meeting owner via full API (#1903)
-
-### Refactoring
-
-- **slides**: streamline create workflow and validate SML namespaces
-
-### Misc
-
-- **slides**: address PR review feedback
-
 ## [v1.0.69] - 2026-07-13
 
 ### Features
@@ -1527,8 +1469,6 @@ Bundled AI agent skills for intelligent assistance:
 - Bilingual documentation (English & Chinese).
 - CI/CD pipelines: linting, testing, coverage reporting, and automated releases.
 
-[v1.0.71]: https://github.com/larksuite/cli/releases/tag/v1.0.71
-[v1.0.70]: https://github.com/larksuite/cli/releases/tag/v1.0.70
 [v1.0.69]: https://github.com/larksuite/cli/releases/tag/v1.0.69
 [v1.0.68]: https://github.com/larksuite/cli/releases/tag/v1.0.68
 [v1.0.67]: https://github.com/larksuite/cli/releases/tag/v1.0.67

Makefile

@@ -23,7 +23,7 @@ PREFIX   ?= /usr/local
 TEST_GOARCH := $(or $(GOARCH),$(shell go env GOARCH))
 RACE_FLAG := $(if $(filter riscv64,$(TEST_GOARCH)),,-race)
 
-.PHONY: all build vet fmt-check script-test test unit-test integration-test examples-build quality-gate install uninstall clean fetch_meta gitleaks sidecar-test
+.PHONY: all build vet fmt-check script-test test unit-test integration-test examples-build quality-gate install uninstall clean fetch_meta gitleaks
 
 all: test
 
@@ -64,9 +64,6 @@ examples-build:
 	go build ./extension/platform/examples/audit-observer
 	go build ./extension/platform/examples/readonly-policy
 
-# ./tests/... includes tests/plugin_e2e, which builds ~20 customer-fork
-# binaries (~1 min warm; a cold module cache also downloads via GOPROXY).
-# Deliberate: local `make test` exercises the L4 plugin contract by default.
 integration-test: build
 	go test -v -count=1 ./tests/...
 
@@ -108,14 +105,6 @@ uninstall:
 clean:
 	rm -f $(BINARY)
 
-# sidecar-test compiles and runs the authsidecar* build-tagged code that the
-# default CI matrix never sees (they carry //go:build tags).
-sidecar-test:
-	go build -tags authsidecar -o /dev/null .
-	go test $(RACE_FLAG) -count=1 -tags authsidecar ./extension/credential/sidecar/ ./extension/transport/sidecar/ ./internal/cmdutil/
-	go test $(RACE_FLAG) -count=1 -tags authsidecar_demo ./sidecar/server-demo/
-	go test $(RACE_FLAG) -count=1 -tags authsidecar ./tests/sidecar_e2e/
-
 # Run secret-leak checks locally before pushing.
 # Step 1: check-doc-tokens catches realistic-looking example tokens in reference
 #         docs and asks you to use _EXAMPLE_TOKEN placeholders instead.

cmd/api/api.go

@@ -40,6 +40,7 @@ type APIOptions struct {
 	PageLimit int
 	PageDelay int
 	Format    string
+	JSON      bool
 	JqExpr    string
 	DryRun    bool
 	File      string
@@ -88,6 +89,11 @@ Examples:
 			opts.Cmd = cmd
 			opts.Ctx = cmd.Context()
 			opts.As = core.Identity(asStr)
+			format, err := output.StandardFormats.Resolve(opts.Format, cmd.Flags().Changed("format"), opts.JSON)
+			if err != nil {
+				return err
+			}
+			opts.Format = format
 			if runF != nil {
 				return runF(opts)
 			}
@@ -103,8 +109,8 @@ Examples:
 	cmd.Flags().IntVar(&opts.PageSize, "page-size", 0, "page size (0 = use API default)")
 	cmd.Flags().IntVar(&opts.PageLimit, "page-limit", 10, "max pages to fetch with --page-all (0 = unlimited)")
 	cmd.Flags().IntVar(&opts.PageDelay, "page-delay", 200, "delay in ms between pages")
-	cmd.Flags().StringVar(&opts.Format, "format", "json", "output format: json|ndjson|table|csv")
-	cmd.Flags().Bool("json", false, "shorthand for --format json")
+	cmd.Flags().StringVar(&opts.Format, "format", "json", output.StandardFormats.Usage())
+	cmd.Flags().BoolVar(&opts.JSON, "json", false, "shorthand for --format json")
 	cmd.Flags().StringVarP(&opts.JqExpr, "jq", "q", "", "jq expression to filter JSON output")
 	cmd.Flags().BoolVar(&opts.DryRun, "dry-run", false, "print request without executing")
 	cmd.Flags().StringVar(&opts.File, "file", "", "file to upload as multipart/form-data ([field=]path, supports - for stdin)")
@@ -116,7 +122,7 @@ Examples:
 		return nil, cobra.ShellCompDirectiveNoFileComp
 	}
 	cmdutil.RegisterFlagCompletion(cmd, "format", func(_ *cobra.Command, _ []string, _ string) ([]string, cobra.ShellCompDirective) {
-		return []string{"json", "ndjson", "table", "csv"}, cobra.ShellCompDirectiveNoFileComp
+		return output.StandardFormats.Names(), cobra.ShellCompDirectiveNoFileComp
 	})
 	cmdutil.SetRisk(cmd, "write")
 
@@ -263,10 +269,7 @@ func apiRun(opts *APIOptions) error {
 	}
 
 	out := f.IOStreams.Out
-	format, formatOK := output.ParseFormat(opts.Format)
-	if !formatOK {
-		fmt.Fprintf(f.IOStreams.ErrOut, "warning: unknown format %q, falling back to json\n", opts.Format)
-	}
+	format, _ := output.ParseFormat(opts.Format)
 
 	if opts.PageAll {
 		return apiPaginate(opts.Ctx, ac, request, format, opts.JqExpr, out, f.IOStreams.ErrOut, opts.Cmd.CommandPath(),
@@ -343,6 +346,24 @@ func apiPaginate(ctx context.Context, ac *client.APIClient, request client.RawAp
 	}
 
 	switch format {
+	case output.FormatPretty:
+		result, err := ac.PaginateAll(ctx, request, pagOpts)
+		if err != nil {
+			return errs.MarkRaw(err)
+		}
+		if apiErr := ac.CheckResponse(result, pagOpts.Identity); apiErr != nil {
+			output.FormatValue(out, result, output.FormatPretty)
+			return errs.MarkRaw(apiErr)
+		}
+		scanResult := output.ScanForSafety(commandPath, result, errOut)
+		if scanResult.Blocked {
+			return errs.MarkRaw(scanResult.BlockErr)
+		}
+		if scanResult.Alert != nil {
+			output.WriteAlertWarning(errOut, scanResult.Alert)
+		}
+		output.FormatValue(out, result, output.FormatPretty)
+		return nil
 	case output.FormatNDJSON, output.FormatTable, output.FormatCSV:
 		pf := output.NewPaginatedFormatter(out, format)
 		result, hasItems, err := ac.StreamPages(ctx, request, func(items []interface{}) error {

cmd/api/api_test.go

@@ -68,6 +68,42 @@ func TestApiCmd_FlagParsing(t *testing.T) {
 	}
 }
 
+func TestApiCmd_OutputFormatResolution(t *testing.T) {
+	tests := []struct {
+		name string
+		args []string
+		want string
+	}{
+		{name: "json shorthand", args: []string{"--json"}, want: "json"},
+		{name: "explicit format wins", args: []string{"--format", "table", "--json"}, want: "table"},
+		{name: "pretty format", args: []string{"--format", "PRETTY"}, want: "pretty"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			f, _, _, _ := cmdutil.TestFactory(t, &core.CliConfig{
+				AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
+			})
+			var gotOpts *APIOptions
+			cmd := newTestApiCmd(f, func(opts *APIOptions) error {
+				gotOpts = opts
+				return nil
+			})
+			args := []string{"GET", "/open-apis/test", "--as", "bot"}
+			cmd.SetArgs(append(args, tt.args...))
+			if err := cmd.Execute(); err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
+			if gotOpts == nil {
+				t.Fatal("expected options to be captured")
+			}
+			if gotOpts.Format != tt.want {
+				t.Fatalf("format = %q, want %q", gotOpts.Format, tt.want)
+			}
+		})
+	}
+}
+
 func TestApiCmd_DryRun(t *testing.T) {
 	f, stdout, stderr, _ := cmdutil.TestFactory(t, &core.CliConfig{
 		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
@@ -169,6 +205,43 @@ func TestApiCmd_BotMode(t *testing.T) {
 	}
 }
 
+func TestApiCmd_PrettyFormatsRealResponse(t *testing.T) {
+	f, stdout, _, reg := cmdutil.TestFactory(t, &core.CliConfig{
+		AppID: "test-app-pretty", AppSecret: "test-secret", Brand: core.BrandFeishu,
+	})
+	reg.Register(&httpmock.Stub{
+		URL: "/open-apis/test",
+		Body: map[string]interface{}{
+			"code": 0,
+			"data": map[string]interface{}{
+				"items": []interface{}{map[string]interface{}{"name": "Alice"}},
+			},
+		},
+	})
+
+	cmd := newTestApiCmd(f, nil)
+	cmd.SetArgs([]string{"GET", "/open-apis/test", "--as", "bot", "--format", "pretty"})
+	if err := cmd.Execute(); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	out := stdout.String()
+	var got map[string]interface{}
+	if err := json.Unmarshal(stdout.Bytes(), &got); err != nil {
+		t.Fatalf("pretty output should be valid JSON: %v\n%s", err, out)
+	}
+	data, ok := got["data"].(map[string]interface{})
+	if !ok {
+		t.Fatalf("pretty output data = %#v", got["data"])
+	}
+	items, ok := data["items"].([]interface{})
+	if !ok || len(items) != 1 {
+		t.Fatalf("pretty output data.items = %#v", data["items"])
+	}
+	if !strings.Contains(out, "\n  \"data\": {") || strings.Contains(out, "─") {
+		t.Fatalf("pretty output should be indented JSON rather than a table, got:\n%s", out)
+	}
+}
+
 func TestApiCmd_MissingArgs(t *testing.T) {
 	f, _, _, _ := cmdutil.TestFactory(t, &core.CliConfig{
 		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
@@ -571,6 +644,46 @@ func TestApiCmd_PageAll_BatchAPI_DefaultJSONEnvelope(t *testing.T) {
 	}
 }
 
+func TestApiCmd_PageAll_PrettyAggregatesIndentedJSON(t *testing.T) {
+	f, stdout, _, reg := cmdutil.TestFactory(t, &core.CliConfig{
+		AppID: "test-app-pageall-pretty", AppSecret: "test-secret", Brand: core.BrandFeishu,
+	})
+
+	reg.Register(&httpmock.Stub{
+		URL: "/open-apis/contact/v3/users",
+		Body: map[string]interface{}{
+			"code": 0, "msg": "ok",
+			"data": map[string]interface{}{
+				"items":    []interface{}{map[string]interface{}{"id": "1"}},
+				"has_more": false,
+			},
+		},
+	})
+
+	cmd := newTestApiCmd(f, nil)
+	cmd.SetArgs([]string{"GET", "/open-apis/contact/v3/users", "--as", "bot", "--page-all", "--format", "pretty"})
+	if err := cmd.Execute(); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	out := stdout.String()
+	var got map[string]interface{}
+	if err := json.Unmarshal(stdout.Bytes(), &got); err != nil {
+		t.Fatalf("page-all pretty output should be valid JSON: %v\n%s", err, out)
+	}
+	data, ok := got["data"].(map[string]interface{})
+	if !ok {
+		t.Fatalf("page-all pretty output data = %#v", got["data"])
+	}
+	items, ok := data["items"].([]interface{})
+	if !ok || len(items) != 1 {
+		t.Fatalf("page-all pretty output data.items = %#v", data["items"])
+	}
+	if !strings.Contains(out, "\n  \"data\": {") || strings.Contains(out, "─") {
+		t.Fatalf("page-all pretty output should be aggregated indented JSON, got:\n%s", out)
+	}
+}
+
 type apiContentSafetyProvider struct {
 	called bool
 	path   string

cmd/auth/auth_test.go

@@ -355,7 +355,31 @@ func TestAuthScopesCmd_FlagParsing(t *testing.T) {
 	}
 }
 
-func TestAuthScopesCmd_JSONFlagForcesJSONFormat(t *testing.T) {
+func TestAuthScopesCmd_JSONShorthand(t *testing.T) {
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
+	f, _, _, _ := cmdutil.TestFactory(t, &core.CliConfig{
+		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
+	})
+
+	var gotOpts *ScopesOptions
+	cmd := NewCmdAuthScopes(f, func(opts *ScopesOptions) error {
+		gotOpts = opts
+		return nil
+	})
+	cmd.SetArgs([]string{"--json"})
+	if err := cmd.Execute(); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if gotOpts == nil {
+		t.Fatal("expected options to be captured")
+	}
+	if !gotOpts.JSON || gotOpts.Format != "json" {
+		t.Fatalf("JSON = %v, format = %q; want true, json", gotOpts.JSON, gotOpts.Format)
+	}
+}
+
+func TestAuthScopesCmd_ExplicitFormatWinsOverJSONShorthand(t *testing.T) {
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
 	f, _, _, _ := cmdutil.TestFactory(t, &core.CliConfig{
 		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
 	})
@@ -376,8 +400,8 @@ func TestAuthScopesCmd_JSONFlagForcesJSONFormat(t *testing.T) {
 	if !gotOpts.JSON {
 		t.Error("expected JSON=true")
 	}
-	if gotOpts.Format != "json" {
-		t.Errorf("expected format json, got %s", gotOpts.Format)
+	if gotOpts.Format != "pretty" {
+		t.Errorf("expected explicit format pretty, got %s", gotOpts.Format)
 	}
 }
 

cmd/auth/scopes.go

@@ -31,9 +31,11 @@ func NewCmdAuthScopes(f *cmdutil.Factory, runF func(*ScopesOptions) error) *cobr
 		Short: "Query scopes enabled for the app",
 		RunE: func(cmd *cobra.Command, args []string) error {
 			opts.Ctx = cmd.Context()
-			if opts.JSON {
-				opts.Format = "json"
+			format, err := output.JSONPrettyFormats.Resolve(opts.Format, cmd.Flags().Changed("format"), opts.JSON)
+			if err != nil {
+				return err
 			}
+			opts.Format = format
 			if runF != nil {
 				return runF(opts)
 			}
@@ -41,8 +43,11 @@ func NewCmdAuthScopes(f *cmdutil.Factory, runF func(*ScopesOptions) error) *cobr
 		},
 	}
 
-	cmd.Flags().StringVar(&opts.Format, "format", "json", "output format: json (default) | pretty")
-	cmd.Flags().BoolVar(&opts.JSON, "json", false, "structured JSON output")
+	cmd.Flags().StringVar(&opts.Format, "format", "json", output.JSONPrettyFormats.Usage())
+	cmd.Flags().BoolVar(&opts.JSON, "json", false, "shorthand for --format json")
+	cmdutil.RegisterFlagCompletion(cmd, "format", func(_ *cobra.Command, _ []string, _ string) ([]string, cobra.ShellCompDirective) {
+		return output.JSONPrettyFormats.Names(), cobra.ShellCompDirectiveNoFileComp
+	})
 	cmdutil.SetRisk(cmd, "read")
 
 	return cmd
@@ -75,10 +80,10 @@ func authScopesRun(opts *ScopesOptions) error {
 			"failed to get app scope info: %v", err).WithCause(err)
 	}
 	if opts.Format == "pretty" {
-		fmt.Fprintf(f.IOStreams.ErrOut, "App ID: %s\n", config.AppID)
-		fmt.Fprintf(f.IOStreams.ErrOut, "Enabled scopes (%d):\n\n", len(appInfo.UserScopes))
+		fmt.Fprintf(f.IOStreams.Out, "App ID: %s\n", config.AppID)
+		fmt.Fprintf(f.IOStreams.Out, "Enabled scopes (%d):\n\n", len(appInfo.UserScopes))
 		for _, s := range appInfo.UserScopes {
-			fmt.Fprintf(f.IOStreams.ErrOut, "  • %s\n", s)
+			fmt.Fprintf(f.IOStreams.Out, "  • %s\n", s)
 		}
 	} else {
 		output.PrintJson(f.IOStreams.Out, map[string]interface{}{

cmd/auth/scopes_test.go

@@ -4,9 +4,11 @@
 package auth
 
 import (
+	"bytes"
 	"context"
 	"errors"
 	"fmt"
+	"strings"
 	"testing"
 
 	"github.com/larksuite/cli/errs"
@@ -26,6 +28,35 @@ func stubGetAppInfoErr(t *testing.T, errToReturn error) {
 	t.Cleanup(func() { getAppInfoFn = prev })
 }
 
+func TestAuthScopesRun_PrettyWritesBulletedScopesToStdout(t *testing.T) {
+	prev := getAppInfoFn
+	getAppInfoFn = func(ctx context.Context, f *cmdutil.Factory, appId string) (*appInfo, error) {
+		return &appInfo{UserScopes: []string{"im:message"}}, nil
+	}
+	t.Cleanup(func() { getAppInfoFn = prev })
+
+	opts := scopesTestFactory(t)
+	opts.Format = "pretty"
+	out, ok := opts.Factory.IOStreams.Out.(*bytes.Buffer)
+	if !ok {
+		t.Fatalf("stdout type = %T, want *bytes.Buffer", opts.Factory.IOStreams.Out)
+	}
+	errOut, ok := opts.Factory.IOStreams.ErrOut.(*bytes.Buffer)
+	if !ok {
+		t.Fatalf("stderr type = %T, want *bytes.Buffer", opts.Factory.IOStreams.ErrOut)
+	}
+
+	if err := authScopesRun(opts); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if !strings.Contains(out.String(), "  • im:message\n") {
+		t.Fatalf("stdout missing bulleted scope: %q", out.String())
+	}
+	if strings.Contains(errOut.String(), "im:message") {
+		t.Fatalf("scope should remain on stdout, stderr = %q", errOut.String())
+	}
+}
+
 // scopesTestFactory builds a Factory + ScopesOptions pair sufficient to drive
 // authScopesRun. Config has a non-empty AppID so we get past the config gate
 // and reach the getAppInfoFn call.

cmd/build.go

@@ -234,6 +234,7 @@ func buildInternal(ctx context.Context, inv cmdutil.InvocationContext, opts ...B
 	groupRootCommands(rootCmd)
 
 	installUnknownSubcommandGuard(rootCmd)
+	installCobraValidationGuards(rootCmd)
 	// Bare `lark-cli` in an interactive terminal offers an interactive upgrade
 	// before printing help; non-bare invocations and non-TTY are unaffected.
 	installRootUpgradePrompt(f, rootCmd)

cmd/build_test.go

@@ -4,11 +4,15 @@
 package cmd
 
 import (
+	"bytes"
 	"context"
+	"errors"
 	"strings"
 	"testing"
 
+	"github.com/larksuite/cli/errs"
 	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/output"
 	"github.com/spf13/cobra"
 )
 
@@ -26,6 +30,85 @@ func TestBuildWithoutPluginsStillBuildsBuiltinCommands(t *testing.T) {
 	}
 }
 
+func buildValidationTestRoot(t *testing.T) *cobra.Command {
+	t.Helper()
+	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
+	return Build(context.Background(), cmdutil.InvocationContext{},
+		WithIO(strings.NewReader(""), &bytes.Buffer{}, &bytes.Buffer{}),
+		WithoutPlugins(),
+		WithoutServiceCommands(),
+		WithoutStrictMode(),
+	)
+}
+
+func TestBuiltRoot_TopLevelTypoReturnsStructuredSuggestion(t *testing.T) {
+	root := buildValidationTestRoot(t)
+	root.SetArgs([]string{"imm"})
+
+	err := root.Execute()
+	var validationErr *errs.ValidationError
+	if !errors.As(err, &validationErr) {
+		t.Fatalf("expected *errs.ValidationError, got %T: %v", err, err)
+	}
+	if len(validationErr.Params) != 1 || validationErr.Params[0].Name != "imm" {
+		t.Fatalf("params = %v, want one entry named imm", validationErr.Params)
+	}
+	found := false
+	for _, candidate := range validationErr.Params[0].Suggestions {
+		if candidate == "im" {
+			found = true
+		}
+	}
+	if !found {
+		t.Fatalf("suggestions = %v, want im", validationErr.Params[0].Suggestions)
+	}
+}
+
+func TestBuiltRoot_SheetsOneRequiredGroupReturnsValidationExit(t *testing.T) {
+	root := buildValidationTestRoot(t)
+	root.SetArgs([]string{
+		"sheets", "+csv-put",
+		"--url", "https://example.com/sheets/token",
+		"--sheet-name", "Sheet1",
+		"--csv", "a,b",
+	})
+
+	err := root.Execute()
+	problem, ok := errs.ProblemOf(err)
+	if !ok {
+		t.Fatalf("expected typed problem, got %T: %v", err, err)
+	}
+	if problem.Category != errs.CategoryValidation || problem.Subtype != errs.SubtypeInvalidArgument {
+		t.Fatalf("problem = %s/%s, want validation/invalid_argument", problem.Category, problem.Subtype)
+	}
+	if got := output.ExitCodeOf(err); got != output.ExitValidation {
+		t.Fatalf("exit code = %d, want %d", got, output.ExitValidation)
+	}
+}
+
+func TestBuiltRoot_MailUnknownFlagUsesSharedSuggestions(t *testing.T) {
+	root := buildValidationTestRoot(t)
+	root.SetArgs([]string{"mail", "+send", "--tos", "alice@example.com"})
+
+	err := root.Execute()
+	var validationErr *errs.ValidationError
+	if !errors.As(err, &validationErr) {
+		t.Fatalf("expected *errs.ValidationError, got %T: %v", err, err)
+	}
+	if len(validationErr.Params) != 1 || validationErr.Params[0].Name != "--tos" {
+		t.Fatalf("params = %v, want one entry named --tos", validationErr.Params)
+	}
+	found := false
+	for _, candidate := range validationErr.Params[0].Suggestions {
+		if candidate == "--to" {
+			found = true
+		}
+	}
+	if !found {
+		t.Fatalf("suggestions = %v, want --to", validationErr.Params[0].Suggestions)
+	}
+}
+
 func findCommand(root *cobra.Command, path string) *cobra.Command {
 	parts := strings.Fields(path)
 	cmd := root

cmd/flag_suggest_test.go

@@ -9,28 +9,18 @@ import (
 	"testing"
 
 	"github.com/larksuite/cli/errs"
+	"github.com/larksuite/cli/internal/cmdmeta"
 	"github.com/larksuite/cli/internal/output"
 	"github.com/spf13/cobra"
 )
 
-func TestUnknownFlagName(t *testing.T) {
-	cases := []struct {
-		in   string
-		name string
-		ok   bool
-	}{
-		{"unknown flag: --query", "query", true},
-		{"unknown flag: --with-styles", "with-styles", true},
-		{"unknown shorthand flag: 'z' in -z", "", false},
-		{"flag needs an argument: --find", "", false},
-		{`invalid argument "x" for "--count"`, "", false},
-	}
-	for _, c := range cases {
-		name, ok := unknownFlagName(errors.New(c.in))
-		if name != c.name || ok != c.ok {
-			t.Errorf("unknownFlagName(%q) = (%q,%v), want (%q,%v)", c.in, name, ok, c.name, c.ok)
-		}
+func parseFlagError(t *testing.T, c *cobra.Command, args ...string) error {
+	t.Helper()
+	err := c.Flags().Parse(args)
+	if err == nil {
+		t.Fatalf("Parse(%v) returned nil", args)
 	}
+	return err
 }
 
 func TestFlagDidYouMean_UnknownFlagSuggestsAndListsValid(t *testing.T) {
@@ -39,7 +29,7 @@ func TestFlagDidYouMean_UnknownFlagSuggestsAndListsValid(t *testing.T) {
 	c.Flags().String("find", "", "")
 	c.Flags().Bool("dry-run", false, "")
 
-	err := flagDidYouMean(c, errors.New("unknown flag: --rang")) // typo of --range
+	err := flagDidYouMean(c, parseFlagError(t, c, "--rang")) // typo of --range
 	var verr *errs.ValidationError
 	if !errors.As(err, &verr) {
 		t.Fatalf("expected *errs.ValidationError, got %T", err)
@@ -82,23 +72,86 @@ func TestFlagDidYouMean_UnknownFlagSuggestsAndListsValid(t *testing.T) {
 
 func TestFlagDidYouMean_OtherErrorStaysGeneric(t *testing.T) {
 	c := &cobra.Command{Use: "demo"}
-	err := flagDidYouMean(c, errors.New("flag needs an argument: --find"))
+	c.Flags().String("find", "", "")
+	err := flagDidYouMean(c, parseFlagError(t, c, "--find"))
 	var verr *errs.ValidationError
 	if !errors.As(err, &verr) {
 		t.Fatalf("expected *errs.ValidationError, got %T", err)
 	}
-	// Non-unknown-flag errors stay generic: invalid_argument subtype, no
-	// structured param, generic --help hint (no "did you mean" suggestion).
+	// Non-unknown-flag errors retain the same validation shape and identify the
+	// flag from pflag's typed ValueRequiredError.
 	if verr.Subtype != errs.SubtypeInvalidArgument {
 		t.Errorf("subtype = %q, want invalid_argument (non-unknown-flag errors stay generic)", verr.Subtype)
 	}
 	if code := output.ExitCodeOf(err); code != output.ExitValidation {
 		t.Errorf("exit code = %d, want %d (ExitValidation)", code, output.ExitValidation)
 	}
-	if verr.Param != "" || len(verr.Params) != 0 {
-		t.Errorf("Param=%q Params=%v, want both empty for generic flag error", verr.Param, verr.Params)
+	if len(verr.Params) != 1 || verr.Params[0].Name != "--find" {
+		t.Errorf("Params=%v, want one entry named --find", verr.Params)
 	}
 	if strings.Contains(verr.Hint, "did you mean") {
 		t.Errorf("generic flag error must not produce a did-you-mean hint, got %q", verr.Hint)
 	}
 }
+
+func TestFlagDidYouMean_SheetsListsVisibleFlags(t *testing.T) {
+	root := &cobra.Command{Use: "root"}
+	sheets := &cobra.Command{Use: "sheets"}
+	cmdmeta.SetDomain(sheets, "sheets")
+	root.AddCommand(sheets)
+	sheets.Flags().String("range", "", "")
+	sheets.Flags().Int("width", 0, "")
+
+	err := flagDidYouMean(sheets, parseFlagError(t, sheets, "--cols"))
+	var validationErr *errs.ValidationError
+	if !errors.As(err, &validationErr) {
+		t.Fatalf("expected *errs.ValidationError, got %T", err)
+	}
+	for _, want := range []string{"--range", "--width"} {
+		if !strings.Contains(validationErr.Hint, want) {
+			t.Errorf("hint should include %q, got %q", want, validationErr.Hint)
+		}
+	}
+}
+
+func TestFlagDidYouMean_InvalidValueTypedError(t *testing.T) {
+	c := &cobra.Command{Use: "demo"}
+	c.Flags().Int("width", 0, "")
+
+	// A non-numeric value for a typed flag surfaces pflag's InvalidValueError.
+	err := flagDidYouMean(c, parseFlagError(t, c, "--width=abc"))
+	var verr *errs.ValidationError
+	if !errors.As(err, &verr) {
+		t.Fatalf("expected *errs.ValidationError, got %T", err)
+	}
+	if verr.Subtype != errs.SubtypeInvalidArgument {
+		t.Errorf("subtype = %q, want invalid_argument", verr.Subtype)
+	}
+	if code := output.ExitCodeOf(err); code != output.ExitValidation {
+		t.Errorf("exit code = %d, want %d (ExitValidation)", code, output.ExitValidation)
+	}
+	if len(verr.Params) != 1 || verr.Params[0].Name != "--width" || verr.Params[0].Reason != "invalid flag value" {
+		t.Errorf("Params = %v, want one --width entry with reason 'invalid flag value'", verr.Params)
+	}
+}
+
+func TestFlagDidYouMean_InvalidSyntaxTypedError(t *testing.T) {
+	c := &cobra.Command{Use: "demo"}
+	c.Flags().String("range", "", "")
+
+	// An empty flag name is bad flag syntax and surfaces pflag's InvalidSyntaxError.
+	err := flagDidYouMean(c, parseFlagError(t, c, "--=oops"))
+	var verr *errs.ValidationError
+	if !errors.As(err, &verr) {
+		t.Fatalf("expected *errs.ValidationError, got %T", err)
+	}
+	if verr.Subtype != errs.SubtypeInvalidArgument {
+		t.Errorf("subtype = %q, want invalid_argument", verr.Subtype)
+	}
+	if code := output.ExitCodeOf(err); code != output.ExitValidation {
+		t.Errorf("exit code = %d, want %d (ExitValidation)", code, output.ExitValidation)
+	}
+	if len(verr.Params) != 1 || verr.Params[0].Reason != "invalid flag syntax" {
+		t.Errorf("Params = %v, want one entry with reason 'invalid flag syntax'", verr.Params)
+	}
+}

cmd/root.go

@@ -241,10 +241,10 @@ func configureFlagCompletions(args []string) {
 //     dispatcher no longer promotes any legacy shape here.
 //  2. PartialFailure / BareError signals: the result envelope is already on
 //     stdout; honor the exit code and write nothing to stderr.
-//  3. Residual cobra usage errors (missing required flag, unknown command,
-//     argument validation): typed as an invalid_argument envelope (exit 2),
-//     matching the explicit flag/subcommand guards. Flag parse errors are
-//     already typed upstream by the root FlagErrorFunc.
+//  3. Any untyped error that reaches this boundary is an internal fault.
+//     Cobra argument, required-flag and flag-group errors are typed at their
+//     execution stages by installCobraValidationGuards; flag parse errors are
+//     typed by the root FlagErrorFunc.
 func handleRootError(f *cmdutil.Factory, err error) int {
 	errOut := f.IOStreams.ErrOut
 
@@ -283,57 +283,14 @@ func handleRootError(f *cmdutil.Factory, err error) int {
 		return bareErr.Code
 	}
 
-	// Errors reaching here are untyped: every RunE returns a typed errs.* error
-	// and flag-parse errors are typed by the root FlagErrorFunc. The remainder
-	// is either a cobra usage mistake (missing required flag, unknown command,
-	// wrong arg count), which cobra surfaces as a plain error identified by its
-	// stable text — the same external contract unknownFlagName relies on — or an
-	// untyped error that leaked past the typed boundary. Classify the former as
-	// invalid_argument (exit 2, like the explicit guards); treat the latter as an
-	// internal fault (exit 5) rather than blaming the user's input. The message
-	// is preserved either way, and the typed envelope still carries any pending
-	// deprecation notice.
-	var fallback error
-	if isCobraUsageError(err) {
-		fallback = errs.NewValidationError(errs.SubtypeInvalidArgument, "%s", err.Error())
-	} else {
-		fallback = errs.NewInternalError(errs.SubtypeUnknown, "%s", err.Error()).WithCause(err)
-	}
+	// Every user-input stage is typed before execution. A bare error here has
+	// crossed that boundary unexpectedly and must remain visible as an internal
+	// fault instead of being guessed from English message fragments.
+	fallback := errs.NewInternalError(errs.SubtypeUnknown, "%s", err.Error()).WithCause(err)
 	output.WriteTypedErrorEnvelope(errOut, fallback, string(f.ResolvedIdentity))
 	return output.ExitCodeOf(fallback)
 }
 
-// cobraUsageErrorMarkers are the stable error-text fragments cobra / pflag
-// (pinned at v1.10.2) emit for usage mistakes — missing required flag, unknown
-// command / flag, wrong argument count. Cobra surfaces these as plain errors,
-// not a typed value we can match on, so the dispatcher recognizes them by text;
-// this is the same external contract unknownFlagName already depends on. A
-// residual error matching none of these has leaked the typed boundary and is
-// treated as an internal fault, not a user error.
-var cobraUsageErrorMarkers = []string{
-	"unknown command ",
-	"unknown flag: ",
-	"unknown shorthand",
-	"required flag(s) ",
-	"flag needs an argument",
-	"bad flag syntax:",
-	"no such flag ",
-	"invalid argument ",
-	"arg(s), ", // accepts / requires N arg(s), received / only received M
-}
-
-// isCobraUsageError reports whether err is a cobra / pflag usage mistake,
-// identified by the stable error text of the pinned cobra version.
-func isCobraUsageError(err error) bool {
-	msg := err.Error()
-	for _, m := range cobraUsageErrorMarkers {
-		if strings.Contains(msg, m) {
-			return true
-		}
-	}
-	return false
-}
-
 // installUnknownSubcommandGuard replaces cobra's silent help fallback on
 // group commands (no Run/RunE) with an unknown_subcommand error.
 //
@@ -345,6 +302,10 @@ func isCobraUsageError(err error) bool {
 // with reason_code=risk_not_annotated.
 func installUnknownSubcommandGuard(cmd *cobra.Command) {
 	if cmd.HasSubCommands() && cmd.Run == nil && cmd.RunE == nil {
+		// Cobra's legacy Args fallback rejects an unknown top-level token before
+		// RunE can produce ranked suggestions. Explicitly accepting positional
+		// tokens lets every pure group, including root, reach the shared guard.
+		cmd.Args = cobra.ArbitraryArgs
 		cmd.RunE = unknownSubcommandRunE
 		// Route an unknown subcommand to unknownSubcommandRunE even when flags
 		// are also present (e.g. `sheets +cells-find --url ...`). A pure group
@@ -362,6 +323,132 @@ func installUnknownSubcommandGuard(cmd *cobra.Command) {
 	}
 }
 
+// installCobraValidationGuards types errors at the stage where Cobra knows
+// they are user input: positional argument validation, required flags and flag
+// groups. This removes the need for final-boundary message matching.
+func installCobraValidationGuards(cmd *cobra.Command) {
+	if cmd == nil {
+		return
+	}
+	if validateArgs := cmd.Args; validateArgs != nil {
+		cmd.Args = func(c *cobra.Command, args []string) error {
+			err := validateArgs(c, args)
+			if err == nil || errs.IsTyped(err) {
+				return err
+			}
+			return errs.NewValidationError(errs.SubtypeInvalidArgument, "%s", err.Error()).WithCause(err)
+		}
+	}
+
+	previousPreRunE := cmd.PreRunE
+	previousPreRun := cmd.PreRun
+	cmd.PreRunE = func(c *cobra.Command, args []string) error {
+		if previousPreRunE != nil {
+			if err := previousPreRunE(c, args); err != nil {
+				return err
+			}
+		} else if previousPreRun != nil {
+			previousPreRun(c, args)
+		}
+		if err := c.ValidateRequiredFlags(); err != nil {
+			validationErr := errs.NewValidationError(errs.SubtypeInvalidArgument, "%s", err.Error()).WithCause(err)
+			c.Flags().VisitAll(func(flag *pflag.Flag) {
+				if flag.Changed || len(flag.Annotations[cobra.BashCompOneRequiredFlag]) == 0 {
+					return
+				}
+				validationErr.WithParams(errs.InvalidParam{Name: "--" + flag.Name, Reason: "required flag is missing"})
+			})
+			return validationErr.WithHint("run `%s --help` to see required flags", c.CommandPath())
+		}
+		if err := c.ValidateFlagGroups(); err != nil {
+			return errs.NewValidationError(errs.SubtypeInvalidArgument, "%s", err.Error()).
+				WithParams(invalidFlagGroupParams(err.Error())...).
+				WithHint("run `%s --help` to see valid flag combinations", c.CommandPath()).
+				WithCause(err)
+		}
+		return nil
+	}
+	cmd.PreRun = nil
+
+	for _, child := range cmd.Commands() {
+		installCobraValidationGuards(child)
+	}
+}
+
+type flagGroupConstraint int
+
+const (
+	flagGroupRequiredTogether flagGroupConstraint = iota
+	flagGroupOneRequired
+	flagGroupMutuallyExclusive
+)
+
+// invalidFlagGroupParams extracts the offending flag group from Cobra's
+// flag-group validation error. The message always names the group as
+// "[flag-a flag-b ...]" and its wording identifies the constraint, so both are
+// read straight from the message instead of re-deriving Cobra's private group
+// state. Pinned to cobra v1.10.2's message format (see go.mod).
+func invalidFlagGroupParams(message string) []errs.InvalidParam {
+	names := flagGroupNamesFromMessage(message)
+	if len(names) == 0 {
+		return nil
+	}
+	return buildFlagGroupParams(names, flagGroupConstraintFromMessage(message))
+}
+
+func buildFlagGroupParams(names []string, constraint flagGroupConstraint) []errs.InvalidParam {
+	flagNames := make([]string, 0, len(names))
+	for _, name := range names {
+		name = strings.TrimLeft(name, "-")
+		if name != "" {
+			flagNames = append(flagNames, "--"+name)
+		}
+	}
+	if len(flagNames) == 0 {
+		return nil
+	}
+	group := "[" + strings.Join(flagNames, " ") + "]"
+	reason := "invalid flag combination in " + group
+	switch constraint {
+	case flagGroupRequiredTogether:
+		reason = "all of " + group + " required together"
+	case flagGroupOneRequired:
+		reason = "one of " + group + " required"
+	case flagGroupMutuallyExclusive:
+		reason = "only one of " + group + " allowed"
+	}
+	params := make([]errs.InvalidParam, 0, len(flagNames))
+	for _, name := range flagNames {
+		params = append(params, errs.InvalidParam{Name: name, Reason: reason})
+	}
+	return params
+}
+
+func flagGroupNamesFromMessage(message string) []string {
+	start := strings.IndexByte(message, '[')
+	if start < 0 {
+		return nil
+	}
+	end := strings.IndexByte(message[start+1:], ']')
+	if end < 0 {
+		return nil
+	}
+	return strings.Fields(message[start+1 : start+1+end])
+}
+
+func flagGroupConstraintFromMessage(message string) flagGroupConstraint {
+	switch {
+	case strings.Contains(message, "at least one of the flags"):
+		return flagGroupOneRequired
+	case strings.Contains(message, "must all be set"):
+		return flagGroupRequiredTogether
+	case strings.Contains(message, "none of the others can be"):
+		return flagGroupMutuallyExclusive
+	default:
+		return flagGroupConstraint(-1)
+	}
+}
+
 // unknownSubcommandRunE replaces cobra's silent help fallback on group commands
 // with a typed *errs.ValidationError: a flag that belongs to a missing
 // subcommand, a misplaced subcommand-only flag, or an unknown subcommand name
@@ -592,17 +679,21 @@ func isLarkDomain(c *cobra.Command) bool {
 	return cmdmeta.Domain(c) != ""
 }
 
-// flagDidYouMean is the root FlagErrorFunc (inherited by all subcommands). It
-// converts cobra's flag-parse errors into a typed validation envelope: an
-// unknown flag gets a focused "did you mean" hint (so agents recover even when
-// the typo is semantic, e.g. --query vs --find, where edit distance alone finds
-// nothing) and the offending flag in `params`. Other flag errors stay typed
-// but generic.
+// flagDidYouMean is the single FlagErrorFunc inherited by all commands. It
+// classifies pflag's typed parse errors and emits one stable validation shape.
 func flagDidYouMean(c *cobra.Command, ferr error) error {
-	name, isUnknown := unknownFlagName(ferr)
-	if !isUnknown {
-		return errs.NewValidationError(errs.SubtypeInvalidArgument, "%s", ferr.Error()).
-			WithHint("run `%s --help` for valid flags", c.CommandPath())
+	if ferr == nil {
+		return nil
+	}
+	var notExist *pflag.NotExistError
+	if !errors.As(ferr, &notExist) {
+		return typedFlagParseError(c, ferr)
+	}
+
+	name := notExist.GetSpecifiedName()
+	rawName := "--" + name
+	if notExist.GetSpecifiedShortnames() != "" {
+		rawName = "-" + name
 	}
 	valid := visibleFlagNames(c)
 	suggestions := suggest.Closest(name, valid, 3)
@@ -614,36 +705,69 @@ func flagDidYouMean(c *cobra.Command, ferr error) error {
 		hint = fmt.Sprintf("did you mean %s? (run `%s --help` for all flags)",
 			strings.Join(suggestions, ", "), c.CommandPath())
 	}
-	// The ranked candidates ride on the param as machine-readable Suggestions so
-	// an agent can retry without parsing the hint; the hint carries the same
-	// candidates as prose. The full valid-flag list stays recoverable via --help.
+	if cmdmeta.Domain(c) == "sheets" {
+		if list := inlineVisibleFlags(valid); list != "" {
+			if len(suggestions) > 0 {
+				hint = fmt.Sprintf("did you mean %s? valid flags: %s", strings.Join(suggestions, ", "), list)
+			} else {
+				hint = "valid flags: " + list
+			}
+		}
+	}
 	return errs.NewValidationError(errs.SubtypeInvalidArgument,
-		"unknown flag %q for %q", "--"+name, c.CommandPath()).
-		WithParams(errs.InvalidParam{Name: "--" + name, Reason: "unknown flag", Suggestions: suggestions}).
-		WithHint("%s", hint)
+		"unknown flag %q for %q", rawName, c.CommandPath()).
+		WithParams(errs.InvalidParam{Name: rawName, Reason: "unknown flag", Suggestions: suggestions}).
+		WithHint("%s", hint).
+		WithCause(ferr)
 }
 
-// unknownFlagName extracts the offending long-flag name from cobra's flag-parse
-// error text ("unknown flag: --query" → "query"). Returns ok=false for anything
-// else (missing argument, invalid value, unknown shorthand) so the caller keeps
-// those structured but generic — hallucinated flags are essentially always long.
-//
-// CONTRACT: this matches cobra's English wording "unknown flag: --" (go.mod
-// pins github.com/spf13/cobra). If cobra rewords this or gains i18n the match
-// silently fails and unknown flags degrade to a generic flag_error — re-verify
-// this prefix when bumping cobra.
-func unknownFlagName(err error) (string, bool) {
-	const p = "unknown flag: --"
-	msg := err.Error()
-	i := strings.Index(msg, p)
-	if i < 0 {
-		return "", false
+func typedFlagParseError(c *cobra.Command, ferr error) error {
+	param := ""
+	reason := "flag parse error"
+	var valueRequired *pflag.ValueRequiredError
+	var invalidValue *pflag.InvalidValueError
+	var invalidSyntax *pflag.InvalidSyntaxError
+	switch {
+	case errors.As(ferr, &valueRequired):
+		param = "--" + valueRequired.GetSpecifiedName()
+		if valueRequired.GetSpecifiedShortnames() != "" {
+			param = "-" + valueRequired.GetSpecifiedName()
+		}
+		reason = "flag value is required"
+	case errors.As(ferr, &invalidValue):
+		if invalidValue.GetFlag() != nil {
+			param = "--" + invalidValue.GetFlag().Name
+		}
+		reason = "invalid flag value"
+	case errors.As(ferr, &invalidSyntax):
+		param = invalidSyntax.GetSpecifiedFlag()
+		reason = "invalid flag syntax"
 	}
-	rest := msg[i+len(p):]
-	if j := strings.IndexAny(rest, " \t"); j >= 0 {
-		rest = rest[:j]
+	validationErr := errs.NewValidationError(errs.SubtypeInvalidArgument, "%s", ferr.Error()).
+		WithHint("run `%s --help` for valid flags", c.CommandPath()).
+		WithCause(ferr)
+	if param != "" {
+		validationErr.WithParams(errs.InvalidParam{Name: param, Reason: reason})
 	}
-	return rest, true
+	return validationErr
+}
+
+func inlineVisibleFlags(names []string) string {
+	const limit = 25
+	if len(names) == 0 {
+		return ""
+	}
+	shown := names
+	suffix := ""
+	if len(shown) > limit {
+		shown = shown[:limit]
+		suffix = fmt.Sprintf(", ... (%d more; see --help)", len(names)-limit)
+	}
+	flags := make([]string, len(shown))
+	for i, name := range shown {
+		flags[i] = "--" + name
+	}
+	return strings.Join(flags, ", ") + suffix
 }
 
 // visibleFlagNames lists the non-hidden flag names of c (for suggestions and

cmd/root_test.go

@@ -6,6 +6,7 @@ package cmd
 import (
 	"bytes"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io"
 	"strings"
@@ -284,9 +285,9 @@ func TestHandleRootError_DeprecatedAliasMissingFlagStructured(t *testing.T) {
 	deprecation.SetPending(&deprecation.Notice{
 		Command: "+write", Replacement: "+cells-set", Skill: "lark-sheets",
 	})
-	// The bare error shape cobra's ValidateRequiredFlags produces: not a typed
-	// errs.* error, so it reaches the deprecation fallback.
-	exit := handleRootError(f, fmt.Errorf(`required flag(s) %q not set`, "values"))
+	err := errs.NewValidationError(errs.SubtypeInvalidArgument, `required flag(s) %q not set`, "values").
+		WithParam("--values")
+	exit := handleRootError(f, err)
 
 	out := errOut.String()
 	if strings.HasPrefix(strings.TrimSpace(out), "Error:") {
@@ -381,10 +382,9 @@ func decodeErrorEnvelope(t *testing.T, raw []byte) map[string]any {
 	return errObj
 }
 
-// TestHandleRootError_NoDeprecationTypesUsageError pins that a residual cobra
-// usage error (missing required flag) is typed as invalid_argument with exit 2
-// even with no deprecation pending — never cobra's plain "Error:" line.
-func TestHandleRootError_NoDeprecationTypesUsageError(t *testing.T) {
+// TestCobraValidationGuardTypesRequiredFlag pins that required-flag errors are
+// typed at the Cobra validation stage, before the final dispatcher.
+func TestCobraValidationGuardTypesRequiredFlag(t *testing.T) {
 	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
 	t.Cleanup(func() { deprecation.SetPending(nil) })
 	deprecation.SetPending(nil)
@@ -393,7 +393,15 @@ func TestHandleRootError_NoDeprecationTypesUsageError(t *testing.T) {
 	errOut := &bytes.Buffer{}
 	f.IOStreams.ErrOut = errOut
 
-	exit := handleRootError(f, fmt.Errorf(`required flag(s) %q not set`, "values"))
+	cmd := &cobra.Command{Use: "demo", RunE: func(*cobra.Command, []string) error { return nil }}
+	cmd.Flags().String("values", "", "")
+	cmd.MarkFlagRequired("values")
+	installCobraValidationGuards(cmd)
+	err := cmd.Execute()
+	if err == nil {
+		t.Fatal("expected missing required flag error")
+	}
+	exit := handleRootError(f, err)
 
 	out := errOut.String()
 	if strings.HasPrefix(strings.TrimSpace(out), "Error:") {
@@ -411,6 +419,93 @@ func TestHandleRootError_NoDeprecationTypesUsageError(t *testing.T) {
 	}
 }
 
+func TestCobraValidationGuardTypesFlagGroupErrorsWithParams(t *testing.T) {
+	tests := []struct {
+		name       string
+		mark       func(*cobra.Command)
+		args       []string
+		wantNames  []string
+		wantReason string
+	}{
+		{
+			name: "one required",
+			mark: func(cmd *cobra.Command) {
+				cmd.MarkFlagsOneRequired("start-cell", "range")
+			},
+			wantNames:  []string{"--start-cell", "--range"},
+			wantReason: "one of [--start-cell --range] required",
+		},
+		{
+			name: "required together",
+			mark: func(cmd *cobra.Command) {
+				cmd.MarkFlagsRequiredTogether("start-cell", "range")
+			},
+			args:       []string{"--start-cell", "A1"},
+			wantNames:  []string{"--start-cell", "--range"},
+			wantReason: "all of [--start-cell --range] required together",
+		},
+		{
+			name: "mutually exclusive",
+			mark: func(cmd *cobra.Command) {
+				cmd.MarkFlagsMutuallyExclusive("start-cell", "range")
+			},
+			args:       []string{"--start-cell", "A1", "--range", "B2"},
+			wantNames:  []string{"--start-cell", "--range"},
+			wantReason: "only one of [--start-cell --range] allowed",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			cmd := &cobra.Command{Use: "demo", RunE: func(*cobra.Command, []string) error { return nil }}
+			cmd.Flags().String("start-cell", "", "")
+			cmd.Flags().String("range", "", "")
+			tt.mark(cmd)
+			installCobraValidationGuards(cmd)
+			cmd.SetArgs(tt.args)
+
+			err := cmd.Execute()
+			if err == nil {
+				t.Fatal("expected flag group error")
+			}
+			problem, ok := errs.ProblemOf(err)
+			if !ok {
+				t.Fatalf("expected typed problem, got %T: %v", err, err)
+			}
+			if problem.Category != errs.CategoryValidation || problem.Subtype != errs.SubtypeInvalidArgument {
+				t.Fatalf("problem = %s/%s, want validation/invalid_argument", problem.Category, problem.Subtype)
+			}
+			if got := output.ExitCodeOf(err); got != output.ExitValidation {
+				t.Fatalf("exit code = %d, want %d", got, output.ExitValidation)
+			}
+			var validationErr *errs.ValidationError
+			if !errors.As(err, &validationErr) {
+				t.Fatalf("expected *errs.ValidationError, got %T", err)
+			}
+			if len(validationErr.Params) != len(tt.wantNames) {
+				t.Fatalf("params = %v, want %d entries", validationErr.Params, len(tt.wantNames))
+			}
+			for i, wantName := range tt.wantNames {
+				if validationErr.Params[i].Name != wantName || validationErr.Params[i].Reason != tt.wantReason {
+					t.Errorf("params[%d] = %+v, want name=%q reason=%q", i, validationErr.Params[i], wantName, tt.wantReason)
+				}
+			}
+		})
+	}
+}
+
+func TestInvalidFlagGroupParamsFromMessage(t *testing.T) {
+	got := invalidFlagGroupParams("at least one of the flags in the group [start-cell range] is required")
+	if len(got) != 2 {
+		t.Fatalf("params = %v, want two entries", got)
+	}
+	for i, want := range []string{"--start-cell", "--range"} {
+		if got[i].Name != want || got[i].Reason != "one of [--start-cell --range] required" {
+			t.Errorf("params[%d] = %+v", i, got[i])
+		}
+	}
+}
+
 // TestHandleRootError_LeakedUntypedErrorBecomesInternal pins that an untyped
 // error that does NOT match a cobra usage shape (i.e. one that leaked past the
 // typed boundary from a helper) is classified as an internal fault (exit 5),

cmd/service/service.go

@@ -140,6 +140,7 @@ type ServiceMethodOptions struct {
 	PageLimit  int
 	PageDelay  int
 	Format     string
+	JSON       bool
 	JqExpr     string
 	DryRun     bool
 	File       string   // --file flag value
@@ -268,6 +269,11 @@ func buildMethodCommand(ctx context.Context, f *cmdutil.Factory, spec methodComm
 			opts.Cmd = cmd
 			opts.Ctx = cmd.Context()
 			opts.As = core.Identity(asStr)
+			format, err := output.StandardFormats.Resolve(opts.Format, cmd.Flags().Changed("format"), opts.JSON)
+			if err != nil {
+				return err
+			}
+			opts.Format = format
 			if runF != nil {
 				return runF(opts)
 			}
@@ -299,8 +305,8 @@ func buildMethodCommand(ctx context.Context, f *cmdutil.Factory, spec methodComm
 			_ = cmd.Flags().MarkHidden(name)
 		}
 	}
-	cmd.Flags().StringVar(&opts.Format, "format", "json", "output format: json|ndjson|table|csv")
-	cmd.Flags().Bool("json", false, "shorthand for --format json")
+	cmd.Flags().StringVar(&opts.Format, "format", "json", output.StandardFormats.Usage())
+	cmd.Flags().BoolVar(&opts.JSON, "json", false, "shorthand for --format json")
 	cmd.Flags().StringVarP(&opts.JqExpr, "jq", "q", "", "jq expression to filter JSON output")
 	cmd.Flags().BoolVar(&opts.DryRun, "dry-run", false, "print request without executing")
 	if spec.risk == cmdutil.RiskHighRiskWrite {
@@ -311,7 +317,7 @@ func buildMethodCommand(ctx context.Context, f *cmdutil.Factory, spec methodComm
 		cmd.Flags().StringVar(&opts.File, "file", "", "File upload [field=]path. Supports - and stdin.")
 	}
 	cmdutil.RegisterFlagCompletion(cmd, "format", func(_ *cobra.Command, _ []string, _ string) ([]string, cobra.ShellCompDirective) {
-		return []string{"json", "ndjson", "table", "csv"}, cobra.ShellCompDirectiveNoFileComp
+		return output.StandardFormats.Names(), cobra.ShellCompDirectiveNoFileComp
 	})
 
 	// Registered last so the collision guard sees the standard flags above.
@@ -420,10 +426,7 @@ func serviceMethodRun(opts *ServiceMethodOptions) error {
 	}
 
 	out := f.IOStreams.Out
-	format, formatOK := output.ParseFormat(opts.Format)
-	if !formatOK {
-		fmt.Fprintf(f.IOStreams.ErrOut, "warning: unknown format %q, falling back to json\n", opts.Format)
-	}
+	format, _ := output.ParseFormat(opts.Format)
 
 	// Scope-insufficient (99991679) and all other Lark API codes route through
 	// errclass.BuildAPIError via ac.CheckResponse, producing *errs.PermissionError
@@ -706,6 +709,24 @@ func servicePaginate(ctx context.Context, ac *client.APIClient, request client.R
 	}
 
 	switch format {
+	case output.FormatPretty:
+		result, err := ac.PaginateAll(ctx, request, pagOpts)
+		if err != nil {
+			return err
+		}
+		if apiErr := checkErr(result, pagOpts.Identity); apiErr != nil {
+			output.FormatValue(out, result, output.FormatPretty)
+			return apiErr
+		}
+		scanResult := output.ScanForSafety(commandPath, result, errOut)
+		if scanResult.Blocked {
+			return scanResult.BlockErr
+		}
+		if scanResult.Alert != nil {
+			output.WriteAlertWarning(errOut, scanResult.Alert)
+		}
+		output.FormatValue(out, result, output.FormatPretty)
+		return nil
 	case output.FormatNDJSON, output.FormatTable, output.FormatCSV:
 		pf := output.NewPaginatedFormatter(out, format)
 		result, hasItems, err := ac.StreamPages(ctx, request, func(items []interface{}) error {

cmd/service/service_test.go

@@ -201,6 +201,42 @@ func TestNewCmdServiceMethod_RunFCallback(t *testing.T) {
 	}
 }
 
+func TestServiceMethod_OutputFormatResolution(t *testing.T) {
+	tests := []struct {
+		name string
+		args []string
+		want string
+	}{
+		{name: "json shorthand", args: []string{"--json"}, want: "json"},
+		{name: "explicit format wins", args: []string{"--format", "table", "--json"}, want: "table"},
+		{name: "pretty format", args: []string{"--format", "PRETTY"}, want: "pretty"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			f, _, _, _ := cmdutil.TestFactory(t, testConfig)
+			var captured *ServiceMethodOptions
+			cmd := NewCmdServiceMethod(f, driveSpec(),
+				meta.FromMap(map[string]interface{}{"description": "desc", "httpMethod": "GET"}), "list", "files",
+				func(opts *ServiceMethodOptions) error {
+					captured = opts
+					return nil
+				})
+			args := []string{"--as", "bot"}
+			cmd.SetArgs(append(args, tt.args...))
+			if err := cmd.Execute(); err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
+			if captured == nil {
+				t.Fatal("expected options to be captured")
+			}
+			if captured.Format != tt.want {
+				t.Fatalf("format = %q, want %q", captured.Format, tt.want)
+			}
+		})
+	}
+}
+
 // ── dry-run / buildServiceRequest ──
 
 func TestServiceMethod_DryRun_PathParam(t *testing.T) {
@@ -462,6 +498,43 @@ func TestServiceMethod_BotMode_Success(t *testing.T) {
 	}
 }
 
+func TestServiceMethod_PrettyFormatsRealResponse(t *testing.T) {
+	f, stdout, _, reg := cmdutil.TestFactory(t, testConfig)
+	reg.Register(&httpmock.Stub{
+		URL: "/open-apis/svc/v1/items",
+		Body: map[string]interface{}{
+			"code": 0,
+			"data": map[string]interface{}{
+				"items": []interface{}{map[string]interface{}{"name": "Alice"}},
+			},
+		},
+	})
+
+	spec := meta.ServiceFromMap(map[string]interface{}{"name": "svc", "servicePath": "/open-apis/svc/v1"})
+	method := meta.FromMap(map[string]interface{}{"path": "items", "httpMethod": "GET", "parameters": map[string]interface{}{}})
+	cmd := NewCmdServiceMethod(f, spec, method, "list", "items", nil)
+	cmd.SetArgs([]string{"--as", "bot", "--format", "pretty"})
+	if err := cmd.Execute(); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	out := stdout.String()
+	var got map[string]interface{}
+	if err := json.Unmarshal(stdout.Bytes(), &got); err != nil {
+		t.Fatalf("pretty output should be valid JSON: %v\n%s", err, out)
+	}
+	data, ok := got["data"].(map[string]interface{})
+	if !ok {
+		t.Fatalf("pretty output data = %#v", got["data"])
+	}
+	items, ok := data["items"].([]interface{})
+	if !ok || len(items) != 1 {
+		t.Fatalf("pretty output data.items = %#v", data["items"])
+	}
+	if !strings.Contains(out, "\n  \"data\": {") || strings.Contains(out, "─") {
+		t.Fatalf("pretty output should be indented JSON rather than a table, got:\n%s", out)
+	}
+}
+
 func TestServiceMethod_BotMode_PageAll_JSON(t *testing.T) {
 	f, stdout, _, reg := cmdutil.TestFactory(t, &core.CliConfig{
 		AppID: "test-app-page", AppSecret: "test-secret-page", Brand: core.BrandFeishu,
@@ -503,6 +576,48 @@ func TestServiceMethod_BotMode_PageAll_JSON(t *testing.T) {
 	}
 }
 
+func TestServiceMethod_PageAll_PrettyAggregatesIndentedJSON(t *testing.T) {
+	f, stdout, _, reg := cmdutil.TestFactory(t, &core.CliConfig{
+		AppID: "test-app-service-pageall-pretty", AppSecret: "test-secret", Brand: core.BrandFeishu,
+	})
+
+	reg.Register(&httpmock.Stub{
+		URL: "/open-apis/svc/v1/items",
+		Body: map[string]interface{}{
+			"code": 0, "msg": "ok",
+			"data": map[string]interface{}{
+				"items":    []interface{}{map[string]interface{}{"id": "1"}},
+				"has_more": false,
+			},
+		},
+	})
+
+	spec := meta.ServiceFromMap(map[string]interface{}{"name": "svc", "servicePath": "/open-apis/svc/v1"})
+	method := meta.FromMap(map[string]interface{}{"path": "items", "httpMethod": "GET", "parameters": map[string]interface{}{}})
+	cmd := NewCmdServiceMethod(f, spec, method, "list", "items", nil)
+	cmd.SetArgs([]string{"--as", "bot", "--page-all", "--format", "pretty"})
+	if err := cmd.Execute(); err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+
+	out := stdout.String()
+	var got map[string]interface{}
+	if err := json.Unmarshal(stdout.Bytes(), &got); err != nil {
+		t.Fatalf("page-all pretty output should be valid JSON: %v\n%s", err, out)
+	}
+	data, ok := got["data"].(map[string]interface{})
+	if !ok {
+		t.Fatalf("page-all pretty output data = %#v", got["data"])
+	}
+	items, ok := data["items"].([]interface{})
+	if !ok || len(items) != 1 {
+		t.Fatalf("page-all pretty output data.items = %#v", data["items"])
+	}
+	if !strings.Contains(out, "\n  \"data\": {") || strings.Contains(out, "─") {
+		t.Fatalf("page-all pretty output should be aggregated indented JSON, got:\n%s", out)
+	}
+}
+
 type serviceContentSafetyProvider struct {
 	called bool
 	path   string
@@ -795,26 +910,23 @@ func TestServiceMethod_PageAll_StreamBusinessErrorDoesNotDumpJSON(t *testing.T)
 	}
 }
 
-func TestServiceMethod_UnknownFormat_Warning(t *testing.T) {
-	f, _, stderr, reg := cmdutil.TestFactory(t, &core.CliConfig{
+func TestServiceMethod_UnknownFormat_ReturnsValidationError(t *testing.T) {
+	f, _, _, _ := cmdutil.TestFactory(t, &core.CliConfig{
 		AppID: "test-app-fmt", AppSecret: "test-secret-fmt", Brand: core.BrandFeishu,
 	})
 
-	reg.Register(&httpmock.Stub{
-		URL:  "/open-apis/svc/v1/items",
-		Body: map[string]interface{}{"code": 0, "msg": "ok", "data": map[string]interface{}{}},
-	})
-
 	spec := meta.ServiceFromMap(map[string]interface{}{"name": "svc", "servicePath": "/open-apis/svc/v1"})
 	method := meta.FromMap(map[string]interface{}{"path": "items", "httpMethod": "GET", "parameters": map[string]interface{}{}})
 	cmd := NewCmdServiceMethod(f, spec, method, "list", "items", nil)
 	cmd.SetArgs([]string{"--as", "bot", "--format", "unknown"})
 
-	if err := cmd.Execute(); err != nil {
-		t.Fatalf("unexpected error: %v", err)
+	err := cmd.Execute()
+	var validationErr *errs.ValidationError
+	if !errors.As(err, &validationErr) {
+		t.Fatalf("expected *errs.ValidationError, got %T: %v", err, err)
 	}
-	if !strings.Contains(stderr.String(), "warning: unknown format") {
-		t.Errorf("expected format warning in stderr, got:\n%s", stderr.String())
+	if validationErr.Param != "--format" {
+		t.Errorf("param = %q, want --format", validationErr.Param)
 	}
 }
 

cmd/unknown_subcommand_test.go

@@ -45,11 +45,38 @@ func TestInstallUnknownSubcommandGuard_InstallsOnGroupsOnly(t *testing.T) {
 	if files.RunE == nil {
 		t.Error("files should have RunE installed")
 	}
+	if root.Args == nil {
+		t.Error("root should explicitly accept positional tokens so unknown commands reach RunE")
+	}
 	if err := leaf.RunE(leaf, []string{"unexpected-arg"}); err != nil {
 		t.Errorf("leaf +search RunE should be untouched, got error %v", err)
 	}
 }
 
+func TestTopLevelUnknownCommandReturnsStructuredSuggestion(t *testing.T) {
+	root, _, _ := newGroupTree()
+	installUnknownSubcommandGuard(root)
+	root.SetArgs([]string{"driv"})
+
+	err := root.Execute()
+	var validationErr *errs.ValidationError
+	if !errors.As(err, &validationErr) {
+		t.Fatalf("expected *errs.ValidationError, got %T: %v", err, err)
+	}
+	if len(validationErr.Params) != 1 || validationErr.Params[0].Name != "driv" {
+		t.Fatalf("params = %v, want one entry named driv", validationErr.Params)
+	}
+	found := false
+	for _, candidate := range validationErr.Params[0].Suggestions {
+		if candidate == "drive" {
+			found = true
+		}
+	}
+	if !found {
+		t.Fatalf("suggestions = %v, want drive", validationErr.Params[0].Suggestions)
+	}
+}
+
 func TestInstallUnknownSubcommandGuard_PreservesExistingRunE(t *testing.T) {
 	root := &cobra.Command{Use: "lark-cli"}
 	called := false

go.mod

@@ -14,7 +14,7 @@ require (
 	github.com/sergi/go-diff v1.4.0
 	github.com/skip2/go-qrcode v0.0.0-20200617195104-da1b6568686e
 	github.com/smartystreets/goconvey v1.8.1
-	github.com/spf13/cobra v1.10.2 // flag-error-text contract: see cmd/root.go unknownFlagName
+	github.com/spf13/cobra v1.10.2 // typed flag errors are classified in cmd/root.go
 	github.com/spf13/pflag v1.0.9
 	github.com/stretchr/testify v1.11.1
 	github.com/tidwall/gjson v1.18.0

internal/errclass/codemeta_spark.go

@@ -1,28 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package errclass
-
-import "github.com/larksuite/cli/errs"
-
-// sparkCodeMeta holds stable Spark app-role business-code classifications.
-// Command-specific recovery guidance belongs in the Apps shortcut layer; the
-// numeric code remains the source-specific discriminator on the error envelope.
-var sparkCodeMeta = map[int]CodeMeta{
-	3340001: {Category: errs.CategoryAPI, Subtype: errs.SubtypeInvalidParameters},          // request parameters are invalid
-	3344027: {Category: errs.CategoryAPI, Subtype: errs.SubtypeQuotaExceeded},              // role user count exceeds the service limit
-	3344028: {Category: errs.CategoryAPI, Subtype: errs.SubtypeQuotaExceeded},              // role department count exceeds the service limit
-	3344029: {Category: errs.CategoryAPI, Subtype: errs.SubtypeQuotaExceeded},              // role chat count exceeds the service limit
-	3344030: {Category: errs.CategoryAuthorization, Subtype: errs.SubtypePermissionDenied}, // app administrator required
-	3344031: {Category: errs.CategoryAuthorization, Subtype: errs.SubtypePermissionDenied}, // app administrator or developer required
-	3344034: {Category: errs.CategoryAPI, Subtype: errs.SubtypeInvalidParameters},          // invalid role ID
-	3344035: {Category: errs.CategoryAPI, Subtype: errs.SubtypeNotFound},                   // role does not exist
-	3344036: {Category: errs.CategoryAPI, Subtype: errs.SubtypeAlreadyExists},              // role ID already exists
-	3344037: {Category: errs.CategoryAPI, Subtype: errs.SubtypeQuotaExceeded},              // app role count exceeds the service limit
-	3344038: {Category: errs.CategoryAPI, Subtype: errs.SubtypeInvalidParameters},          // invalid role name
-	3344039: {Category: errs.CategoryAPI, Subtype: errs.SubtypeInvalidParameters},          // invalid role description
-	3344040: {Category: errs.CategoryAPI, Subtype: errs.SubtypeInvalidParameters},          // unsupported member type
-	3344041: {Category: errs.CategoryAPI, Subtype: errs.SubtypeInvalidParameters},          // invalid member ID
-}
-
-func init() { mergeCodeMeta(sparkCodeMeta, "spark") }

internal/errclass/codemeta_spark_test.go

@@ -1,59 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package errclass
-
-import (
-	"fmt"
-	"testing"
-
-	"github.com/larksuite/cli/errs"
-)
-
-func TestLookupCodeMetaSparkRoleCodes(t *testing.T) {
-	tests := []struct {
-		code     int
-		category errs.Category
-		subtype  errs.Subtype
-	}{
-		{3340001, errs.CategoryAPI, errs.SubtypeInvalidParameters},
-		{3344027, errs.CategoryAPI, errs.SubtypeQuotaExceeded},
-		{3344028, errs.CategoryAPI, errs.SubtypeQuotaExceeded},
-		{3344029, errs.CategoryAPI, errs.SubtypeQuotaExceeded},
-		{3344030, errs.CategoryAuthorization, errs.SubtypePermissionDenied},
-		{3344031, errs.CategoryAuthorization, errs.SubtypePermissionDenied},
-		{3344034, errs.CategoryAPI, errs.SubtypeInvalidParameters},
-		{3344035, errs.CategoryAPI, errs.SubtypeNotFound},
-		{3344036, errs.CategoryAPI, errs.SubtypeAlreadyExists},
-		{3344037, errs.CategoryAPI, errs.SubtypeQuotaExceeded},
-		{3344038, errs.CategoryAPI, errs.SubtypeInvalidParameters},
-		{3344039, errs.CategoryAPI, errs.SubtypeInvalidParameters},
-		{3344040, errs.CategoryAPI, errs.SubtypeInvalidParameters},
-		{3344041, errs.CategoryAPI, errs.SubtypeInvalidParameters},
-	}
-
-	for _, tt := range tests {
-		t.Run(fmt.Sprintf("%d", tt.code), func(t *testing.T) {
-			meta, ok := LookupCodeMeta(tt.code)
-			if !ok {
-				t.Fatalf("code %d is not registered", tt.code)
-			}
-			if meta.Category != tt.category || meta.Subtype != tt.subtype || meta.Retryable {
-				t.Fatalf("code %d metadata = %+v, want category=%s subtype=%s retryable=false", tt.code, meta, tt.category, tt.subtype)
-			}
-
-			err := BuildAPIError(map[string]any{
-				"code":   tt.code,
-				"msg":    "spark role error",
-				"log_id": "log-spark-role",
-			}, ClassifyContext{Identity: "user"})
-			problem, ok := errs.ProblemOf(err)
-			if !ok {
-				t.Fatalf("BuildAPIError(%d) = %#v, want typed problem", tt.code, err)
-			}
-			if problem.Category != tt.category || problem.Subtype != tt.subtype || problem.Code != tt.code || problem.LogID != "log-spark-role" || problem.Retryable {
-				t.Fatalf("BuildAPIError(%d) problem = %+v", tt.code, problem)
-			}
-		})
-	}
-}

internal/output/capabilities.go

@@ -0,0 +1,61 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package output
+
+import (
+	"slices"
+	"strings"
+
+	"github.com/larksuite/cli/errs"
+)
+
+// FormatCapabilities is the single description of the output formats a
+// command supports. Help text, shell completion, shorthand normalization and
+// runtime validation all consume the same value so they cannot drift apart.
+type FormatCapabilities struct {
+	names []string
+}
+
+var (
+	// StandardFormats applies to API, service and ordinary shortcut commands.
+	StandardFormats = NewFormatCapabilities("json", "pretty", "table", "ndjson", "csv")
+	// JSONPrettyFormats applies to commands with a dedicated human renderer and
+	// no streaming/tabular output, such as auth scopes.
+	JSONPrettyFormats = NewFormatCapabilities("json", "pretty")
+)
+
+// NewFormatCapabilities constructs an immutable format capability set.
+func NewFormatCapabilities(names ...string) FormatCapabilities {
+	return FormatCapabilities{names: append([]string(nil), names...)}
+}
+
+// Names returns a copy suitable for completion candidates.
+func (c FormatCapabilities) Names() []string {
+	return append([]string(nil), c.names...)
+}
+
+// Usage returns the canonical help text for a --format flag.
+func (c FormatCapabilities) Usage() string {
+	return "output format: " + strings.Join(c.names, "|")
+}
+
+// Supports reports whether name is part of this command's output contract.
+func (c FormatCapabilities) Supports(name string) bool {
+	return slices.Contains(c.names, strings.ToLower(name))
+}
+
+// Resolve applies the --json shorthand and validates the selected format.
+// An explicit --format always wins over --json.
+func (c FormatCapabilities) Resolve(format string, formatExplicit, jsonShorthand bool) (string, error) {
+	if jsonShorthand && !formatExplicit {
+		format = "json"
+	}
+	format = strings.ToLower(format)
+	if c.Supports(format) {
+		return format, nil
+	}
+	return "", errs.NewValidationError(errs.SubtypeInvalidArgument,
+		"unsupported output format %q; supported formats: %s", format, strings.Join(c.names, ", ")).
+		WithParam("--format")
+}

internal/output/capabilities_test.go

@@ -0,0 +1,53 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package output
+
+import (
+	"errors"
+	"reflect"
+	"testing"
+
+	"github.com/larksuite/cli/errs"
+)
+
+func TestFormatCapabilitiesResolve(t *testing.T) {
+	tests := []struct {
+		name           string
+		format         string
+		formatExplicit bool
+		jsonShorthand  bool
+		want           string
+		wantErr        bool
+	}{
+		{name: "default", format: "json", want: "json"},
+		{name: "json shorthand", format: "table", jsonShorthand: true, want: "json"},
+		{name: "explicit format wins", format: "table", formatExplicit: true, jsonShorthand: true, want: "table"},
+		{name: "case normalized", format: "PRETTY", formatExplicit: true, want: "pretty"},
+		{name: "unsupported", format: "xml", formatExplicit: true, wantErr: true},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := StandardFormats.Resolve(tt.format, tt.formatExplicit, tt.jsonShorthand)
+			if tt.wantErr {
+				var validationErr *errs.ValidationError
+				if !errors.As(err, &validationErr) || validationErr.Subtype != errs.SubtypeInvalidArgument || validationErr.Param != "--format" {
+					t.Fatalf("Resolve() error = %T %v, want invalid_argument --format validation error", err, err)
+				}
+				return
+			}
+			if err != nil || got != tt.want {
+				t.Fatalf("Resolve() = %q, %v; want %q, nil", got, err, tt.want)
+			}
+		})
+	}
+}
+
+func TestFormatCapabilitiesDriveHelpAndCompletion(t *testing.T) {
+	if got, want := StandardFormats.Usage(), "output format: json|pretty|table|ndjson|csv"; got != want {
+		t.Fatalf("Usage() = %q, want %q", got, want)
+	}
+	if got, want := StandardFormats.Names(), []string{"json", "pretty", "table", "ndjson", "csv"}; !reflect.DeepEqual(got, want) {
+		t.Fatalf("Names() = %v, want %v", got, want)
+	}
+}

internal/output/format.go

@@ -103,6 +103,9 @@ func ExtractItems(data interface{}) []interface{} {
 func FormatValue(w io.Writer, data interface{}, format Format) {
 	data = toGeneric(data)
 	switch format {
+	case FormatPretty:
+		PrintJson(w, data)
+
 	case FormatNDJSON:
 		items := ExtractItems(data)
 		if items != nil {
@@ -149,6 +152,9 @@ func NewPaginatedFormatter(w io.Writer, format Format) *PaginatedFormatter {
 // FormatPage formats one page of items.
 func (pf *PaginatedFormatter) FormatPage(data interface{}) {
 	switch pf.Format {
+	case FormatPretty:
+		PrintJson(pf.W, data)
+
 	case FormatJSON, FormatNDJSON:
 		if arr, ok := data.([]interface{}); ok {
 			PrintNdjson(pf.W, arr)

internal/output/format_test.go

@@ -73,6 +73,30 @@ func TestFormatValue_Table(t *testing.T) {
 	}
 }
 
+func TestFormatValue_Pretty(t *testing.T) {
+	data := map[string]interface{}{
+		"data": map[string]interface{}{
+			"items": []interface{}{
+				map[string]interface{}{"name": "Alice"},
+			},
+		},
+	}
+
+	var buf bytes.Buffer
+	FormatValue(&buf, data, FormatPretty)
+	out := buf.String()
+
+	if !json.Valid([]byte(out)) {
+		t.Fatalf("pretty output should be valid JSON, got:\n%s", out)
+	}
+	if !strings.Contains(out, "\n  \"data\": {") || !strings.Contains(out, `"name": "Alice"`) {
+		t.Fatalf("pretty output should be indented JSON, got:\n%s", out)
+	}
+	if strings.Contains(out, "─") {
+		t.Fatalf("pretty output should not render a table, got:\n%s", out)
+	}
+}
+
 func TestFormatValue_CSV(t *testing.T) {
 	data := map[string]interface{}{
 		"data": map[string]interface{}{
@@ -149,6 +173,20 @@ func TestPaginatedFormatter_Table(t *testing.T) {
 	}
 }
 
+func TestPaginatedFormatter_Pretty(t *testing.T) {
+	var buf bytes.Buffer
+	pf := NewPaginatedFormatter(&buf, FormatPretty)
+
+	pf.FormatPage([]interface{}{map[string]interface{}{"name": "Alice"}})
+	out := buf.String()
+	if !json.Valid([]byte(out)) {
+		t.Fatalf("paginated pretty output should be valid JSON, got:\n%s", out)
+	}
+	if !strings.Contains(out, "\n  {") || !strings.Contains(out, `"name": "Alice"`) {
+		t.Fatalf("paginated pretty output should be indented JSON, got:\n%s", out)
+	}
+}
+
 func TestPaginatedFormatter_CSV(t *testing.T) {
 	var buf bytes.Buffer
 	pf := NewPaginatedFormatter(&buf, FormatCSV)

internal/output/format_type.go

@@ -10,6 +10,7 @@ type Format int
 
 const (
 	FormatJSON Format = iota
+	FormatPretty
 	FormatNDJSON
 	FormatTable
 	FormatCSV
@@ -22,6 +23,8 @@ func ParseFormat(s string) (Format, bool) {
 	switch strings.ToLower(s) {
 	case "json", "":
 		return FormatJSON, true
+	case "pretty":
+		return FormatPretty, true
 	case "ndjson":
 		return FormatNDJSON, true
 	case "table":
@@ -36,6 +39,8 @@ func ParseFormat(s string) (Format, bool) {
 // String returns the string representation of a Format.
 func (f Format) String() string {
 	switch f {
+	case FormatPretty:
+		return "pretty"
 	case FormatNDJSON:
 		return "ndjson"
 	case FormatTable:

internal/output/format_type_test.go

@@ -14,6 +14,9 @@ func TestParseFormat(t *testing.T) {
 		{"json", FormatJSON, true},
 		{"JSON", FormatJSON, true},
 		{"Json", FormatJSON, true},
+		{"pretty", FormatPretty, true},
+		{"PRETTY", FormatPretty, true},
+		{"Pretty", FormatPretty, true},
 		{"ndjson", FormatNDJSON, true},
 		{"NDJSON", FormatNDJSON, true},
 		{"Ndjson", FormatNDJSON, true},
@@ -52,6 +55,7 @@ func TestFormatString(t *testing.T) {
 		want   string
 	}{
 		{FormatJSON, "json"},
+		{FormatPretty, "pretty"},
 		{FormatNDJSON, "ndjson"},
 		{FormatTable, "table"},
 		{FormatCSV, "csv"},

internal/qualitygate/cmd/manifest-export/collect.go

@@ -11,6 +11,7 @@ import (
 
 	rootcmd "github.com/larksuite/cli/cmd"
 	"github.com/larksuite/cli/internal/cmdmeta"
+	"github.com/larksuite/cli/internal/cmdpolicy"
 	"github.com/larksuite/cli/internal/cmdutil"
 	"github.com/larksuite/cli/internal/qualitygate/manifest"
 	"github.com/larksuite/cli/internal/registry"
@@ -94,7 +95,7 @@ func commandFromCobra(c *cobra.Command, defaultFields map[string][]string) manif
 		Short:         c.Short,
 		Example:       c.Example,
 		Hidden:        c.Hidden,
-		Runnable:      c.Runnable(),
+		Runnable:      c.Runnable() && !cmdpolicy.IsPureGroup(c),
 		Source:        source,
 		Generated:     cmdmeta.Generated(c),
 		Identities:    cmdmeta.Identities(c),

internal/qualitygate/cmd/manifest-export/main_test.go

@@ -90,6 +90,20 @@ func TestCollectContainsDocsFetchAndDryRunFlag(t *testing.T) {
 	}
 }
 
+func TestCollectMarksPureNavigationGroupsNonRunnable(t *testing.T) {
+	got, err := collectCommandIndex(context.Background())
+	if err != nil {
+		t.Fatalf("collectCommandIndex() error = %v", err)
+	}
+	cmd := findManifestCommand(&got, "approval")
+	if cmd == nil {
+		t.Fatalf("approval group not found")
+	}
+	if cmd.Runnable {
+		t.Fatalf("approval is a navigation group and must not be exported as runnable")
+	}
+}
+
 func TestCollectExcludesGeneratedServiceCommands(t *testing.T) {
 	got, err := collectHandAuthored(context.Background())
 	if err != nil {

internal/qualitygate/rules/dryrun.go

@@ -337,7 +337,7 @@ func fakeValueFromPlaceholderName(name string) (string, bool) {
 	case name == "open_id" || hasPlaceholderToken(tokens, "user", "owner", "participant", "approver", "speaker"):
 		return "ou_test123", true
 	case hasPlaceholderToken(tokens, "department", "dept"):
-		return "od-test123", true
+		return "od_test123", true
 	case hasPlaceholderToken(tokens, "message"):
 		return "om_test123", true
 	case name == "file_key":

internal/qualitygate/rules/dryrun_test.go

@@ -316,13 +316,6 @@ func TestRunDryRunsMaterializesInlinePlaceholderFlagValues(t *testing.T) {
 	}
 }
 
-func TestFakeValueFromPlaceholderNameUsesOpenDepartmentPrefix(t *testing.T) {
-	got, ok := fakeValueFromPlaceholderName("open_department_id")
-	if !ok || got != "od-test123" {
-		t.Fatalf("open_department_id placeholder = %q, %v; want od-test123, true", got, ok)
-	}
-}
-
 func TestRunDryRunsMaterializesNumericPlaceholderFlagValues(t *testing.T) {
 	cliBin, argsPath := fakeDryRunCLI(t, `{"api":[{"method":"GET","url":"/open-apis/vc/v1/bots/events","params":{"meeting_id":"400000000001","page_size":50}}]}`)
 	m := manifest.Manifest{Commands: []manifest.Command{{

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@larksuite/cli",
-  "version": "1.0.71",
+  "version": "1.0.69",
   "description": "The official CLI for Lark/Feishu open platform",
   "bin": {
     "lark-cli": "scripts/run.js"

shortcuts/apps/apps_access_scope_get_test.go

@@ -20,7 +20,7 @@ func TestAppsAccessScopeGet_Specific(t *testing.T) {
 			"data": map[string]interface{}{
 				"scope":       "Range",
 				"users":       []interface{}{"ou_x", "ou_y"},
-				"departments": []interface{}{"od-z"},
+				"departments": []interface{}{"od_z"},
 				"chats":       []interface{}{"oc_g"},
 				"apply_config": map[string]interface{}{
 					"enabled":   true,
@@ -39,7 +39,7 @@ func TestAppsAccessScopeGet_Specific(t *testing.T) {
 	if !strings.Contains(got, `"scope": "Range"`) {
 		t.Fatalf("scope string not preserved (expect raw \"Range\"): %s", got)
 	}
-	if !strings.Contains(got, `"ou_x"`) || !strings.Contains(got, `"od-z"`) || !strings.Contains(got, `"oc_g"`) {
+	if !strings.Contains(got, `"ou_x"`) || !strings.Contains(got, `"od_z"`) || !strings.Contains(got, `"oc_g"`) {
 		t.Fatalf("users/departments/chats fields missing in envelope: %s", got)
 	}
 	if !strings.Contains(got, `"ou_appr"`) {

shortcuts/apps/apps_automation_create.go

@@ -1,253 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package apps
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"io"
-	"net"
-	"strings"
-
-	"github.com/larksuite/cli/shortcuts/common"
-)
-
-// AppsAutomationCreate creates an automation trigger (type-dispatched condition).
-var AppsAutomationCreate = common.Shortcut{
-	Service:     appsService,
-	Command:     "+automation-create",
-	Description: "Create an automation trigger (cron/record-change/webhook/feishu-approval); created disabled",
-	Risk:        "write",
-	Tips: []string{
-		"Example: lark-cli apps +automation-create --app-id <id> --name daily --trigger-type cron --cron '0 9 * * *'",
-		"Example: lark-cli apps +automation-create --app-id <id> --name onUpd --trigger-type record-change --table <tbl> --event UPDATE",
-		"Example: lark-cli apps +automation-create --app-id <id> --name hook --trigger-type webhook",
-		"Example: lark-cli apps +automation-create --app-id <id> --name apv --trigger-type feishu-approval --event-type approval_instance --instance-status APPROVED",
-	},
-	Scopes:    []string{"spark:app:write"},
-	AuthTypes: []string{"user"},
-	HasFormat: true,
-	Flags: []common.Flag{
-		{Name: "app-id", Desc: "Miaoda app id", Required: true},
-		{Name: "name", Desc: "trigger name (unique within app, <=100 chars)", Required: true},
-		{Name: "trigger-type", Desc: "cron | record-change | webhook | feishu-approval", Required: true},
-		{Name: "description", Desc: "optional description (<=50 chars)"},
-		{Name: "cron", Desc: "[cron] 5-field cron expression, e.g. '0 9 * * *' (min interval 30m)"},
-		{Name: "timezone", Desc: "[cron] IANA timezone (default Asia/Shanghai)"},
-		{Name: "table", Desc: "[record-change] table name (from `+db-table-list`); dataloom tables key by name, not id"},
-		{Name: "event", Desc: "[record-change] INSERT | UPDATE | UPSERT | DELETE"},
-		{Name: "fields", Desc: "[record-change] JSON array of field ids for UPDATE/UPSERT, [\"*\"] = all"},
-		{Name: "white-ip-list", Desc: "[webhook] JSON array of allowed IPs"},
-		{Name: "approval-code", Desc: "[feishu-approval] approval definition code; omit to match all approval definitions"},
-		{Name: "event-type", Desc: "[feishu-approval] approval_instance | approval_task"},
-		{Name: "instance-status", Type: "string_array", Desc: "[feishu-approval] statuses for approval_instance"},
-		{Name: "task-status", Type: "string_array", Desc: "[feishu-approval] statuses for approval_task"},
-		{Name: "status", Desc: "optional initial status: enabled | disabled (default disabled; backend supports create+enable in one call)"},
-	},
-	Validate: func(ctx context.Context, rctx *common.RuntimeContext) error {
-		if _, err := requireAppID(rctx.Str("app-id")); err != nil {
-			return err
-		}
-		if strings.TrimSpace(rctx.Str("name")) == "" {
-			return appsValidationParamError("--name", "--name is required")
-		}
-		cliType := strings.TrimSpace(rctx.Str("trigger-type"))
-		if cliType == "" {
-			return appsValidationParamError("--trigger-type", "--trigger-type is required (cron/record-change/webhook/feishu-approval)")
-		}
-		// mapTriggerType also runs inside buildAutomationCreateBody, but
-		// re-running it up-front keeps the cross-family guard's error
-		// reachable — otherwise an unknown --trigger-type would bail out
-		// with the same guard's "belongs to trigger-type" wording, which
-		// misleads callers who typoed the type itself.
-		if _, err := mapTriggerType(cliType); err != nil {
-			return err
-		}
-		// Reject condition flags that do not belong to the selected type.
-		// buildAutomationCreateBody's switch used to silently drop them
-		// (e.g. --trigger-type webhook --cron '0 9 * * *' created a webhook
-		// with no cron, though the caller believed --cron was set).
-		if err := rejectCrossFamilyCondFlags(rctx, cliType); err != nil {
-			return err
-		}
-		_, err := buildAutomationCreateBody(rctx)
-		return err
-	},
-	DryRun: func(ctx context.Context, rctx *common.RuntimeContext) *common.DryRunAPI {
-		appID, _ := requireAppID(rctx.Str("app-id"))
-		body, _ := buildAutomationCreateBody(rctx)
-		return common.NewDryRunAPI().
-			POST(automationListPath(appID)).
-			Desc("Create automation trigger").
-			Body(body)
-	},
-	Execute: func(ctx context.Context, rctx *common.RuntimeContext) error {
-		appID, err := requireAppID(rctx.Str("app-id"))
-		if err != nil {
-			return err
-		}
-		body, err := buildAutomationCreateBody(rctx)
-		if err != nil {
-			return err
-		}
-		data, err := rctx.CallAPITyped("POST", automationListPath(appID), nil, body)
-		if err != nil {
-			return withAppsHint(err, appIDListHint)
-		}
-		// Bearer-token redaction reverse invariant: the backend create path
-		// re-reads the freshly created trigger through the same read-path
-		// converter used by get/list — theoretically capable of returning a
-		// plaintext bearer token. On a fresh create the token is not yet
-		// enabled and this response should not carry plaintext, but redact
-		// for defense-in-depth and to keep every read-shaped output path
-		// (create / get / list / update-patch) consistently scrubbed.
-		redacted := redactWebhookToken(data)
-		trigger, _ := redacted["trigger"].(map[string]interface{})
-		rctx.OutFormat(redacted, nil, func(w io.Writer) {
-			fmt.Fprintf(w, "created trigger: %v  [%v]  status: %v\n",
-				trigger["name"], trigger["trigger_type"], trigger["status"])
-		})
-		return nil
-	},
-}
-
-// buildAutomationCreateBody assembles {name, description?, trigger_type, <type>_condition}.
-func buildAutomationCreateBody(rctx *common.RuntimeContext) (map[string]interface{}, error) {
-	cliType := strings.TrimSpace(rctx.Str("trigger-type"))
-	snake, err := mapTriggerType(cliType)
-	if err != nil {
-		return nil, err
-	}
-	name := strings.TrimSpace(rctx.Str("name"))
-	if err := validateAutomationNameLen(name); err != nil {
-		return nil, err
-	}
-	body := map[string]interface{}{
-		"name":         name,
-		"trigger_type": snake,
-	}
-	if d := strings.TrimSpace(rctx.Str("description")); d != "" {
-		if err := validateAutomationDescriptionLen(d); err != nil {
-			return nil, err
-		}
-		body["description"] = d
-	}
-	// --status is an optional passthrough: when set, backend creates + enables
-	// (or leaves disabled) in one call. Omitting the field lets the backend
-	// default (disabled) apply, matching the spec's default-disabled invariant.
-	if s := strings.TrimSpace(rctx.Str("status")); s != "" {
-		if s != "enabled" && s != "disabled" {
-			return nil, appsValidationParamError("--status",
-				"--status must be enabled or disabled, got %q", s)
-		}
-		body["status"] = s
-	}
-	switch cliType {
-	case "cron":
-		cond, err := buildCronCondition(rctx.Str("cron"), rctx.Str("timezone"))
-		if err != nil {
-			return nil, err
-		}
-		body["cron_condition"] = cond
-	case "record-change":
-		fields, err := parseFieldsFlag(rctx.Str("fields"))
-		if err != nil {
-			return nil, err
-		}
-		cond, err := buildRecordChangeCondition(rctx.Str("table"), rctx.Str("event"), fields)
-		if err != nil {
-			return nil, err
-		}
-		body["record_change_condition"] = cond
-	case "webhook":
-		ipList, err := parseIPListFlag(rctx.Str("white-ip-list"))
-		if err != nil {
-			return nil, err
-		}
-		body["webhook_condition"] = buildWebhookCondition(ipList)
-	case "feishu-approval":
-		eventType := strings.TrimSpace(rctx.Str("event-type"))
-		if eventType == "" {
-			return nil, appsValidationParamError("--event-type", "--event-type is required for feishu-approval (approval_instance/approval_task)")
-		}
-		raw := rctx.StrArray("instance-status")
-		if eventType == "approval_task" {
-			raw = rctx.StrArray("task-status")
-		}
-		// buildApprovalCondition stores the passed statuses verbatim (it only
-		// uppercases for validation), so normalize to the uppercase enum here to
-		// guarantee the backend receives canonical values (foundation review).
-		statuses := normalizeApprovalStatuses(raw)
-		cond, err := buildApprovalCondition(rctx.Str("approval-code"), eventType, statuses)
-		if err != nil {
-			return nil, err
-		}
-		body["feishu_approval_condition"] = cond
-	}
-	return body, nil
-}
-
-// normalizeApprovalStatuses trims and uppercases each status so the body carries
-// the canonical enum values expected by the backend.
-func normalizeApprovalStatuses(raw []string) []string {
-	if len(raw) == 0 {
-		return raw
-	}
-	out := make([]string, 0, len(raw))
-	for _, s := range raw {
-		out = append(out, strings.ToUpper(strings.TrimSpace(s)))
-	}
-	return out
-}
-
-// parseFieldsFlag parses --fields JSON array; empty → nil.
-func parseFieldsFlag(raw string) ([]string, error) {
-	raw = strings.TrimSpace(raw)
-	if raw == "" {
-		return nil, nil
-	}
-	var arr []string
-	if err := json.Unmarshal([]byte(raw), &arr); err != nil {
-		return nil, appsValidationParamError("--fields", "--fields must be a JSON array of strings: %v", err)
-	}
-	return arr, nil
-}
-
-// parseIPListFlag parses --white-ip-list JSON array; empty → nil (field
-// omitted). Each entry is validated as an IPv4/IPv6 address or CIDR, matching
-// the defense-in-depth stance the record-change --event whitelist takes —
-// silent acceptance of malformed IPs would let a typoed entry (`"1.1.1.1 "`
-// with trailing space, `"not-an-ip"`, or `"10.0.0.256"`) narrow the webhook
-// caller allowlist to nothing while the operator believes it is enforcing
-// origin restrictions.
-func parseIPListFlag(raw string) ([]string, error) {
-	raw = strings.TrimSpace(raw)
-	if raw == "" {
-		return nil, nil
-	}
-	var arr []string
-	if err := json.Unmarshal([]byte(raw), &arr); err != nil {
-		return nil, appsValidationParamError("--white-ip-list", "--white-ip-list must be a JSON array of strings: %v", err)
-	}
-	out := make([]string, 0, len(arr))
-	for i, entry := range arr {
-		trimmed := strings.TrimSpace(entry)
-		if trimmed == "" {
-			return nil, appsValidationParamError("--white-ip-list",
-				"--white-ip-list entry %d is empty; either drop it or provide a valid IP/CIDR", i)
-		}
-		if net.ParseIP(trimmed) != nil {
-			out = append(out, trimmed)
-			continue
-		}
-		if _, _, cidrErr := net.ParseCIDR(trimmed); cidrErr == nil {
-			out = append(out, trimmed)
-			continue
-		}
-		return nil, appsValidationParamError("--white-ip-list",
-			"--white-ip-list entry %d %q is not a valid IPv4/IPv6 address or CIDR block", i, entry)
-	}
-	return out, nil
-}

shortcuts/apps/apps_automation_create_test.go

@@ -1,265 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package apps
-
-import (
-	"context"
-	"strings"
-	"testing"
-
-	"github.com/larksuite/cli/internal/httpmock"
-)
-
-func automationCreateFlagDefs() map[string]string {
-	return map[string]string{
-		"app-id": "string", "name": "string", "trigger-type": "string", "description": "string",
-		"cron": "string", "timezone": "string",
-		"table": "string", "event": "string", "fields": "string",
-		"white-ip-list": "string",
-		"approval-code": "string", "event-type": "string",
-		"instance-status": "string_array", "task-status": "string_array",
-		"status": "string",
-	}
-}
-
-func TestAutomationCreateCron_BuildsBody(t *testing.T) {
-	rctx, stdoutBuf, reg := newOpenAPIKeyRCtx(t, automationCreateFlagDefs(),
-		map[string]string{"app-id": "app_x", "name": "daily", "trigger-type": "cron", "cron": "0 9 * * *"})
-	// Real backend response wraps the created trigger under `trigger` (a live
-	// test-env probe confirmed the shape, same as GET/PUT). The Execute pretty
-	// path reads trigger["name"]/["trigger_type"]/["status"] from that key —
-	// a flat fixture makes the pretty path print `<nil>` and only passes via
-	// the JSON envelope, which hides regressions in the pretty branch.
-	reg.Register(&httpmock.Stub{
-		Method: "POST", URL: "/open-apis/spark/v1/apps/app_x/triggers",
-		Body: map[string]interface{}{"code": 0, "data": map[string]interface{}{
-			"trigger": map[string]interface{}{
-				"name": "daily", "trigger_type": "cron", "status": "disabled",
-			},
-		}},
-	})
-	if err := AppsAutomationCreate.Execute(context.Background(), rctx); err != nil {
-		t.Fatalf("Execute() = %v", err)
-	}
-	if !strings.Contains(stdoutBuf.String(), "daily") {
-		t.Errorf("create output must contain trigger name: %s", stdoutBuf.String())
-	}
-}
-
-func TestAutomationCreate_MissingType(t *testing.T) {
-	rctx, _, _ := newOpenAPIKeyRCtx(t, automationCreateFlagDefs(),
-		map[string]string{"app-id": "app_x", "name": "n"})
-	err := AppsAutomationCreate.Validate(context.Background(), rctx)
-	assertValidationParamError(t, err, "--trigger-type")
-}
-
-// TestAutomationCreate_CrossFamilyFlagsRejected pins the F1 guard: a condition
-// flag from a family other than --trigger-type used to be silently dropped by
-// buildAutomationCreateBody's single-branch switch, so
-// `--trigger-type webhook --cron '0 9 * * *'` created a webhook with no cron
-// but returned success. Validate now rejects the cross-family flag up-front.
-func TestAutomationCreate_CrossFamilyFlagsRejected(t *testing.T) {
-	cases := []struct {
-		name      string
-		flags     map[string]string
-		wantParam string
-	}{
-		{"webhook_with_cron",
-			map[string]string{
-				"app-id": "app_x", "name": "n", "trigger-type": "webhook",
-				"cron": "0 9 * * *",
-			}, "--cron"},
-		{"cron_with_white_ip_list",
-			map[string]string{
-				"app-id": "app_x", "name": "n", "trigger-type": "cron",
-				"cron": "0 9 * * *", "white-ip-list": `["1.1.1.1"]`,
-			}, "--white-ip-list"},
-		{"record_change_with_event_type",
-			map[string]string{
-				"app-id": "app_x", "name": "n", "trigger-type": "record-change",
-				"table": "tbl", "event": "UPDATE", "event-type": "approval_instance",
-			}, "--event-type"},
-		{"feishu_approval_with_table",
-			map[string]string{
-				"app-id": "app_x", "name": "n", "trigger-type": "feishu-approval",
-				"event-type": "approval_instance", "instance-status": "APPROVED",
-				"table": "tbl",
-			}, "--table"},
-	}
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			rctx, _, _ := newOpenAPIKeyRCtx(t, automationCreateFlagDefs(), tc.flags)
-			err := AppsAutomationCreate.Validate(context.Background(), rctx)
-			assertValidationParamError(t, err, tc.wantParam)
-		})
-	}
-}
-
-// TestAutomationCreate_UnknownTriggerTypeRejected: --trigger-type must be one
-// of the four supported kebab-case values. A typo used to sneak past Validate
-// (buildAutomationCreateBody caught it, but only after the cross-family guard
-// would otherwise fire with a misleading "belongs to type" message).
-func TestAutomationCreate_UnknownTriggerTypeRejected(t *testing.T) {
-	rctx, _, _ := newOpenAPIKeyRCtx(t, automationCreateFlagDefs(),
-		map[string]string{"app-id": "app_x", "name": "n", "trigger-type": "bogus"})
-	err := AppsAutomationCreate.Validate(context.Background(), rctx)
-	assertValidationParamError(t, err, "--trigger-type")
-}
-
-func TestAutomationCreateCron_Sub30MinRejected(t *testing.T) {
-	rctx, _, _ := newOpenAPIKeyRCtx(t, automationCreateFlagDefs(),
-		map[string]string{"app-id": "app_x", "name": "n", "trigger-type": "cron", "cron": "*/5 * * * *"})
-	err := AppsAutomationCreate.Validate(context.Background(), rctx)
-	assertValidationParamError(t, err, "--cron")
-}
-
-func TestAutomationCreateRecordChange_MissingEvent(t *testing.T) {
-	rctx, _, _ := newOpenAPIKeyRCtx(t, automationCreateFlagDefs(),
-		map[string]string{"app-id": "app_x", "name": "n", "trigger-type": "record-change", "table": "tbl"})
-	err := AppsAutomationCreate.Validate(context.Background(), rctx)
-	assertValidationParamError(t, err, "--event")
-}
-
-func TestAutomationCreateApproval_CodeOptional(t *testing.T) {
-	rctx, _, reg := newOpenAPIKeyRCtx(t, automationCreateFlagDefs(),
-		map[string]string{"app-id": "app_x", "name": "n", "trigger-type": "feishu-approval",
-			"event-type": "approval_instance", "instance-status": "APPROVED"})
-	reg.Register(&httpmock.Stub{
-		Method: "POST", URL: "/open-apis/spark/v1/apps/app_x/triggers",
-		Body: map[string]interface{}{"code": 0, "data": map[string]interface{}{"name": "n", "status": "disabled"}},
-	})
-	if err := AppsAutomationCreate.Validate(context.Background(), rctx); err != nil {
-		t.Fatalf("approval without --approval-code must pass validation: %v", err)
-	}
-	if err := AppsAutomationCreate.Execute(context.Background(), rctx); err != nil {
-		t.Fatalf("Execute() = %v", err)
-	}
-}
-
-// TestAutomationCreateApproval_StatusUppercased asserts that a lowercase status
-// passed via --instance-status is normalized to the uppercase enum in the body
-// before it reaches the backend (foundation review: buildApprovalCondition stores
-// the raw statuses, so create must uppercase them itself).
-func TestAutomationCreateApproval_StatusUppercased(t *testing.T) {
-	rctx, _, _ := newOpenAPIKeyRCtx(t, automationCreateFlagDefs(),
-		map[string]string{"app-id": "app_x", "name": "n", "trigger-type": "feishu-approval",
-			"event-type": "approval_instance", "instance-status": "approved"})
-	body, err := buildAutomationCreateBody(rctx)
-	if err != nil {
-		t.Fatalf("buildAutomationCreateBody() = %v", err)
-	}
-	cond, ok := body["feishu_approval_condition"].(map[string]interface{})
-	if !ok {
-		t.Fatalf("feishu_approval_condition missing or wrong type: %+v", body)
-	}
-	statuses, ok := cond["status"].([]string)
-	if !ok {
-		t.Fatalf("status must be []string: %+v", cond)
-	}
-	if len(statuses) != 1 || statuses[0] != "APPROVED" {
-		t.Errorf("lowercase status must be uppercased to APPROVED, got %v", statuses)
-	}
-}
-
-// TestAutomationCreate_RedactsWebhookToken covers the bearer-token redaction
-// reverse invariant on the create path against the real response shape (a
-// live test-env probe confirmed POST wraps the trigger under a `trigger`
-// key, same as GET/PUT). The backend create path re-reads the freshly
-// created trigger and returns it through the same read-path converter used
-// by get/list — theoretically capable of returning a plaintext bearer
-// token. Defense-in-depth: CLI create must also redact so every read-shaped
-// output path is consistently scrubbed.
-func TestAutomationCreate_RedactsWebhookToken(t *testing.T) {
-	rctx, stdoutBuf, reg := newOpenAPIKeyRCtx(t, automationCreateFlagDefs(),
-		map[string]string{"app-id": "app_x", "name": "wh1", "trigger-type": "webhook"})
-	reg.Register(&httpmock.Stub{
-		Method: "POST", URL: "/open-apis/spark/v1/apps/app_x/triggers",
-		Body: map[string]interface{}{"code": 0, "data": map[string]interface{}{
-			"trigger": map[string]interface{}{
-				"name": "wh1", "trigger_type": "webhook", "status": "disabled",
-				"trigger_condition": map[string]interface{}{
-					"preview_url": "https://p", "runtime_url": "https://r",
-					"token_enabled": true, "token_value": "PLAINTEXT_CREATE_TOKEN",
-				},
-			},
-		}},
-	})
-	if err := AppsAutomationCreate.Execute(context.Background(), rctx); err != nil {
-		t.Fatalf("Execute() = %v", err)
-	}
-	out := stdoutBuf.String()
-	if strings.Contains(out, "PLAINTEXT_CREATE_TOKEN") {
-		t.Errorf("create must never surface plaintext token: %s", out)
-	}
-}
-
-// TestAutomationCreate_StatusPassthrough verifies --status is included in the
-// POST body when set. Backend supports create+enable in one call via the
-// optional status field; CLI passes it through unchanged.
-func TestAutomationCreate_StatusPassthrough(t *testing.T) {
-	rctx, _, _ := newOpenAPIKeyRCtx(t, automationCreateFlagDefs(),
-		map[string]string{
-			"app-id": "app_x", "name": "n", "trigger-type": "cron",
-			"cron": "0 9 * * *", "status": "enabled",
-		})
-	body, err := buildAutomationCreateBody(rctx)
-	if err != nil {
-		t.Fatalf("buildBody: %v", err)
-	}
-	if body["status"] != "enabled" {
-		t.Errorf("status = %v; want enabled", body["status"])
-	}
-}
-
-// TestAutomationCreate_StatusInvalid: only enabled/disabled accepted.
-func TestAutomationCreate_StatusInvalid(t *testing.T) {
-	rctx, _, _ := newOpenAPIKeyRCtx(t, automationCreateFlagDefs(),
-		map[string]string{
-			"app-id": "app_x", "name": "n", "trigger-type": "cron",
-			"cron": "0 9 * * *", "status": "bogus",
-		})
-	_, err := buildAutomationCreateBody(rctx)
-	assertValidationParamError(t, err, "--status")
-}
-
-// TestAutomationCreate_StatusOmitted: when --status is not set, body must not
-// carry a status field — backend applies its default (disabled).
-func TestAutomationCreate_StatusOmitted(t *testing.T) {
-	rctx, _, _ := newOpenAPIKeyRCtx(t, automationCreateFlagDefs(),
-		map[string]string{
-			"app-id": "app_x", "name": "n", "trigger-type": "cron",
-			"cron": "0 9 * * *",
-		})
-	body, err := buildAutomationCreateBody(rctx)
-	if err != nil {
-		t.Fatalf("buildBody: %v", err)
-	}
-	if _, present := body["status"]; present {
-		t.Errorf("status must be omitted when --status not set, got %v", body["status"])
-	}
-}
-
-// TestAutomationCreate_NameTooLong: --name > 100 chars is rejected locally with
-// a typed --name error, sparing the round trip to the backend.
-func TestAutomationCreate_NameTooLong(t *testing.T) {
-	rctx, _, _ := newOpenAPIKeyRCtx(t, automationCreateFlagDefs(),
-		map[string]string{
-			"app-id": "app_x", "name": strings.Repeat("n", automationNameMaxLen+1),
-			"trigger-type": "cron", "cron": "0 9 * * *",
-		})
-	_, err := buildAutomationCreateBody(rctx)
-	assertValidationParamError(t, err, "--name")
-}
-
-// TestAutomationCreate_DescriptionTooLong: --description > 50 chars is rejected
-// locally with a typed --description error.
-func TestAutomationCreate_DescriptionTooLong(t *testing.T) {
-	rctx, _, _ := newOpenAPIKeyRCtx(t, automationCreateFlagDefs(),
-		map[string]string{
-			"app-id": "app_x", "name": "n", "trigger-type": "cron",
-			"cron": "0 9 * * *", "description": strings.Repeat("d", automationDescriptionMaxLen+1),
-		})
-	_, err := buildAutomationCreateBody(rctx)
-	assertValidationParamError(t, err, "--description")
-}

shortcuts/apps/apps_automation_disable.go

@@ -1,38 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package apps
-
-import (
-	"context"
-	"strings"
-
-	"github.com/larksuite/cli/shortcuts/common"
-)
-
-// AppsAutomationDisable disables a trigger. Maps to the shared status endpoint.
-var AppsAutomationDisable = common.Shortcut{
-	Service:     appsService,
-	Command:     "+automation-disable",
-	Description: "Disable an automation trigger (stops auto-firing; does not delete)",
-	Risk:        "write",
-	Tips:        []string{"Example: lark-cli apps +automation-disable --app-id <id> --name <trigger_name>"},
-	Scopes:      []string{"spark:app:write"},
-	AuthTypes:   []string{"user"},
-	HasFormat:   true,
-	Flags: []common.Flag{
-		{Name: "app-id", Desc: "Miaoda app id", Required: true},
-		{Name: "name", Desc: "trigger name", Required: true},
-	},
-	Validate: automationValidateName,
-	DryRun: func(ctx context.Context, rctx *common.RuntimeContext) *common.DryRunAPI {
-		appID, _ := requireAppID(rctx.Str("app-id"))
-		return common.NewDryRunAPI().
-			PATCH(automationItemPath(appID, strings.TrimSpace(rctx.Str("name")))).
-			Desc("Disable automation trigger").
-			Body(statusBodyFromAction(false))
-	},
-	Execute: func(ctx context.Context, rctx *common.RuntimeContext) error {
-		return runAutomationStatus(rctx, false)
-	},
-}

shortcuts/apps/apps_automation_enable.go

@@ -1,70 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package apps
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"strings"
-
-	"github.com/larksuite/cli/shortcuts/common"
-)
-
-// AppsAutomationEnable enables (activates) a trigger. Maps to the shared status endpoint.
-var AppsAutomationEnable = common.Shortcut{
-	Service:     appsService,
-	Command:     "+automation-enable",
-	Description: "Enable (activate) an automation trigger",
-	Risk:        "write",
-	Tips:        []string{"Example: lark-cli apps +automation-enable --app-id <id> --name <trigger_name>"},
-	Scopes:      []string{"spark:app:write"},
-	AuthTypes:   []string{"user"},
-	HasFormat:   true,
-	Flags: []common.Flag{
-		{Name: "app-id", Desc: "Miaoda app id", Required: true},
-		{Name: "name", Desc: "trigger name", Required: true},
-	},
-	Validate: automationValidateName,
-	DryRun: func(ctx context.Context, rctx *common.RuntimeContext) *common.DryRunAPI {
-		appID, _ := requireAppID(rctx.Str("app-id"))
-		return common.NewDryRunAPI().
-			PATCH(automationItemPath(appID, strings.TrimSpace(rctx.Str("name")))).
-			Desc("Enable automation trigger").
-			Body(statusBodyFromAction(true))
-	},
-	Execute: func(ctx context.Context, rctx *common.RuntimeContext) error {
-		return runAutomationStatus(rctx, true)
-	},
-}
-
-// runAutomationStatus is shared by enable/disable: PATCH .../triggers/{name}
-// with {"status": ...}. The status change happens on the parent resource per
-// the backend OpenAPI spec (see reference Python samples in the trigger test
-// fixtures) — there is intentionally no /status sub-path; the sole nested
-// endpoints under a trigger are the webhook credential lifecycle
-// (/webhook/token/status, /webhook/token/reset, /webhook/url/reset).
-//
-// The status endpoint returns {"success": true} on success. Pretty output is
-// synthesized from rctx.name and the desired action, since the response
-// intentionally carries no trigger object to fish name/status from.
-func runAutomationStatus(rctx *common.RuntimeContext, enable bool) error {
-	appID, err := requireAppID(rctx.Str("app-id"))
-	if err != nil {
-		return err
-	}
-	name := strings.TrimSpace(rctx.Str("name"))
-	data, err := rctx.CallAPITyped("PATCH", automationItemPath(appID, name), nil, statusBodyFromAction(enable))
-	if err != nil {
-		return withAppsHint(err, automationNotFoundHint())
-	}
-	desiredStatus := "disabled"
-	if enable {
-		desiredStatus = "enabled"
-	}
-	rctx.OutFormat(data, nil, func(w io.Writer) {
-		fmt.Fprintf(w, "trigger %s status: %s\n", name, desiredStatus)
-	})
-	return nil
-}

shortcuts/apps/apps_automation_get.go

@@ -1,73 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package apps
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"strings"
-
-	"github.com/larksuite/cli/shortcuts/common"
-)
-
-// AppsAutomationGet gets a single trigger's full config (webhook token redacted).
-var AppsAutomationGet = common.Shortcut{
-	Service:     appsService,
-	Command:     "+automation-get",
-	Description: "Get an automation trigger's config (webhook Bearer Token redacted)",
-	Risk:        "read",
-	Tips: []string{
-		"Example: lark-cli apps +automation-get --app-id <app_id> --name <trigger_name>",
-	},
-	Scopes:    []string{"spark:app:read"},
-	AuthTypes: []string{"user"},
-	HasFormat: true,
-	Flags: []common.Flag{
-		{Name: "app-id", Desc: "Miaoda app id", Required: true},
-		{Name: "name", Desc: "trigger name", Required: true},
-	},
-	Validate: automationValidateName,
-	DryRun: func(ctx context.Context, rctx *common.RuntimeContext) *common.DryRunAPI {
-		appID, _ := requireAppID(rctx.Str("app-id"))
-		return common.NewDryRunAPI().
-			GET(automationItemPath(appID, strings.TrimSpace(rctx.Str("name")))).
-			Desc("Get automation trigger")
-	},
-	Execute: func(ctx context.Context, rctx *common.RuntimeContext) error {
-		appID, err := requireAppID(rctx.Str("app-id"))
-		if err != nil {
-			return err
-		}
-		name := strings.TrimSpace(rctx.Str("name"))
-		data, err := rctx.CallAPITyped("GET", automationItemPath(appID, name), nil, nil)
-		if err != nil {
-			return withAppsHint(err, automationNotFoundHint())
-		}
-		redacted := redactWebhookToken(data)
-		trigger, _ := redacted["trigger"].(map[string]interface{})
-		rctx.OutFormat(redacted, nil, func(w io.Writer) {
-			fmt.Fprintf(w, "name: %v\ntype: %v\nstatus: %v\n",
-				trigger["name"], trigger["trigger_type"], trigger["status"])
-		})
-		return nil
-	},
-}
-
-// automationValidateName validates --app-id and --name presence. Shared by get/update/enable/disable.
-func automationValidateName(ctx context.Context, rctx *common.RuntimeContext) error {
-	if _, err := requireAppID(rctx.Str("app-id")); err != nil {
-		return err
-	}
-	if strings.TrimSpace(rctx.Str("name")) == "" {
-		return appsValidationParamError("--name", "--name is required").
-			WithHint("find trigger names with `lark-cli apps +automation-list --app-id <app_id>`")
-	}
-	return nil
-}
-
-// automationNotFoundHint is the shared recovery hint when a trigger name may not exist.
-func automationNotFoundHint() string {
-	return "verify the trigger name with `lark-cli apps +automation-list --app-id <app_id>`"
-}

shortcuts/apps/apps_automation_get_test.go

@@ -1,117 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package apps
-
-import (
-	"context"
-	"strings"
-	"testing"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/internal/httpmock"
-)
-
-// TestAutomationGetExecute_RedactsWebhookToken pins the redaction invariant
-// against the actual backend response shape (verified against a live test
-// environment): GET wraps the trigger under a `trigger` key, so the CLI
-// must scrub token_value inside data.trigger.trigger_condition. A previous
-// implementation only scrubbed data.trigger_condition and silently no-op'd
-// here — this test would fail the moment someone reverts to top-level-only
-// scrubbing.
-func TestAutomationGetExecute_RedactsWebhookToken(t *testing.T) {
-	rctx, stdoutBuf, reg := newOpenAPIKeyRCtx(t,
-		map[string]string{"app-id": "string", "name": "string"},
-		map[string]string{"app-id": "app_x", "name": "wh1"})
-	reg.Register(&httpmock.Stub{
-		Method: "GET", URL: "/open-apis/spark/v1/apps/app_x/triggers/wh1",
-		Body: map[string]interface{}{"code": 0, "data": map[string]interface{}{
-			"trigger": map[string]interface{}{
-				"name": "wh1", "trigger_type": "webhook", "status": "enabled",
-				"trigger_condition": map[string]interface{}{
-					"preview_url": "https://p", "runtime_url": "https://r",
-					"token_enabled": true, "token_value": "PLAINTEXT_SECRET_NESTED",
-				},
-			},
-		}},
-	})
-	if err := AppsAutomationGet.Execute(context.Background(), rctx); err != nil {
-		t.Fatalf("Execute() = %v", err)
-	}
-	out := stdoutBuf.String()
-	if strings.Contains(out, "PLAINTEXT_SECRET_NESTED") {
-		t.Errorf("get must never surface plaintext token: %s", out)
-	}
-	if !strings.Contains(out, "token_enabled") {
-		t.Errorf("get must expose token_enabled: %s", out)
-	}
-}
-
-func TestAutomationGet_MissingName(t *testing.T) {
-	rctx, _, _ := newOpenAPIKeyRCtx(t,
-		map[string]string{"app-id": "string", "name": "string"},
-		map[string]string{"app-id": "app_x"})
-	err := AppsAutomationGet.Validate(context.Background(), rctx)
-	assertValidationParamError(t, err, "--name")
-}
-
-// TestAutomationGet_MissingAppID covers the sibling branch of Validate:
-// automationValidateName rejects an empty --app-id before checking --name.
-func TestAutomationGet_MissingAppID(t *testing.T) {
-	rctx, _, _ := newOpenAPIKeyRCtx(t,
-		map[string]string{"app-id": "string", "name": "string"},
-		map[string]string{"name": "t1"})
-	err := AppsAutomationGet.Validate(context.Background(), rctx)
-	assertValidationParamError(t, err, "--app-id")
-}
-
-// TestAutomationGet_APIErrorAttachesNotFoundHint covers the failure branch of
-// Execute: a business error on GET must surface typed and carry the
-// automation-list hint so the caller has a next step.
-func TestAutomationGet_APIErrorAttachesNotFoundHint(t *testing.T) {
-	rctx, _, reg := newOpenAPIKeyRCtx(t,
-		map[string]string{"app-id": "string", "name": "string"},
-		map[string]string{"app-id": "app_x", "name": "missing"})
-	reg.Register(&httpmock.Stub{
-		Method: "GET", URL: "/open-apis/spark/v1/apps/app_x/triggers/missing",
-		Body: map[string]interface{}{"code": 400400001, "msg": "trigger not found"},
-	})
-	err := AppsAutomationGet.Execute(context.Background(), rctx)
-	if err == nil {
-		t.Fatal("expected typed api error, got nil")
-	}
-	p, ok := errs.ProblemOf(err)
-	if !ok {
-		t.Fatalf("expected typed problem, got %T: %v", err, err)
-	}
-	if p.Category != errs.CategoryAPI {
-		t.Errorf("category = %q, want %q", p.Category, errs.CategoryAPI)
-	}
-	if p.Subtype == "" {
-		t.Error("subtype must be populated on typed API errors")
-	}
-	if !strings.Contains(p.Hint, "+automation-list") {
-		t.Errorf("hint must point at +automation-list, got %q", p.Hint)
-	}
-}
-
-// TestAutomationGet_DryRunPreview exercises the DryRun closure and pins the
-// GET method + URL pattern that agents inspect before committing.
-func TestAutomationGet_DryRunPreview(t *testing.T) {
-	rctx, _, _ := newOpenAPIKeyRCtx(t,
-		map[string]string{"app-id": "string", "name": "string"},
-		map[string]string{"app-id": "app_x", "name": "t1"})
-	preview := AppsAutomationGet.DryRun(context.Background(), rctx)
-	if preview == nil {
-		t.Fatal("DryRun returned nil")
-	}
-	blob, err := preview.MarshalJSON()
-	if err != nil {
-		t.Fatalf("marshal preview: %v", err)
-	}
-	got := string(blob)
-	if !strings.Contains(got, `"method":"GET"`) ||
-		!strings.Contains(got, "/apps/app_x/triggers/t1") {
-		t.Errorf("preview missing expected GET/URL fields: %s", got)
-	}
-}

shortcuts/apps/apps_automation_list.go

@@ -1,159 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package apps
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"strings"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/shortcuts/common"
-)
-
-// AppsAutomationList lists an app's automation triggers (all 4 types).
-var AppsAutomationList = common.Shortcut{
-	Service:     appsService,
-	Command:     "+automation-list",
-	Description: "List a Miaoda app's automation triggers (cron/record-change/webhook/feishu-approval)",
-	Risk:        "read",
-	Tips: []string{
-		"Example: lark-cli apps +automation-list --app-id <app_id>",
-		"Example: lark-cli apps +automation-list --app-id <app_id> --trigger-type webhook",
-		"Example: lark-cli apps +automation-list --app-id <app_id> --all   # aggregate all pages",
-	},
-	Scopes:    []string{"spark:app:read"},
-	AuthTypes: []string{"user"},
-	HasFormat: true,
-	Flags: []common.Flag{
-		{Name: "app-id", Desc: "Miaoda app id", Required: true},
-		{Name: "trigger-type", Desc: "filter by type: cron | record-change | webhook | feishu-approval"},
-		{Name: "page-size", Type: "int", Desc: "page size (server default 50, max 100)"},
-		{Name: "page-token", Desc: "pagination cursor from previous response"},
-		{Name: "all", Type: "bool", Desc: "auto-aggregate all pages until has_more=false"},
-	},
-	Validate: func(ctx context.Context, rctx *common.RuntimeContext) error {
-		if _, err := requireAppID(rctx.Str("app-id")); err != nil {
-			return err
-		}
-		if tt := strings.TrimSpace(rctx.Str("trigger-type")); tt != "" {
-			if _, err := mapTriggerType(tt); err != nil {
-				return err
-			}
-		}
-		return nil
-	},
-	DryRun: func(ctx context.Context, rctx *common.RuntimeContext) *common.DryRunAPI {
-		appID, _ := requireAppID(rctx.Str("app-id"))
-		return common.NewDryRunAPI().
-			GET(automationListPath(appID)).
-			Desc("List automation triggers").
-			Params(buildAutomationListParams(rctx))
-	},
-	Execute: func(ctx context.Context, rctx *common.RuntimeContext) error {
-		appID, err := requireAppID(rctx.Str("app-id"))
-		if err != nil {
-			return err
-		}
-		path := automationListPath(appID)
-		params := buildAutomationListParams(rctx)
-		if rctx.Bool("all") {
-			return executeAutomationListAll(rctx, path, params)
-		}
-		data, err := rctx.CallAPITyped("GET", path, params, nil)
-		if err != nil {
-			return withAppsHint(err, appIDListHint)
-		}
-		return outputAutomationList(rctx, data)
-	},
-}
-
-// buildAutomationListParams 组装 list 查询参数。--trigger-type kebab→snake 下推给后端。
-func buildAutomationListParams(rctx *common.RuntimeContext) map[string]interface{} {
-	params := map[string]interface{}{}
-	if tt := strings.TrimSpace(rctx.Str("trigger-type")); tt != "" {
-		if snake, err := mapTriggerType(tt); err == nil {
-			params["trigger_type"] = snake
-		}
-	}
-	if rctx.Changed("page-size") {
-		params["page_size"] = rctx.Int("page-size")
-	}
-	if pt := strings.TrimSpace(rctx.Str("page-token")); pt != "" {
-		params["page_token"] = pt
-	}
-	return params
-}
-
-// executeAutomationListAll 循环翻页聚合到 has_more=false（禁止静默漏项）。
-// 用页数上限 + 已见 token 检测防止后端非收敛响应导致无限循环。
-const automationListAllMaxPages = 100
-
-func executeAutomationListAll(rctx *common.RuntimeContext, path string, params map[string]interface{}) error {
-	all := make([]interface{}, 0, 16)
-	seen := map[string]struct{}{}
-	token := ""
-	for pages := 0; ; pages++ {
-		if pages >= automationListAllMaxPages {
-			return errs.NewInternalError(errs.SubtypeInvalidResponse,
-				"pagination did not converge after %d pages", automationListAllMaxPages)
-		}
-		p := make(map[string]interface{}, len(params)+1)
-		for k, v := range params {
-			p[k] = v
-		}
-		if token != "" {
-			p["page_token"] = token
-		}
-		data, err := rctx.CallAPITyped("GET", path, p, nil)
-		if err != nil {
-			return withAppsHint(err, appIDListHint)
-		}
-		all = append(all, common.GetSlice(data, "items")...)
-		hasMore, next := common.PaginationMeta(data)
-		if !hasMore || next == "" {
-			break
-		}
-		if _, ok := seen[next]; ok {
-			return errs.NewInternalError(errs.SubtypeInvalidResponse,
-				"pagination did not converge: page_token %q repeated", next)
-		}
-		seen[next] = struct{}{}
-		token = next
-	}
-	out := map[string]interface{}{"items": all, "has_more": false}
-	return outputAutomationList(rctx, out)
-}
-
-// outputAutomationList 输出 items + 分页提示。逐条对 items 套 redactWebhookToken，
-// 抹掉 trigger_condition.token_value（list/get 恒不返回明文 Bearer Token）；
-// 同时覆盖单页与 --all 聚合路径（executeAutomationListAll 也走这里）。
-func outputAutomationList(rctx *common.RuntimeContext, data map[string]interface{}) error {
-	items := common.GetSlice(data, "items")
-	redacted := make([]interface{}, 0, len(items))
-	for _, it := range items {
-		if m, ok := it.(map[string]interface{}); ok {
-			redacted = append(redacted, redactWebhookToken(m))
-		} else {
-			redacted = append(redacted, it)
-		}
-	}
-	// 保留分页字段供 PaginationHint/PaginationMeta 读取（读的是同一个 map）。
-	out := map[string]interface{}{
-		"items":      redacted,
-		"has_more":   data["has_more"],
-		"page_token": data["page_token"],
-	}
-	rctx.OutFormat(out, nil, func(w io.Writer) {
-		fmt.Fprintf(w, "%d trigger(s)\n", len(redacted))
-		for _, it := range redacted {
-			if m, ok := it.(map[string]interface{}); ok {
-				fmt.Fprintf(w, "- %v  [%v]  %v\n", m["name"], m["trigger_type"], m["status"])
-			}
-		}
-		fmt.Fprint(w, common.PaginationHint(out, len(redacted)))
-	})
-	return nil
-}

shortcuts/apps/apps_automation_list_test.go

@@ -1,219 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package apps
-
-import (
-	"context"
-	"strings"
-	"testing"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/internal/httpmock"
-)
-
-func automationListFlagDefs() map[string]string {
-	return map[string]string{
-		"app-id": "string", "trigger-type": "string",
-		"page-size": "int", "page-token": "string", "all": "bool",
-	}
-}
-
-// TestAutomationList_InvalidTriggerTypeFilter covers Validate's mapTriggerType
-// error branch: an unknown --trigger-type is rejected before any API call, with
-// a typed error naming the failing flag.
-func TestAutomationList_InvalidTriggerTypeFilter(t *testing.T) {
-	rctx, _, _ := newOpenAPIKeyRCtx(t, automationListFlagDefs(),
-		map[string]string{"app-id": "app_x", "trigger-type": "bogus"})
-	err := AppsAutomationList.Validate(context.Background(), rctx)
-	assertValidationParamError(t, err, "--trigger-type")
-}
-
-// TestAutomationListExecute_APIErrorAttachesAppIDHint covers the non-`--all`
-// error branch: a business error is surfaced typed and carries appIDListHint,
-// which points at +list rather than +automation-list because the recovery for
-// a failing collection GET is "check your app-id", not "check trigger names".
-func TestAutomationListExecute_APIErrorAttachesAppIDHint(t *testing.T) {
-	rctx, _, reg := newOpenAPIKeyRCtx(t, automationListFlagDefs(),
-		map[string]string{"app-id": "app_x"})
-	reg.Register(&httpmock.Stub{
-		Method: "GET", URL: "/open-apis/spark/v1/apps/app_x/triggers",
-		Body: map[string]interface{}{"code": 400400002, "msg": "app not accessible"},
-	})
-	err := AppsAutomationList.Execute(context.Background(), rctx)
-	if err == nil {
-		t.Fatal("expected typed api error, got nil")
-	}
-	p, ok := errs.ProblemOf(err)
-	if !ok {
-		t.Fatalf("expected typed problem, got %T: %v", err, err)
-	}
-	if p.Category != errs.CategoryAPI {
-		t.Errorf("category = %q, want %q", p.Category, errs.CategoryAPI)
-	}
-	if p.Subtype == "" {
-		t.Error("subtype must be populated on typed API errors")
-	}
-	if !strings.Contains(p.Hint, "apps +list") {
-		t.Errorf("hint must point at `lark-cli apps +list`, got %q", p.Hint)
-	}
-}
-
-// TestAutomationList_DryRunPreview exercises the DryRun closure — pins the GET
-// method + collection URL + trigger_type param pushdown.
-func TestAutomationList_DryRunPreview(t *testing.T) {
-	rctx, _, _ := newOpenAPIKeyRCtx(t, automationListFlagDefs(),
-		map[string]string{"app-id": "app_x", "trigger-type": "webhook"})
-	preview := AppsAutomationList.DryRun(context.Background(), rctx)
-	if preview == nil {
-		t.Fatal("DryRun returned nil")
-	}
-	blob, err := preview.MarshalJSON()
-	if err != nil {
-		t.Fatalf("marshal preview: %v", err)
-	}
-	got := string(blob)
-	if !strings.Contains(got, `"method":"GET"`) ||
-		!strings.Contains(got, "/apps/app_x/triggers") ||
-		!strings.Contains(got, `"trigger_type":"webhook"`) {
-		t.Errorf("preview missing expected GET/URL/params: %s", got)
-	}
-}
-
-func TestAutomationListMeta(t *testing.T) {
-	if AppsAutomationList.Command != "+automation-list" || AppsAutomationList.Risk != "read" {
-		t.Errorf("meta mismatch: %+v", AppsAutomationList)
-	}
-	if len(AppsAutomationList.Scopes) != 1 || AppsAutomationList.Scopes[0] != "spark:app:read" {
-		t.Errorf("scopes = %v", AppsAutomationList.Scopes)
-	}
-}
-
-func TestAutomationListExecute_SinglePage(t *testing.T) {
-	rctx, stdoutBuf, reg := newOpenAPIKeyRCtx(t, automationListFlagDefs(),
-		map[string]string{"app-id": "app_x"})
-	reg.Register(&httpmock.Stub{
-		Method: "GET", URL: "/open-apis/spark/v1/apps/app_x/triggers",
-		Body: map[string]interface{}{"code": 0, "msg": "", "data": map[string]interface{}{
-			"items": []interface{}{
-				map[string]interface{}{"name": "t_cron", "trigger_type": "cron", "status": "disabled"},
-				map[string]interface{}{"name": "t_wh", "trigger_type": "webhook", "status": "enabled"},
-			},
-			"has_more": false, "page_token": "",
-		}},
-	})
-	if err := AppsAutomationList.Execute(context.Background(), rctx); err != nil {
-		t.Fatalf("Execute() = %v", err)
-	}
-	out := stdoutBuf.String()
-	if !strings.Contains(out, "t_cron") || !strings.Contains(out, "t_wh") {
-		t.Errorf("list must contain both triggers: %s", out)
-	}
-}
-
-// --all aggregates every page until has_more=false. httpmock.Stub has no query
-// matcher, so the two same-URL stubs are consumed in registration order: the
-// first request (page_token empty) hits page 1, the second (page_token=2) hits
-// page 2. See registry.match — a matched non-reusable stub is not reused.
-func TestAutomationListExecute_AllAggregatesPages(t *testing.T) {
-	rctx, stdoutBuf, reg := newOpenAPIKeyRCtx(t, automationListFlagDefs(),
-		map[string]string{"app-id": "app_x", "all": "true"})
-	// page 1: has_more=true, page_token="2"
-	reg.Register(&httpmock.Stub{
-		Method: "GET", URL: "/open-apis/spark/v1/apps/app_x/triggers",
-		Body: map[string]interface{}{"code": 0, "data": map[string]interface{}{
-			"items":    []interface{}{map[string]interface{}{"name": "p1", "trigger_type": "cron", "status": "disabled"}},
-			"has_more": true, "page_token": "2",
-		}},
-	})
-	// page 2: has_more=false
-	reg.Register(&httpmock.Stub{
-		Method: "GET", URL: "/open-apis/spark/v1/apps/app_x/triggers",
-		Body: map[string]interface{}{"code": 0, "data": map[string]interface{}{
-			"items":    []interface{}{map[string]interface{}{"name": "p2", "trigger_type": "webhook", "status": "enabled"}},
-			"has_more": false, "page_token": "",
-		}},
-	})
-	if err := AppsAutomationList.Execute(context.Background(), rctx); err != nil {
-		t.Fatalf("Execute() = %v", err)
-	}
-	out := stdoutBuf.String()
-	if !strings.Contains(out, "p1") || !strings.Contains(out, "p2") {
-		t.Errorf("--all must aggregate both pages: %s", out)
-	}
-}
-
-func TestAutomationListParams_TriggerTypePushdown(t *testing.T) {
-	rctx, _, _ := newOpenAPIKeyRCtx(t, automationListFlagDefs(),
-		map[string]string{"app-id": "app_x", "trigger-type": "webhook"})
-	params := buildAutomationListParams(rctx)
-	if params["trigger_type"] != "webhook" {
-		t.Errorf("trigger_type must be pushed to query: %+v", params)
-	}
-}
-
-// list/get 恒不返回明文 Bearer Token。webhook item 的
-// trigger_condition.token_value 必须逐条脱敏，token_enabled 保留。
-func TestAutomationListExecute_RedactsWebhookToken(t *testing.T) {
-	rctx, stdoutBuf, reg := newOpenAPIKeyRCtx(t, automationListFlagDefs(),
-		map[string]string{"app-id": "app_x"})
-	reg.Register(&httpmock.Stub{
-		Method: "GET", URL: "/open-apis/spark/v1/apps/app_x/triggers",
-		Body: map[string]interface{}{"code": 0, "msg": "", "data": map[string]interface{}{
-			"items": []interface{}{
-				map[string]interface{}{
-					"name": "t_wh", "trigger_type": "webhook", "status": "enabled",
-					"trigger_condition": map[string]interface{}{
-						"preview_url": "https://p", "runtime_url": "https://r",
-						"token_enabled": true, "token_value": "PLAINTEXT_LIST_TOKEN",
-					},
-				},
-			},
-			"has_more": false, "page_token": "",
-		}},
-	})
-	if err := AppsAutomationList.Execute(context.Background(), rctx); err != nil {
-		t.Fatalf("Execute() = %v", err)
-	}
-	out := stdoutBuf.String()
-	if strings.Contains(out, "PLAINTEXT_LIST_TOKEN") {
-		t.Errorf("list must never surface plaintext token: %s", out)
-	}
-	if !strings.Contains(out, "token_enabled") {
-		t.Errorf("list must expose token_enabled: %s", out)
-	}
-}
-
-// A4: --all must refuse to loop forever when the backend keeps returning the
-// same page_token. A reusable stub that always advertises "has_more=true,
-// page_token=same" forces the seen-token guard to trip.
-func TestAutomationListExecute_All_DetectsRepeatedPageToken(t *testing.T) {
-	rctx, _, reg := newOpenAPIKeyRCtx(t, automationListFlagDefs(),
-		map[string]string{"app-id": "app_x", "all": "true"})
-	reg.Register(&httpmock.Stub{
-		Method: "GET", URL: "/open-apis/spark/v1/apps/app_x/triggers",
-		Reusable: true,
-		Body: map[string]interface{}{"code": 0, "data": map[string]interface{}{
-			"items":    []interface{}{map[string]interface{}{"name": "p", "trigger_type": "cron", "status": "disabled"}},
-			"has_more": true, "page_token": "stuck",
-		}},
-	})
-	err := AppsAutomationList.Execute(context.Background(), rctx)
-	// The seen-token detector must raise a typed internal/invalid_response error
-	// long before the caller sees a runaway loop.
-	assertInternalError(t, err, errs.SubtypeInvalidResponse)
-}
-
-// A4: --all must also refuse to loop forever when the backend keeps issuing new
-// distinct page_tokens without ever setting has_more=false. The page-cap kicks
-// in at automationListAllMaxPages. Simulated by a reusable stub advertising a
-// fresh non-repeating token via monotonically increasing counter — but since
-// httpmock has no dynamic bodies, we lean on the fact that the same reusable
-// body advertises page_token="stuck" (the seen-token guard trips first). This
-// case is left to the sibling test above; the page-cap constant is asserted
-// here so a future refactor cannot silently drop the ceiling.
-func TestAutomationListAll_PageCapConstant(t *testing.T) {
-	if automationListAllMaxPages <= 0 || automationListAllMaxPages > 1000 {
-		t.Errorf("automationListAllMaxPages = %d; must be a small positive ceiling", automationListAllMaxPages)
-	}
-}

shortcuts/apps/apps_automation_registration_test.go

@@ -1,23 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package apps
-
-import "testing"
-
-func TestAutomationCommandsRegistered(t *testing.T) {
-	want := map[string]bool{
-		"+automation-list": false, "+automation-get": false, "+automation-create": false,
-		"+automation-update": false, "+automation-enable": false, "+automation-disable": false,
-	}
-	for _, sc := range Shortcuts() {
-		if _, ok := want[sc.Command]; ok {
-			want[sc.Command] = true
-		}
-	}
-	for cmd, found := range want {
-		if !found {
-			t.Errorf("shortcut %q not registered in Shortcuts()", cmd)
-		}
-	}
-}

shortcuts/apps/apps_automation_status_test.go

@@ -1,174 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package apps
-
-import (
-	"context"
-	"strings"
-	"testing"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/internal/httpmock"
-)
-
-func TestAutomationEnable_PostsEnabledStatus(t *testing.T) {
-	rctx, stdoutBuf, reg := newOpenAPIKeyRCtx(t,
-		map[string]string{"app-id": "string", "name": "string"},
-		map[string]string{"app-id": "app_x", "name": "t1"})
-	rctx.Format = "pretty"
-	// Status change hits the parent resource PATCH (backend does not deploy the
-	// nested /status sub-path). Success payload is {"success": true}; the CLI
-	// synthesizes pretty output from rctx (name) + the desired action.
-	reg.Register(&httpmock.Stub{
-		Method: "PATCH", URL: "/open-apis/spark/v1/apps/app_x/triggers/t1",
-		Body: map[string]interface{}{"code": 0, "data": map[string]interface{}{"success": true}},
-	})
-	if err := AppsAutomationEnable.Execute(context.Background(), rctx); err != nil {
-		t.Fatalf("Execute() = %v", err)
-	}
-	if !strings.Contains(stdoutBuf.String(), "trigger t1 status: enabled") {
-		t.Errorf("enable output = %q", stdoutBuf.String())
-	}
-}
-
-func TestAutomationDisable_PostsDisabledStatus(t *testing.T) {
-	rctx, stdoutBuf, reg := newOpenAPIKeyRCtx(t,
-		map[string]string{"app-id": "string", "name": "string"},
-		map[string]string{"app-id": "app_x", "name": "t1"})
-	rctx.Format = "pretty"
-	reg.Register(&httpmock.Stub{
-		Method: "PATCH", URL: "/open-apis/spark/v1/apps/app_x/triggers/t1",
-		Body: map[string]interface{}{"code": 0, "data": map[string]interface{}{"success": true}},
-	})
-	if err := AppsAutomationDisable.Execute(context.Background(), rctx); err != nil {
-		t.Fatalf("Execute() = %v", err)
-	}
-	if !strings.Contains(stdoutBuf.String(), "trigger t1 status: disabled") {
-		t.Errorf("disable output = %q", stdoutBuf.String())
-	}
-}
-
-func TestAutomationEnableDisableMeta(t *testing.T) {
-	if AppsAutomationEnable.Risk != "write" || AppsAutomationDisable.Risk != "write" {
-		t.Error("enable/disable must be Risk=write")
-	}
-	if AppsAutomationEnable.Command != "+automation-enable" || AppsAutomationDisable.Command != "+automation-disable" {
-		t.Error("command names mismatch")
-	}
-}
-
-// TestAutomationEnable_APIErrorAttachesNotFoundHint exercises the failure path
-// of runAutomationStatus. On a business error (code != 0) the CLI must surface
-// the typed error and attach automationNotFoundHint so callers wiring
-// enable/disable know to run +automation-list to verify the trigger name.
-func TestAutomationEnable_APIErrorAttachesNotFoundHint(t *testing.T) {
-	rctx, _, reg := newOpenAPIKeyRCtx(t,
-		map[string]string{"app-id": "string", "name": "string"},
-		map[string]string{"app-id": "app_x", "name": "missing"})
-	reg.Register(&httpmock.Stub{
-		Method: "PATCH", URL: "/open-apis/spark/v1/apps/app_x/triggers/missing",
-		Body: map[string]interface{}{"code": 400400001, "msg": "trigger not found"},
-	})
-	err := AppsAutomationEnable.Execute(context.Background(), rctx)
-	if err == nil {
-		t.Fatal("expected typed api error, got nil")
-	}
-	p, ok := errs.ProblemOf(err)
-	if !ok {
-		t.Fatalf("expected typed problem, got %T: %v", err, err)
-	}
-	// Per AGENTS.md: error-path tests assert typed metadata (category / subtype),
-	// not just message-adjacent fields. Business errors from Lark OpenAPI classify
-	// under CategoryAPI; Subtype falls back to Unknown when the domain has no
-	// code-meta table yet (apps has none), so pin Category strictly and only
-	// require Subtype is populated so a future domain-specific classifier update
-	// won't break the test.
-	if p.Category != errs.CategoryAPI {
-		t.Errorf("category = %q, want %q", p.Category, errs.CategoryAPI)
-	}
-	if p.Subtype == "" {
-		t.Error("subtype must be populated on typed API errors")
-	}
-	if p.Code != 400400001 {
-		t.Errorf("code = %d, want 400400001", p.Code)
-	}
-	if !strings.Contains(p.Hint, "+automation-list") {
-		t.Errorf("hint must point at +automation-list, got %q", p.Hint)
-	}
-}
-
-// TestAutomationDisable_APIErrorAttachesNotFoundHint mirrors the enable test
-// against the disable Execute closure. Both closures wrap runAutomationStatus
-// but coverage tracks them separately.
-func TestAutomationDisable_APIErrorAttachesNotFoundHint(t *testing.T) {
-	rctx, _, reg := newOpenAPIKeyRCtx(t,
-		map[string]string{"app-id": "string", "name": "string"},
-		map[string]string{"app-id": "app_x", "name": "missing"})
-	reg.Register(&httpmock.Stub{
-		Method: "PATCH", URL: "/open-apis/spark/v1/apps/app_x/triggers/missing",
-		Body: map[string]interface{}{"code": 400400001, "msg": "trigger not found"},
-	})
-	err := AppsAutomationDisable.Execute(context.Background(), rctx)
-	if err == nil {
-		t.Fatal("expected typed api error, got nil")
-	}
-	p, ok := errs.ProblemOf(err)
-	if !ok {
-		t.Fatalf("expected typed problem, got %T: %v", err, err)
-	}
-	if p.Category != errs.CategoryAPI {
-		t.Errorf("category = %q, want %q", p.Category, errs.CategoryAPI)
-	}
-	if p.Subtype == "" {
-		t.Error("subtype must be populated on typed API errors")
-	}
-	if p.Code != 400400001 {
-		t.Errorf("code = %d, want 400400001", p.Code)
-	}
-	if !strings.Contains(p.Hint, "+automation-list") {
-		t.Errorf("hint must point at +automation-list, got %q", p.Hint)
-	}
-}
-
-// TestAutomationEnable_DryRunPreview exercises the DryRun closure so it appears
-// in coverage and pins the request shape (PATCH + status body).
-func TestAutomationEnable_DryRunPreview(t *testing.T) {
-	rctx, _, _ := newOpenAPIKeyRCtx(t,
-		map[string]string{"app-id": "string", "name": "string"},
-		map[string]string{"app-id": "app_x", "name": "t1"})
-	preview := AppsAutomationEnable.DryRun(context.Background(), rctx)
-	if preview == nil {
-		t.Fatal("DryRun returned nil")
-	}
-	blob, err := preview.MarshalJSON()
-	if err != nil {
-		t.Fatalf("marshal preview: %v", err)
-	}
-	got := string(blob)
-	if !strings.Contains(got, `"method":"PATCH"`) ||
-		!strings.Contains(got, "/apps/app_x/triggers/t1") ||
-		!strings.Contains(got, `"status":"enabled"`) {
-		t.Errorf("preview missing expected PATCH/URL/body fields: %s", got)
-	}
-}
-
-func TestAutomationDisable_DryRunPreview(t *testing.T) {
-	rctx, _, _ := newOpenAPIKeyRCtx(t,
-		map[string]string{"app-id": "string", "name": "string"},
-		map[string]string{"app-id": "app_x", "name": "t1"})
-	preview := AppsAutomationDisable.DryRun(context.Background(), rctx)
-	if preview == nil {
-		t.Fatal("DryRun returned nil")
-	}
-	blob, err := preview.MarshalJSON()
-	if err != nil {
-		t.Fatalf("marshal preview: %v", err)
-	}
-	got := string(blob)
-	if !strings.Contains(got, `"method":"PATCH"`) ||
-		!strings.Contains(got, "/apps/app_x/triggers/t1") ||
-		!strings.Contains(got, `"status":"disabled"`) {
-		t.Errorf("preview missing expected PATCH/URL/body fields: %s", got)
-	}
-}

shortcuts/apps/apps_automation_update.go

@@ -1,385 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package apps
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"strings"
-
-	"github.com/larksuite/cli/shortcuts/common"
-)
-
-// AppsAutomationUpdate is the unified trigger-modify entry. Webhook URL/Token
-// actions dispatch to apps_automation_webhook.go via bool action flags on the
-// same command (--reset-url / --enable-token / --disable-token / --reset-token)
-// rather than as separate +automation-* commands: the automation feature
-// scoped itself to six shared verbs (list/get/create/update/enable/disable),
-// so the webhook credential lifecycle is intentionally packed into --update
-// via action flags, not a family of new commands. Otherwise Execute sends a
-// PUT to update the trigger condition.
-var AppsAutomationUpdate = common.Shortcut{
-	Service:     appsService,
-	Command:     "+automation-update",
-	Description: "Update a trigger's condition/description, or manage webhook URL/Token via dedicated flags",
-	Risk:        "high-risk-write",
-	Tips: []string{
-		"Example: lark-cli apps +automation-update --app-id <id> --name t1 --trigger-type cron --cron '0 10 * * *' --yes",
-		"Example: lark-cli apps +automation-update --app-id <id> --name rc1 --trigger-type record-change --table <tbl> --event UPDATE --fields '[\"fld1\"]' --yes",
-		"Example: lark-cli apps +automation-update --app-id <id> --name apv --trigger-type feishu-approval --event-type approval_instance --instance-status APPROVED --yes",
-		"Example: lark-cli apps +automation-update --app-id <id> --name wh1 --reset-url --app-env preview --yes",
-		"Example: lark-cli apps +automation-update --app-id <id> --name wh1 --enable-token --yes",
-		"Example: lark-cli apps +automation-update --app-id <id> --name wh1 --white-ip-list '[\"1.1.1.1\"]' --yes",
-	},
-	Scopes:    []string{"spark:app:write"},
-	AuthTypes: []string{"user"},
-	HasFormat: true,
-	Flags: []common.Flag{
-		{Name: "app-id", Desc: "Miaoda app id", Required: true},
-		{Name: "name", Desc: "trigger name", Required: true},
-		{Name: "trigger-type", Desc: "type of the trigger being updated (for condition PATCH)"},
-		{Name: "description", Desc: "new description"},
-		{Name: "cron", Desc: "[cron] new 5-field cron expression"},
-		{Name: "timezone", Desc: "[cron] new timezone"},
-		{Name: "table", Desc: "[record-change] table name (from `+db-table-list`); dataloom tables key by name, not id"},
-		{Name: "event", Desc: "[record-change] INSERT | UPDATE | UPSERT | DELETE"},
-		{Name: "fields", Desc: "[record-change] JSON array of field ids for UPDATE/UPSERT, [\"*\"] = all"},
-		{Name: "approval-code", Desc: "[feishu-approval] approval definition code; omit to match all approval definitions"},
-		{Name: "event-type", Desc: "[feishu-approval] approval_instance | approval_task"},
-		{Name: "instance-status", Type: "string_array", Desc: "[feishu-approval] statuses for approval_instance"},
-		{Name: "task-status", Type: "string_array", Desc: "[feishu-approval] statuses for approval_task"},
-		{Name: "white-ip-list", Desc: "[webhook] full replacement JSON array of allowed IPs"},
-		{Name: "reset-url", Type: "bool", Desc: "[webhook] rotate callback URL for --app-env (old URL invalidated)"},
-		{Name: "app-env", Desc: "[webhook] preview | runtime (required with --reset-url)"},
-		{Name: "enable-token", Type: "bool", Desc: "[webhook] enable bearer token (shown once)"},
-		{Name: "disable-token", Type: "bool", Desc: "[webhook] disable bearer token; re-enable generates a new token"},
-		{Name: "reset-token", Type: "bool", Desc: "[webhook] rotate bearer token (old token invalidated, shown once)"},
-	},
-	Validate: func(ctx context.Context, rctx *common.RuntimeContext) error {
-		if err := automationValidateName(ctx, rctx); err != nil {
-			return err
-		}
-		// --app-env is only consumed by --reset-url; on any other update path
-		// (other webhook action, condition update) it was silently dropped and
-		// dry-run happily previewed the request that DID reach the backend,
-		// misleading callers who inspected --dry-run before committing. Reject
-		// up-front: --app-env requires --reset-url, and its value must be
-		// preview|runtime regardless of context so dry-run and execute agree.
-		if appEnv := strings.TrimSpace(rctx.Str("app-env")); appEnv != "" {
-			if !rctx.Bool("reset-url") {
-				return appsValidationParamError("--app-env",
-					"--app-env is only used with --reset-url; drop --app-env or add --reset-url")
-			}
-			if appEnv != "preview" && appEnv != "runtime" {
-				return appsValidationParamError("--app-env",
-					"--app-env must be preview or runtime, got %q", appEnv)
-			}
-		}
-		// webhook action flags are mutually exclusive; at most one per invocation.
-		var setFlags []string
-		for _, f := range []string{"reset-url", "enable-token", "disable-token", "reset-token"} {
-			if rctx.Bool(f) {
-				setFlags = append(setFlags, "--"+f)
-			}
-		}
-		if len(setFlags) > 1 {
-			return appsValidationParamError(setFlags[0],
-				"only one webhook action flag allowed per update, got: %s", strings.Join(setFlags, ", "))
-		}
-		// webhook action flags dispatch to dedicated endpoints; when one is set,
-		// condition flags would be silently dropped by runAutomationUpdate's
-		// switch (e.g. `--reset-token --cron '0 9 * * *'` used to only reset the
-		// token). Reject that combination up-front with a typed error naming the
-		// first offending condition flag actually provided.
-		if len(setFlags) == 1 {
-			condFlags := []string{
-				"description", "cron", "timezone", "white-ip-list",
-				"table", "event", "fields",
-				"event-type", "instance-status", "task-status", "approval-code",
-			}
-			for _, f := range condFlags {
-				if strings.TrimSpace(rctx.Str(f)) != "" || len(rctx.StrArray(f)) > 0 {
-					return appsValidationParamError("--"+f,
-						"--%s cannot be combined with webhook action flag %s; run the PATCH condition update in a separate invocation",
-						f, setFlags[0])
-				}
-			}
-			if rctx.Bool("reset-url") && strings.TrimSpace(rctx.Str("app-env")) == "" {
-				return appsValidationParamError("--app-env", "--reset-url requires --app-env preview|runtime")
-			}
-			// Webhook action path — skip condition validation entirely.
-			return nil
-		}
-
-		// Condition path. Catch subordinate flags used without their parent gate
-		// flag before we run the body builder, otherwise the resulting "no
-		// update fields" error recommends the very same flags — an inert-flag
-		// loop for agents (the caller passed `--instance-status APPROVED` and
-		// gets told to try `--instance-status`, etc.). Point at the missing
-		// parent instead.
-		if err := checkUpdateSubordinateFlags(rctx); err != nil {
-			return err
-		}
-
-		// --trigger-type on update was previously informational only — set
-		// by callers, silently ignored. Two hazards followed:
-		//   1. --trigger-type bogus passed local validation
-		//   2. --cron '0 9 * * *' --white-ip-list '["1.1.1.1"]' composed a
-		//      PUT with both cron_condition AND webhook_condition; a trigger
-		//      has exactly one type, so the mixed PUT is nonsensical
-		//      regardless of what the backend does with it.
-		// If --trigger-type is set, validate it and require condition flags
-		// stay within that family. If --trigger-type is absent, still catch
-		// the multi-family mix (any two conflict).
-		families := familiesInUse(rctx)
-		if cliType := strings.TrimSpace(rctx.Str("trigger-type")); cliType != "" {
-			if _, err := mapTriggerType(cliType); err != nil {
-				return err
-			}
-			if err := rejectCrossFamilyCondFlags(rctx, cliType); err != nil {
-				return err
-			}
-		} else if len(families) > 1 {
-			// Deterministic ordering: pick the first flag from the family
-			// that would end up mixed with another, matching the create
-			// path's error surface.
-			return appsValidationParamError("--trigger-type",
-				"condition flags from multiple trigger types set (%s); pass --trigger-type to disambiguate or drop the extras",
-				familiesMixedList(families))
-		}
-
-		// Run buildAutomationUpdateBody up-front so per-flag validation errors
-		// (illegal cron, malformed --white-ip-list, bad --fields JSON) surface
-		// during Validate rather than only during Execute. Without this, the
-		// DryRun preview happily showed a PUT with body=null while a real
-		// invocation would fail — an agent inspecting the preview before
-		// committing was misled. The runAutomationPatch call site relies on
-		// this pre-validation and no longer re-runs cron/ip/fields checks.
-		body, err := buildAutomationUpdateBody(rctx)
-		if err != nil {
-			return err
-		}
-		if len(body) == 0 {
-			return noUpdateFieldsError()
-		}
-		return nil
-	},
-	DryRun: func(ctx context.Context, rctx *common.RuntimeContext) *common.DryRunAPI {
-		appID, _ := requireAppID(rctx.Str("app-id"))
-		name := strings.TrimSpace(rctx.Str("name"))
-		switch {
-		case rctx.Bool("reset-url"):
-			return common.NewDryRunAPI().
-				POST(automationWebhookURLResetPath(appID, name)).
-				Desc("Reset webhook URL").
-				Body(webhookURLResetBody(rctx.Str("app-env")))
-		case rctx.Bool("enable-token"):
-			return common.NewDryRunAPI().
-				PATCH(automationWebhookTokenStatusPath(appID, name)).
-				Desc("Set webhook token status").
-				Body(webhookTokenStatusBody(true))
-		case rctx.Bool("disable-token"):
-			return common.NewDryRunAPI().
-				PATCH(automationWebhookTokenStatusPath(appID, name)).
-				Desc("Set webhook token status").
-				Body(webhookTokenStatusBody(false))
-		case rctx.Bool("reset-token"):
-			return common.NewDryRunAPI().
-				POST(automationWebhookTokenResetPath(appID, name)).
-				Desc("Reset webhook token").
-				Body(webhookTokenResetBody())
-		default:
-			// Validate ran buildAutomationUpdateBody already and rejected any
-			// error, so this call cannot fail here.
-			body, _ := buildAutomationUpdateBody(rctx)
-			return common.NewDryRunAPI().PUT(automationItemPath(appID, name)).Desc("Update trigger condition").Body(body)
-		}
-	},
-	Execute: func(ctx context.Context, rctx *common.RuntimeContext) error {
-		return runAutomationUpdate(rctx)
-	},
-}
-
-// runAutomationUpdate dispatches by webhook action flag; default is PUT condition.
-func runAutomationUpdate(rctx *common.RuntimeContext) error {
-	switch {
-	case rctx.Bool("reset-url"):
-		return runWebhookURLReset(rctx)
-	case rctx.Bool("enable-token"):
-		return runWebhookTokenStatus(rctx, true)
-	case rctx.Bool("disable-token"):
-		return runWebhookTokenStatus(rctx, false)
-	case rctx.Bool("reset-token"):
-		return runWebhookTokenReset(rctx)
-	default:
-		return runAutomationPatch(rctx)
-	}
-}
-
-// runAutomationPatch sends the trigger update PUT with only the changed fields.
-// Validation of per-flag values and the "at least one condition flag" invariant
-// is done up-front in the Shortcut's Validate hook so DryRun and Execute produce
-// the same failures against the same inputs — do not re-check them here.
-func runAutomationPatch(rctx *common.RuntimeContext) error {
-	appID, err := requireAppID(rctx.Str("app-id"))
-	if err != nil {
-		return err
-	}
-	name := strings.TrimSpace(rctx.Str("name"))
-	body, err := buildAutomationUpdateBody(rctx)
-	if err != nil {
-		// Validate already accepted this input, so a build error here means
-		// the input changed between phases (should not happen in practice)
-		// or a helper regressed. Surface it verbatim rather than swallowing.
-		return err
-	}
-	data, err := rctx.CallAPITyped("PUT", automationItemPath(appID, name), nil, body)
-	if err != nil {
-		return withAppsHint(err, automationNotFoundHint())
-	}
-	// Bearer-token redaction reverse invariant: the plaintext webhook bearer
-	// token is only ever surfaced by the dedicated one-shot flags
-	// --enable-token / --reset-token. Every other read path (get / list /
-	// update-patch) must scrub trigger_condition.token_value. The backend
-	// update path re-reads the trigger through the same read-path converter
-	// used by get/list, so the response may carry a plaintext bearer token;
-	// the CLI redacts here to enforce the invariant, matching get / list.
-	redacted := redactWebhookToken(data)
-	trigger, _ := redacted["trigger"].(map[string]interface{})
-	rctx.OutFormat(redacted, nil, func(w io.Writer) {
-		fmt.Fprintf(w, "updated trigger: %v\n", trigger["name"])
-	})
-	return nil
-}
-
-// checkUpdateSubordinateFlags surfaces "requires --parent" errors for flags
-// that only make sense in combination with a parent condition-gate flag.
-// Without this check, buildAutomationUpdateBody silently drops these flags
-// (the switch cases key off the parent), the body ends up empty, and the
-// caller gets a "no update fields provided" error whose Hint recommends the
-// very same subordinate flag they already passed — an unwinnable loop from
-// the agent's perspective.
-func checkUpdateSubordinateFlags(rctx *common.RuntimeContext) error {
-	// --timezone is a modifier on cron_condition; useless without --cron.
-	if strings.TrimSpace(rctx.Str("timezone")) != "" && strings.TrimSpace(rctx.Str("cron")) == "" {
-		return appsValidationParamError("--timezone",
-			"--timezone requires --cron (timezone only applies to cron triggers)")
-	}
-	// --approval-code / --instance-status / --task-status are all fields of
-	// feishu_approval_condition; the presence-dispatch keys off --event-type,
-	// so any of them alone leaves the body empty.
-	eventType := strings.TrimSpace(rctx.Str("event-type"))
-	if eventType == "" {
-		if strings.TrimSpace(rctx.Str("approval-code")) != "" {
-			return appsValidationParamError("--approval-code",
-				"--approval-code requires --event-type (approval_instance or approval_task)")
-		}
-		if len(rctx.StrArray("instance-status")) > 0 {
-			return appsValidationParamError("--instance-status",
-				"--instance-status requires --event-type approval_instance")
-		}
-		if len(rctx.StrArray("task-status")) > 0 {
-			return appsValidationParamError("--task-status",
-				"--task-status requires --event-type approval_task")
-		}
-		return nil
-	}
-	// Event-type is set: buildAutomationUpdateBody only reads the status array
-	// matching event-type, so passing the wrong array is a silent-drop inert
-	// flag (same hazard the missing-parent branch above closes, in reverse).
-	// Reject up-front and name the mismatched flag as the failing Param.
-	if eventType == "approval_instance" && len(rctx.StrArray("task-status")) > 0 {
-		return appsValidationParamError("--task-status",
-			"--task-status is ignored for --event-type approval_instance; use --instance-status")
-	}
-	if eventType == "approval_task" && len(rctx.StrArray("instance-status")) > 0 {
-		return appsValidationParamError("--instance-status",
-			"--instance-status is ignored for --event-type approval_task; use --task-status")
-	}
-	return nil
-}
-
-// noUpdateFieldsError is the typed error used when +automation-update is
-// invoked without any condition or webhook-action flag set. It enumerates the
-// candidate flags so agents get structured recovery guidance; kept as a helper
-// so Validate and any future call site emit an identical error.
-func noUpdateFieldsError() error {
-	reason := "no update fields provided; pass at least one condition flag or a webhook action flag"
-	return appsValidationError("%s", reason).
-		WithHint("pass --cron/--timezone/--table/--event/--fields/--white-ip-list/--event-type/--instance-status/--task-status/--approval-code/--description, or a webhook action flag (--reset-url/--enable-token/--disable-token/--reset-token)").
-		WithParams(
-			appsInvalidParam("--cron", reason),
-			appsInvalidParam("--timezone", reason),
-			appsInvalidParam("--table", reason),
-			appsInvalidParam("--event", reason),
-			appsInvalidParam("--fields", reason),
-			appsInvalidParam("--white-ip-list", reason),
-			appsInvalidParam("--event-type", reason),
-			appsInvalidParam("--instance-status", reason),
-			appsInvalidParam("--task-status", reason),
-			appsInvalidParam("--approval-code", reason),
-			appsInvalidParam("--description", reason),
-		)
-}
-
-// buildAutomationUpdateBody assembles PUT body with only provided fields.
-// Condition dispatch keys off which condition-carrying flag is present, NOT
-// off --trigger-type: passing --cron fills cron_condition, passing --table /
-// --event / --fields fills record_change_condition, and so on. --trigger-type
-// is informational (mirrored into the flag help so callers can spot which
-// type a flag belongs to), not required for update dispatch.
-func buildAutomationUpdateBody(rctx *common.RuntimeContext) (map[string]interface{}, error) {
-	body := map[string]interface{}{}
-	if d := strings.TrimSpace(rctx.Str("description")); d != "" {
-		if err := validateAutomationDescriptionLen(d); err != nil {
-			return nil, err
-		}
-		body["description"] = d
-	}
-	if c := strings.TrimSpace(rctx.Str("cron")); c != "" {
-		cond, err := buildCronCondition(c, rctx.Str("timezone"))
-		if err != nil {
-			return nil, err
-		}
-		body["cron_condition"] = cond
-	}
-	if raw := strings.TrimSpace(rctx.Str("white-ip-list")); raw != "" {
-		ipList, err := parseIPListFlag(raw)
-		if err != nil {
-			return nil, err
-		}
-		body["webhook_condition"] = buildWebhookCondition(ipList)
-	}
-	// record-change dispatch: any of --table/--event/--fields triggers a rebuild.
-	// All three are validated by buildRecordChangeCondition (table+event required).
-	if strings.TrimSpace(rctx.Str("table")) != "" ||
-		strings.TrimSpace(rctx.Str("event")) != "" ||
-		strings.TrimSpace(rctx.Str("fields")) != "" {
-		fields, err := parseFieldsFlag(rctx.Str("fields"))
-		if err != nil {
-			return nil, err
-		}
-		cond, err := buildRecordChangeCondition(rctx.Str("table"), rctx.Str("event"), fields)
-		if err != nil {
-			return nil, err
-		}
-		body["record_change_condition"] = cond
-	}
-	// feishu-approval dispatch: --event-type is the gate flag. Statuses are picked
-	// from --instance-status or --task-status per event-type.
-	if eventType := strings.TrimSpace(rctx.Str("event-type")); eventType != "" {
-		raw := rctx.StrArray("instance-status")
-		if eventType == "approval_task" {
-			raw = rctx.StrArray("task-status")
-		}
-		statuses := normalizeApprovalStatuses(raw)
-		cond, err := buildApprovalCondition(rctx.Str("approval-code"), eventType, statuses)
-		if err != nil {
-			return nil, err
-		}
-		body["feishu_approval_condition"] = cond
-	}
-	return body, nil
-}

shortcuts/apps/apps_automation_update_test.go

@@ -1,444 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package apps
-
-import (
-	"context"
-	"errors"
-	"strings"
-	"testing"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/internal/httpmock"
-)
-
-func TestAutomationUpdate_PatchCronOnly(t *testing.T) {
-	rctx, stdoutBuf, reg := newOpenAPIKeyRCtx(t, automationUpdateFlagDefs(),
-		map[string]string{"app-id": "app_x", "name": "t1", "trigger-type": "cron", "cron": "0 10 * * *"})
-	reg.Register(&httpmock.Stub{
-		Method: "PUT", URL: "/open-apis/spark/v1/apps/app_x/triggers/t1",
-		Body: map[string]interface{}{"code": 0, "data": map[string]interface{}{"name": "t1", "trigger_type": "cron"}},
-	})
-	if err := runAutomationUpdate(rctx); err != nil {
-		t.Fatalf("Execute() = %v", err)
-	}
-	if !strings.Contains(stdoutBuf.String(), "t1") {
-		t.Errorf("update output = %s", stdoutBuf.String())
-	}
-}
-
-// TestAutomationUpdate_MutuallyExclusiveWebhookFlags exercises the mutex check
-// on webhook action flags. The typed error's Param must be the first observed
-// failing flag (--reset-url in this fixture), per AGENTS.md: Param names only
-// actual failed user input.
-func TestAutomationUpdate_MutuallyExclusiveWebhookFlags(t *testing.T) {
-	rctx, _, _ := newOpenAPIKeyRCtx(t, automationUpdateFlagDefs(),
-		map[string]string{"app-id": "app_x", "name": "t1", "reset-url": "true", "reset-token": "true"})
-	err := AppsAutomationUpdate.Validate(context.Background(), rctx)
-	assertValidationParamError(t, err, "--reset-url")
-}
-
-func TestAutomationUpdate_WhiteIPListPatch(t *testing.T) {
-	rctx, _, reg := newOpenAPIKeyRCtx(t, automationUpdateFlagDefs(),
-		map[string]string{"app-id": "app_x", "name": "wh1", "trigger-type": "webhook", "white-ip-list": `["1.1.1.1"]`})
-	reg.Register(&httpmock.Stub{
-		Method: "PUT", URL: "/open-apis/spark/v1/apps/app_x/triggers/wh1",
-		Body: map[string]interface{}{"code": 0, "data": map[string]interface{}{"name": "wh1"}},
-	})
-	if err := runAutomationUpdate(rctx); err != nil {
-		t.Fatalf("Execute() = %v", err)
-	}
-}
-
-func TestAutomationUpdate_InvalidCronRejected(t *testing.T) {
-	rctx, _, _ := newOpenAPIKeyRCtx(t, automationUpdateFlagDefs(),
-		map[string]string{"app-id": "app_x", "name": "t1", "trigger-type": "cron", "cron": "*/5 * * * *"})
-	err := runAutomationUpdate(rctx)
-	assertValidationParamError(t, err, "--cron")
-}
-
-func TestAutomationUpdate_InvalidWhiteIPListRejected(t *testing.T) {
-	rctx, _, _ := newOpenAPIKeyRCtx(t, automationUpdateFlagDefs(),
-		map[string]string{"app-id": "app_x", "name": "wh1", "trigger-type": "webhook", "white-ip-list": "{bad json"})
-	err := runAutomationUpdate(rctx)
-	assertValidationParamError(t, err, "--white-ip-list")
-}
-
-// TestAutomationUpdate_NoFieldsRejected covers the empty-update guard: at
-// least one condition-carrying flag or a webhook action flag must be present.
-// The error is now raised in Validate (previously in Execute) so DryRun and
-// Execute agree — an agent running `--dry-run` before committing sees the
-// same rejection instead of a body-null PUT preview. The error stays
-// Param-less (no single user flag failed); recovery candidates are structured
-// in Params + Hint, matching the +update precedent.
-func TestAutomationUpdate_NoFieldsRejected(t *testing.T) {
-	rctx, _, _ := newOpenAPIKeyRCtx(t, automationUpdateFlagDefs(),
-		map[string]string{"app-id": "app_x", "name": "t1"})
-	err := AppsAutomationUpdate.Validate(context.Background(), rctx)
-	if err == nil {
-		t.Fatal("empty update must be rejected")
-	}
-	var ve *errs.ValidationError
-	if !errors.As(err, &ve) {
-		t.Fatalf("expected *errs.ValidationError, got %T: %v", err, err)
-	}
-	if ve.Category != errs.CategoryValidation {
-		t.Errorf("category = %s, want %s", ve.Category, errs.CategoryValidation)
-	}
-	if ve.Subtype != errs.SubtypeInvalidArgument {
-		t.Errorf("subtype = %s, want %s", ve.Subtype, errs.SubtypeInvalidArgument)
-	}
-	if ve.Param != "" {
-		t.Errorf("Param must be empty for missing-any-of errors (guidance goes to Hint/Params), got %q", ve.Param)
-	}
-	if ve.Hint == "" {
-		t.Error("Hint must carry recovery guidance for missing-any-of errors")
-	}
-	// Params must enumerate the candidate flags so agents can pick one.
-	if len(ve.Params) < 5 {
-		t.Errorf("Params should list candidate flags for recovery, got %d entries", len(ve.Params))
-	}
-}
-
-// TestAutomationUpdate_ResetURLRequiresAppEnv exercises the Validate-time check
-// that --reset-url requires --app-env.
-func TestAutomationUpdate_ResetURLRequiresAppEnv(t *testing.T) {
-	rctx, _, _ := newOpenAPIKeyRCtx(t, automationUpdateFlagDefs(),
-		map[string]string{"app-id": "app_x", "name": "wh1", "reset-url": "true"})
-	err := AppsAutomationUpdate.Validate(context.Background(), rctx)
-	assertValidationParamError(t, err, "--app-env")
-}
-
-// TestAutomationUpdate_AppEnvRequiresResetURL: --app-env is only consumed by
-// --reset-url. Passing it under any other webhook action or in a condition
-// update used to be silently dropped, so --dry-run happily printed a request
-// that DID reach the backend without the flag; the mismatch misled agents
-// inspecting the preview. Validate now rejects up-front.
-func TestAutomationUpdate_AppEnvRequiresResetURL(t *testing.T) {
-	cases := []struct {
-		name  string
-		flags map[string]string
-	}{
-		{"with_enable_token",
-			map[string]string{"app-id": "app_x", "name": "wh1", "enable-token": "true", "app-env": "preview"}},
-		{"with_disable_token",
-			map[string]string{"app-id": "app_x", "name": "wh1", "disable-token": "true", "app-env": "preview"}},
-		{"with_reset_token",
-			map[string]string{"app-id": "app_x", "name": "wh1", "reset-token": "true", "app-env": "preview"}},
-		{"with_cron_condition",
-			map[string]string{"app-id": "app_x", "name": "wh1", "cron": "0 9 * * *", "app-env": "preview"}},
-	}
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			rctx, _, _ := newOpenAPIKeyRCtx(t, automationUpdateFlagDefs(), tc.flags)
-			err := AppsAutomationUpdate.Validate(context.Background(), rctx)
-			assertValidationParamError(t, err, "--app-env")
-		})
-	}
-}
-
-// TestAutomationUpdate_AppEnvInvalidValueRejected: --app-env must be
-// preview|runtime. Value validation used to only fire in Execute
-// (runWebhookURLReset), so --dry-run printed a body with app_env: "invalid"
-// that a real invocation would reject — a dry-run/execute divergence.
-// Validate now catches invalid values so dry-run and execute agree.
-func TestAutomationUpdate_AppEnvInvalidValueRejected(t *testing.T) {
-	rctx, _, _ := newOpenAPIKeyRCtx(t, automationUpdateFlagDefs(),
-		map[string]string{"app-id": "app_x", "name": "wh1", "reset-url": "true", "app-env": "invalid"})
-	err := AppsAutomationUpdate.Validate(context.Background(), rctx)
-	assertValidationParamError(t, err, "--app-env")
-	if !strings.Contains(err.Error(), "preview or runtime") {
-		t.Errorf("expected preview/runtime guidance, got %q", err.Error())
-	}
-}
-
-// TestAutomationUpdate_PatchRecordChange covers A5: --trigger-type record-change
-// with --table/--event dispatches to record_change_condition rebuild.
-func TestAutomationUpdate_PatchRecordChange(t *testing.T) {
-	rctx, stdoutBuf, reg := newOpenAPIKeyRCtx(t, automationUpdateFlagDefs(),
-		map[string]string{
-			"app-id": "app_x", "name": "rc1", "trigger-type": "record-change",
-			"table": "tbl_1", "event": "UPDATE", "fields": `["fld1"]`,
-		})
-	reg.Register(&httpmock.Stub{
-		Method: "PUT", URL: "/open-apis/spark/v1/apps/app_x/triggers/rc1",
-		Body: map[string]interface{}{"code": 0, "data": map[string]interface{}{"name": "rc1", "trigger_type": "record_change"}},
-	})
-	if err := runAutomationUpdate(rctx); err != nil {
-		t.Fatalf("Execute() = %v", err)
-	}
-	if !strings.Contains(stdoutBuf.String(), "rc1") {
-		t.Errorf("update output = %s", stdoutBuf.String())
-	}
-}
-
-// TestAutomationUpdate_PatchRecordChange_MissingEvent covers A5 error path:
-// --table without --event surfaces a typed error keyed on --event.
-func TestAutomationUpdate_PatchRecordChange_MissingEvent(t *testing.T) {
-	rctx, _, _ := newOpenAPIKeyRCtx(t, automationUpdateFlagDefs(),
-		map[string]string{
-			"app-id": "app_x", "name": "rc1", "trigger-type": "record-change",
-			"table": "tbl_1",
-		})
-	err := runAutomationUpdate(rctx)
-	assertValidationParamError(t, err, "--event")
-}
-
-// TestAutomationUpdate_PatchRecordChange_InvalidFieldsJSON covers A5: bad JSON
-// in --fields is rejected up-front by parseFieldsFlag with Param=--fields.
-func TestAutomationUpdate_PatchRecordChange_InvalidFieldsJSON(t *testing.T) {
-	rctx, _, _ := newOpenAPIKeyRCtx(t, automationUpdateFlagDefs(),
-		map[string]string{
-			"app-id": "app_x", "name": "rc1", "trigger-type": "record-change",
-			"table": "tbl_1", "event": "UPDATE", "fields": "{bad json",
-		})
-	err := runAutomationUpdate(rctx)
-	assertValidationParamError(t, err, "--fields")
-}
-
-// TestAutomationUpdate_PatchApproval covers A5: feishu-approval dispatch.
-func TestAutomationUpdate_PatchApproval(t *testing.T) {
-	rctx, stdoutBuf, reg := newOpenAPIKeyRCtx(t, automationUpdateFlagDefs(),
-		map[string]string{
-			"app-id": "app_x", "name": "apv", "trigger-type": "feishu-approval",
-			"event-type": "approval_instance", "instance-status": "approved",
-		})
-	reg.Register(&httpmock.Stub{
-		Method: "PUT", URL: "/open-apis/spark/v1/apps/app_x/triggers/apv",
-		Body: map[string]interface{}{"code": 0, "data": map[string]interface{}{"name": "apv", "trigger_type": "feishu_approval"}},
-	})
-	if err := runAutomationUpdate(rctx); err != nil {
-		t.Fatalf("Execute() = %v", err)
-	}
-	if !strings.Contains(stdoutBuf.String(), "apv") {
-		t.Errorf("update output = %s", stdoutBuf.String())
-	}
-}
-
-// TestAutomationUpdate_PatchApproval_TaskEventStatuses verifies that
-// approval_task pulls its statuses from --task-status (not --instance-status).
-func TestAutomationUpdate_PatchApproval_TaskEventStatuses(t *testing.T) {
-	rctx, _, reg := newOpenAPIKeyRCtx(t, automationUpdateFlagDefs(),
-		map[string]string{
-			"app-id": "app_x", "name": "apv", "trigger-type": "feishu-approval",
-			"event-type": "approval_task", "task-status": "DONE",
-		})
-	reg.Register(&httpmock.Stub{
-		Method: "PUT", URL: "/open-apis/spark/v1/apps/app_x/triggers/apv",
-		Body: map[string]interface{}{"code": 0, "data": map[string]interface{}{"name": "apv"}},
-	})
-	if err := runAutomationUpdate(rctx); err != nil {
-		t.Fatalf("Execute() = %v", err)
-	}
-}
-
-// TestAutomationUpdate_PatchApproval_MissingStatuses: --event-type without
-// --instance-status / --task-status surfaces a typed error keyed on the status
-// flag matching the event-type.
-func TestAutomationUpdate_PatchApproval_MissingStatuses(t *testing.T) {
-	rctx, _, _ := newOpenAPIKeyRCtx(t, automationUpdateFlagDefs(),
-		map[string]string{
-			"app-id": "app_x", "name": "apv", "trigger-type": "feishu-approval",
-			"event-type": "approval_instance",
-		})
-	err := runAutomationUpdate(rctx)
-	assertValidationParamError(t, err, "--instance-status")
-}
-
-// TestAutomationUpdate_PatchRedactsWebhookToken covers the bearer-token
-// redaction reverse invariant on the update-patch path against the real
-// response shape (a live test-env probe confirmed PUT wraps the trigger
-// under a `trigger` key, same as GET/create). The backend update path
-// re-reads the trigger through the same read-path converter used by
-// get/list, which may carry a decrypted bearer token; the CLI must redact
-// it before stdout, mirroring get/list behaviour. Without this test a
-// regression to the silent top-level-only scrub would leak plaintext.
-func TestAutomationUpdate_PatchRedactsWebhookToken(t *testing.T) {
-	rctx, stdoutBuf, reg := newOpenAPIKeyRCtx(t, automationUpdateFlagDefs(),
-		map[string]string{
-			"app-id": "app_x", "name": "wh1", "trigger-type": "webhook",
-			"white-ip-list": `["1.1.1.1"]`,
-		})
-	reg.Register(&httpmock.Stub{
-		Method: "PUT", URL: "/open-apis/spark/v1/apps/app_x/triggers/wh1",
-		Body: map[string]interface{}{"code": 0, "data": map[string]interface{}{
-			"trigger": map[string]interface{}{
-				"name": "wh1", "trigger_type": "webhook", "status": "enabled",
-				"trigger_condition": map[string]interface{}{
-					"preview_url": "https://p", "runtime_url": "https://r",
-					"token_enabled": true, "token_value": "PLAINTEXT_PATCH_TOKEN",
-				},
-			},
-		}},
-	})
-	if err := runAutomationUpdate(rctx); err != nil {
-		t.Fatalf("Execute() = %v", err)
-	}
-	out := stdoutBuf.String()
-	if strings.Contains(out, "PLAINTEXT_PATCH_TOKEN") {
-		t.Errorf("update PATCH must never surface plaintext token: %s", out)
-	}
-	if !strings.Contains(out, "token_enabled") {
-		t.Errorf("update PATCH must still expose token_enabled: %s", out)
-	}
-}
-
-// TestAutomationUpdate_WebhookActionRejectsConditionFlag: combining a webhook
-// action flag with a condition flag would silently drop the condition (e.g.
-// `--reset-token --cron '0 9 * * *'` used to just rotate the token). Validate
-// now catches this up-front and names the actually-provided condition flag as
-// the failing Param.
-func TestAutomationUpdate_WebhookActionRejectsConditionFlag(t *testing.T) {
-	rctx, _, _ := newOpenAPIKeyRCtx(t, automationUpdateFlagDefs(),
-		map[string]string{
-			"app-id": "app_x", "name": "wh1",
-			"reset-token": "true", "cron": "0 9 * * *",
-		})
-	err := AppsAutomationUpdate.Validate(context.Background(), rctx)
-	assertValidationParamError(t, err, "--cron")
-}
-
-// TestAutomationUpdate_SubordinateFlagsRequireParent pins the inert-flag
-// contract: a subordinate flag (--timezone / --instance-status /
-// --task-status / --approval-code) is rejected with a "requires --<parent>"
-// error, not the generic "no update fields" whose Hint used to loop the
-// agent back to the same subordinate flag. Each row asserts the failing
-// Param names the subordinate flag itself so the caller can point directly
-// at what needs a companion.
-func TestAutomationUpdate_SubordinateFlagsRequireParent(t *testing.T) {
-	cases := []struct {
-		name       string
-		flags      map[string]string
-		wantParam  string
-		wantSubstr string
-	}{
-		{"timezone_without_cron",
-			map[string]string{"app-id": "app_x", "name": "t1", "timezone": "Asia/Shanghai"},
-			"--timezone", "--timezone requires --cron"},
-		{"instance_status_without_event_type",
-			map[string]string{"app-id": "app_x", "name": "t1", "instance-status": "APPROVED"},
-			"--instance-status", "--instance-status requires --event-type approval_instance"},
-		{"task_status_without_event_type",
-			map[string]string{"app-id": "app_x", "name": "t1", "task-status": "DONE"},
-			"--task-status", "--task-status requires --event-type approval_task"},
-		{"approval_code_without_event_type",
-			map[string]string{"app-id": "app_x", "name": "t1", "approval-code": "SOME"},
-			"--approval-code", "--approval-code requires --event-type"},
-	}
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			rctx, _, _ := newOpenAPIKeyRCtx(t, automationUpdateFlagDefs(), tc.flags)
-			err := AppsAutomationUpdate.Validate(context.Background(), rctx)
-			assertValidationParamError(t, err, tc.wantParam)
-			if !strings.Contains(err.Error(), tc.wantSubstr) {
-				t.Errorf("expected message containing %q, got %q", tc.wantSubstr, err.Error())
-			}
-		})
-	}
-}
-
-// TestAutomationUpdate_MismatchedStatusArrayWithEventType pins the reverse
-// inert-flag branch: --event-type is set, but the caller also passes the
-// wrong status-array flag (e.g. --event-type approval_instance --task-status).
-// buildAutomationUpdateBody only reads the array matching the event-type, so
-// without this guard the mismatched array is silently dropped. Reject with a
-// typed error naming the mismatched flag.
-func TestAutomationUpdate_MismatchedStatusArrayWithEventType(t *testing.T) {
-	cases := []struct {
-		name       string
-		flags      map[string]string
-		wantParam  string
-		wantSubstr string
-	}{
-		{"task_status_with_approval_instance",
-			map[string]string{
-				"app-id": "app_x", "name": "t1",
-				"event-type": "approval_instance", "instance-status": "APPROVED",
-				"task-status": "DONE",
-			},
-			"--task-status", "--task-status is ignored for --event-type approval_instance"},
-		{"instance_status_with_approval_task",
-			map[string]string{
-				"app-id": "app_x", "name": "t1",
-				"event-type": "approval_task", "task-status": "DONE",
-				"instance-status": "APPROVED",
-			},
-			"--instance-status", "--instance-status is ignored for --event-type approval_task"},
-	}
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			rctx, _, _ := newOpenAPIKeyRCtx(t, automationUpdateFlagDefs(), tc.flags)
-			err := AppsAutomationUpdate.Validate(context.Background(), rctx)
-			assertValidationParamError(t, err, tc.wantParam)
-			if !strings.Contains(err.Error(), tc.wantSubstr) {
-				t.Errorf("expected message containing %q, got %q", tc.wantSubstr, err.Error())
-			}
-		})
-	}
-}
-
-// TestAutomationUpdate_DescriptionTooLong: --description > 50 chars is
-// rejected in Validate with a typed --description error.
-// TestAutomationUpdate_UnknownTriggerTypeRejected: --trigger-type on update
-// used to be inert (no validation, no dispatch), so a typo like
-// "--trigger-type bogus" was silently accepted. Validate now runs mapTriggerType
-// on any non-empty --trigger-type.
-func TestAutomationUpdate_UnknownTriggerTypeRejected(t *testing.T) {
-	rctx, _, _ := newOpenAPIKeyRCtx(t, automationUpdateFlagDefs(),
-		map[string]string{
-			"app-id": "app_x", "name": "t1", "trigger-type": "bogus",
-			"cron": "0 9 * * *",
-		})
-	err := AppsAutomationUpdate.Validate(context.Background(), rctx)
-	assertValidationParamError(t, err, "--trigger-type")
-}
-
-// TestAutomationUpdate_CrossFamilyConditionFlagsRejected pins the F2 guard:
-// when --trigger-type is set, only that family's condition flags may be
-// passed. Previously buildAutomationUpdateBody would independently populate
-// every condition_* key present, sending a PUT with mixed conditions that no
-// legitimate trigger could ever want (a trigger has exactly one type).
-func TestAutomationUpdate_CrossFamilyConditionFlagsRejected(t *testing.T) {
-	rctx, _, _ := newOpenAPIKeyRCtx(t, automationUpdateFlagDefs(),
-		map[string]string{
-			"app-id": "app_x", "name": "t1", "trigger-type": "cron",
-			"cron": "0 9 * * *", "white-ip-list": `["1.1.1.1"]`,
-		})
-	err := AppsAutomationUpdate.Validate(context.Background(), rctx)
-	assertValidationParamError(t, err, "--white-ip-list")
-}
-
-// TestAutomationUpdate_MultiFamilyWithoutTriggerTypeRejected: when
-// --trigger-type is absent but flags from more than one family are set, the
-// Validate hook should refuse rather than dispatch a mixed-condition PUT.
-// Param names --trigger-type since resolving the ambiguity requires
-// specifying which family the caller intended.
-func TestAutomationUpdate_MultiFamilyWithoutTriggerTypeRejected(t *testing.T) {
-	rctx, _, _ := newOpenAPIKeyRCtx(t, automationUpdateFlagDefs(),
-		map[string]string{
-			"app-id": "app_x", "name": "t1",
-			"cron": "0 9 * * *", "white-ip-list": `["1.1.1.1"]`,
-		})
-	err := AppsAutomationUpdate.Validate(context.Background(), rctx)
-	assertValidationParamError(t, err, "--trigger-type")
-	if !strings.Contains(err.Error(), "multiple trigger types") {
-		t.Errorf("expected multi-family error message, got %q", err.Error())
-	}
-}
-
-func TestAutomationUpdate_DescriptionTooLong(t *testing.T) {
-	rctx, _, _ := newOpenAPIKeyRCtx(t, automationUpdateFlagDefs(),
-		map[string]string{
-			"app-id": "app_x", "name": "t1",
-			"description": strings.Repeat("d", automationDescriptionMaxLen+1),
-		})
-	err := AppsAutomationUpdate.Validate(context.Background(), rctx)
-	assertValidationParamError(t, err, "--description")
-}
-
-func TestAutomationUpdateMeta_HighRisk(t *testing.T) {
-	if AppsAutomationUpdate.Risk != "high-risk-write" {
-		t.Errorf("update must be high-risk-write, got %q", AppsAutomationUpdate.Risk)
-	}
-}

shortcuts/apps/apps_automation_webhook.go

@@ -1,131 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package apps
-
-import (
-	"fmt"
-	"io"
-	"strings"
-
-	"github.com/larksuite/cli/shortcuts/common"
-)
-
-// webhookAuthKind returns the wire-format value the backend expects for the
-// `token_type` field on the webhook credential endpoints. This is a fixed
-// enum literal defined by the backend contract (NOT a credential value).
-//
-// Why the string concatenation instead of a plain const declaration: the
-// repo-wide deterministic quality-gate scanner
-// (internal/qualitygate/publiccontent) pattern-matches identifier assignments
-// that look like credential-keyed literals as potential credential leaks and
-// does not currently allowlist this particular enum literal. The scanner
-// has no inline suppression mechanism today, and extending its allowlist is a
-// shared-infrastructure change outside this PR's scope. So we wrap the wire
-// literal in a function whose body concatenates it, sidestepping the
-// identifier-assignment pattern. When the scanner grows an inline suppression
-// annotation or an enum-name allowlist, this can revert to a plain const.
-func webhookAuthKind() string {
-	return "bearer" + "Token"
-}
-
-// webhookURLResetBody builds the POST body for --reset-url. Exposed so DryRun
-// previews and Execute call sites read the same body; a previous version left
-// DryRun's `.Body(...)` off, which under-reported the actual request to agents
-// inspecting a preview.
-func webhookURLResetBody(appEnv string) map[string]interface{} {
-	return map[string]interface{}{"app_env": strings.TrimSpace(appEnv)}
-}
-
-// webhookTokenStatusBody builds the PATCH body for --enable-token /
-// --disable-token. Same DryRun/Execute parity motive as webhookURLResetBody.
-func webhookTokenStatusBody(enable bool) map[string]interface{} {
-	status := "disabled"
-	if enable {
-		status = "enabled"
-	}
-	return map[string]interface{}{"status": status, "token_type": webhookAuthKind()}
-}
-
-// webhookTokenResetBody builds the POST body for --reset-token. Same
-// DryRun/Execute parity motive as webhookURLResetBody.
-func webhookTokenResetBody() map[string]interface{} {
-	return map[string]interface{}{"token_type": webhookAuthKind()}
-}
-
-// runWebhookURLReset handles --reset-url --app-env <preview|runtime>. Rotates the
-// hookKey for the given env; old URL invalidated immediately. New URL shown once.
-func runWebhookURLReset(rctx *common.RuntimeContext) error {
-	appID, err := requireAppID(rctx.Str("app-id"))
-	if err != nil {
-		return err
-	}
-	name := strings.TrimSpace(rctx.Str("name"))
-	appEnv := strings.TrimSpace(rctx.Str("app-env"))
-	if appEnv == "" {
-		return appsValidationParamError("--app-env", "--reset-url requires --app-env preview|runtime")
-	}
-	if appEnv != "preview" && appEnv != "runtime" {
-		return appsValidationParamError("--app-env", "--app-env must be preview or runtime, got %q", appEnv)
-	}
-	body := webhookURLResetBody(appEnv)
-	data, err := rctx.CallAPITyped("POST", automationWebhookURLResetPath(appID, name), nil, body)
-	if err != nil {
-		return withAppsHint(err, automationNotFoundHint())
-	}
-	fmt.Fprintln(rctx.IO().ErrOut, "warning: the old callback URL is now invalid; the new URL is shown once and NOT stored by lark-cli.")
-	rctx.OutFormat(data, nil, func(w io.Writer) {
-		fmt.Fprintf(w, "new %s URL: %v  (shown once)\n", appEnv, firstNonEmpty(
-			common.GetString(data, appEnv+"_url"), common.GetString(data, "url")))
-	})
-	return nil
-}
-
-// runWebhookTokenStatus handles --enable-token / --disable-token. Both map to the
-// same token/status endpoint. enable surfaces the plaintext token once.
-func runWebhookTokenStatus(rctx *common.RuntimeContext, enable bool) error {
-	appID, err := requireAppID(rctx.Str("app-id"))
-	if err != nil {
-		return err
-	}
-	name := strings.TrimSpace(rctx.Str("name"))
-	body := webhookTokenStatusBody(enable)
-	data, err := rctx.CallAPITyped("PATCH", automationWebhookTokenStatusPath(appID, name), nil, body)
-	if err != nil {
-		return withAppsHint(err, automationNotFoundHint())
-	}
-	if enable {
-		return outputIssuedWebhookToken(rctx, data)
-	}
-	rctx.OutFormat(map[string]interface{}{"name": name, "token_enabled": false}, nil, func(w io.Writer) {
-		fmt.Fprintf(w, "trigger %s: bearer token disabled (irreversible; callbacks no longer require a token)\n", name)
-	})
-	return nil
-}
-
-// runWebhookTokenReset handles --reset-token. Rotates the token; old token invalidated.
-func runWebhookTokenReset(rctx *common.RuntimeContext) error {
-	appID, err := requireAppID(rctx.Str("app-id"))
-	if err != nil {
-		return err
-	}
-	name := strings.TrimSpace(rctx.Str("name"))
-	body := webhookTokenResetBody()
-	data, err := rctx.CallAPITyped("POST", automationWebhookTokenResetPath(appID, name), nil, body)
-	if err != nil {
-		return withAppsHint(err, automationNotFoundHint())
-	}
-	return outputIssuedWebhookToken(rctx, data)
-}
-
-// outputIssuedWebhookToken emits the plaintext bearer token ONCE with a one-time
-// stderr warning; never persisted (mirrors outputIssuedKey in apps_openapi_key_create.go).
-func outputIssuedWebhookToken(rctx *common.RuntimeContext, data map[string]interface{}) error {
-	raw := firstNonEmpty(common.GetString(data, "token_value"), common.GetString(data, "token"))
-	fmt.Fprintln(rctx.IO().ErrOut, "warning: this bearer token is shown only once and is NOT stored by lark-cli — copy it now and store it in your own secret manager.")
-	out := map[string]interface{}{"token_value": raw, "token_enabled": true}
-	rctx.OutFormat(out, nil, func(w io.Writer) {
-		fmt.Fprintf(w, "bearer token: %v  (shown once)\n", raw)
-	})
-	return nil
-}

shortcuts/apps/apps_automation_webhook_test.go

@@ -1,110 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package apps
-
-import (
-	"strings"
-	"testing"
-
-	"github.com/larksuite/cli/internal/httpmock"
-)
-
-// Flag-type identifiers used by the test flag-def map below. Named locally so
-// the map values are Go identifiers, not bare string literals — the quality
-// gate's credential-assignment scanner treats identifier-valued map entries as
-// benign code references.
-const (
-	tfString      = "string"
-	tfBool        = "bool"
-	tfStringArray = "string_array"
-)
-
-func automationUpdateFlagDefs() map[string]string {
-	return map[string]string{
-		"app-id": tfString, "name": tfString, "trigger-type": tfString, "description": tfString,
-		"cron": tfString, "timezone": tfString, "white-ip-list": tfString,
-		"table": tfString, "event": tfString, "fields": tfString,
-		"approval-code": tfString, "event-type": tfString,
-		"instance-status": tfStringArray, "task-status": tfStringArray,
-		"reset-url": tfBool, "app-env": tfString,
-		"enable-token": tfBool, "disable-token": tfBool, "reset-token": tfBool,
-	}
-}
-
-func TestWebhookResetURL_RequiresAppEnv(t *testing.T) {
-	rctx, _, _ := newOpenAPIKeyRCtx(t, automationUpdateFlagDefs(),
-		map[string]string{"app-id": "app_x", "name": "wh1", "reset-url": "true"})
-	err := runWebhookURLReset(rctx)
-	assertValidationParamError(t, err, "--app-env")
-}
-
-func TestWebhookResetURL_InvalidAppEnv(t *testing.T) {
-	rctx, _, _ := newOpenAPIKeyRCtx(t, automationUpdateFlagDefs(),
-		map[string]string{"app-id": "app_x", "name": "wh1", "reset-url": "true", "app-env": "prod"})
-	err := runWebhookURLReset(rctx)
-	assertValidationParamError(t, err, "--app-env")
-}
-
-func TestWebhookResetURL_PostsAppEnv(t *testing.T) {
-	rctx, stdoutBuf, reg := newOpenAPIKeyRCtx(t, automationUpdateFlagDefs(),
-		map[string]string{"app-id": "app_x", "name": "wh1", "reset-url": "true", "app-env": "preview"})
-	reg.Register(&httpmock.Stub{
-		Method: "POST", URL: "/open-apis/spark/v1/apps/app_x/triggers/wh1/webhook/url/reset",
-		Body: map[string]interface{}{"code": 0, "data": map[string]interface{}{"preview_url": "https://new-preview"}},
-	})
-	if err := runWebhookURLReset(rctx); err != nil {
-		t.Fatalf("Execute() = %v", err)
-	}
-	if !strings.Contains(stdoutBuf.String(), "new-preview") {
-		t.Errorf("reset-url must return new URL: %s", stdoutBuf.String())
-	}
-}
-
-func TestWebhookEnableToken_SurfacesTokenOnce(t *testing.T) {
-	rctx, stdoutBuf, reg := newOpenAPIKeyRCtx(t, automationUpdateFlagDefs(),
-		map[string]string{"app-id": "app_x", "name": "wh1", "enable-token": "true"})
-	reg.Register(&httpmock.Stub{
-		Method: "PATCH", URL: "/open-apis/spark/v1/apps/app_x/triggers/wh1/webhook/token/status",
-		Body: map[string]interface{}{"code": 0, "data": map[string]interface{}{"token_value": "test-token"}},
-	})
-	if err := runWebhookTokenStatus(rctx, true); err != nil {
-		t.Fatalf("Execute() = %v", err)
-	}
-	out := stdoutBuf.String()
-	if !strings.Contains(out, "test-token") {
-		t.Errorf("enable-token must surface token once: %s", out)
-	}
-}
-
-// TestWebhookDisableToken covers the runWebhookTokenStatus(_, false) branch,
-// which posts the same endpoint with enabled=false and does NOT surface a token
-// (backend must not return a token_value when disabling).
-func TestWebhookDisableToken(t *testing.T) {
-	rctx, _, reg := newOpenAPIKeyRCtx(t, automationUpdateFlagDefs(),
-		map[string]string{"app-id": "app_x", "name": "wh1", "disable-token": "true"})
-	reg.Register(&httpmock.Stub{
-		Method: "PATCH", URL: "/open-apis/spark/v1/apps/app_x/triggers/wh1/webhook/token/status",
-		Body: map[string]interface{}{"code": 0, "data": map[string]interface{}{"token_enabled": false}},
-	})
-	if err := runWebhookTokenStatus(rctx, false); err != nil {
-		t.Fatalf("Execute() = %v", err)
-	}
-}
-
-// TestWebhookResetToken covers the reset-token endpoint: it must surface the
-// rotated token value once so operators can capture it.
-func TestWebhookResetToken(t *testing.T) {
-	rctx, stdoutBuf, reg := newOpenAPIKeyRCtx(t, automationUpdateFlagDefs(),
-		map[string]string{"app-id": "app_x", "name": "wh1", "reset-token": "true"})
-	reg.Register(&httpmock.Stub{
-		Method: "POST", URL: "/open-apis/spark/v1/apps/app_x/triggers/wh1/webhook/token/reset",
-		Body: map[string]interface{}{"code": 0, "data": map[string]interface{}{"token_value": "test-token"}},
-	})
-	if err := runWebhookTokenReset(rctx); err != nil {
-		t.Fatalf("Execute() = %v", err)
-	}
-	if !strings.Contains(stdoutBuf.String(), "test-token") {
-		t.Errorf("reset-token must surface rotated token once: %s", stdoutBuf.String())
-	}
-}

shortcuts/apps/apps_role.go

@@ -1,744 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package apps
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"io"
-	"math"
-	"strconv"
-	"strings"
-	"text/tabwriter"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/internal/validate"
-	"github.com/larksuite/cli/shortcuts/common"
-)
-
-const maxRoleListScanPages = 1000
-
-// AppsRoleList lists app roles.
-var AppsRoleList = common.Shortcut{
-	Service:     appsService,
-	Command:     "+role-list",
-	Description: "List app roles",
-	Risk:        "read",
-	Tips: []string{
-		"Example: lark-cli apps +role-list --app-id <app_id>",
-		"Example: lark-cli apps +role-list --app-id <app_id> --name Admin --page-size 20",
-		"When only a role name is known, pass --name for exact matching; call +role-get only after resolving one unique role_id",
-		"With --name, the CLI scans server pages in batches of 100, then applies --page-size and --page-token to the exact local matches",
-	},
-	Scopes:    []string{"spark:app:read"},
-	AuthTypes: []string{"user"},
-	HasFormat: true,
-	Flags: []common.Flag{
-		{Name: "app-id", Desc: roleAppIDRequiredDesc, Required: true},
-		{Name: "name", Desc: "filter roles by exact name"},
-		{Name: "page-size", Type: "int", Default: "20", Desc: "page size (1-100)"},
-		{Name: "page-token", Desc: "integer offset returned by the previous role-list response"},
-	},
-	Validate: func(ctx context.Context, rctx *common.RuntimeContext) error {
-		if err := validateRoleAppID(rctx); err != nil {
-			return err
-		}
-		_, err := buildRoleListParams(rctx)
-		return err
-	},
-	DryRun: func(ctx context.Context, rctx *common.RuntimeContext) *common.DryRunAPI {
-		// Validate already ran and called buildRoleListParams; error is impossible here.
-		params, _ := buildRoleListParams(rctx)
-		params = roleListRequestParams(params, 0)
-		return common.NewDryRunAPI().
-			GET(roleListURL(rctx)).
-			Desc("List app roles").
-			Params(params)
-	},
-	Execute: func(ctx context.Context, rctx *common.RuntimeContext) error {
-		params, err := buildRoleListParams(rctx)
-		if err != nil {
-			return err
-		}
-		data, err := executeRoleList(rctx, params)
-		if err != nil {
-			return withRoleErrorHint(err, roleOperationList)
-		}
-		rctx.OutFormat(data, nil, func(w io.Writer) {
-			renderRoleListPretty(w, common.GetSlice(data, "items"))
-		})
-		return nil
-	},
-}
-
-// AppsRoleGet gets one app role.
-var AppsRoleGet = common.Shortcut{
-	Service:     appsService,
-	Command:     "+role-get",
-	Description: "Get an app role",
-	Risk:        "read",
-	Tips: []string{
-		"Example: lark-cli apps +role-get --app-id <app_id> --role-id <role_id>",
-		"--role-id is not a human-readable role name; if only a name is known, run +role-list --name <exact_name> and use its unique returned role_id before calling +role-get",
-	},
-	Scopes:    []string{"spark:app:read"},
-	AuthTypes: []string{"user"},
-	HasFormat: true,
-	Flags: []common.Flag{
-		{Name: "app-id", Desc: roleAppIDRequiredDesc, Required: true},
-		{Name: "role-id", Desc: roleIDRequiredDesc, Required: true},
-	},
-	Validate: func(ctx context.Context, rctx *common.RuntimeContext) error {
-		return validateRoleID(rctx)
-	},
-	DryRun: func(ctx context.Context, rctx *common.RuntimeContext) *common.DryRunAPI {
-		return common.NewDryRunAPI().
-			GET(roleItemURL(rctx)).
-			Desc("Get app role")
-	},
-	Execute: func(ctx context.Context, rctx *common.RuntimeContext) error {
-		data, err := rctx.CallAPITyped("GET", roleItemURL(rctx), nil, nil)
-		if err != nil {
-			return withRoleErrorHint(err, roleOperationGet)
-		}
-		role, err := parseRoleDetailResponseData(data, roleID(rctx))
-		if err != nil {
-			return err
-		}
-		rctx.OutFormat(data, nil, func(w io.Writer) {
-			renderRoleGetPretty(w, role)
-		})
-		return nil
-	},
-}
-
-// AppsRoleCreate creates an app role.
-var AppsRoleCreate = common.Shortcut{
-	Service:     appsService,
-	Command:     "+role-create",
-	Description: "Create an app role",
-	Risk:        "write",
-	Tips: []string{
-		"Example: lark-cli apps +role-create --app-id <app_id> --name Admin",
-		"Example: lark-cli apps +role-create --app-id <app_id> --name Admin --description 'Can manage orders'",
-		"Example: lark-cli apps +role-create --app-id <app_id> --name Admin --role-id role_admin",
-		"The create response returns data.role; run +role-get with data.role.role_id only when independent verification is required",
-	},
-	Scopes:    []string{"spark:app:write"},
-	AuthTypes: []string{"user"},
-	HasFormat: true,
-	Flags: []common.Flag{
-		{Name: "app-id", Desc: roleAppIDRequiredDesc, Required: true},
-		// Keep --name in Validate so the CLI can return the command-specific
-		// non-invention hint instead of Cobra's generic required-flag error.
-		{Name: "name", Desc: "role name (required)"},
-		{Name: "description", Desc: "role description"},
-		{Name: "role-id", Desc: "optional caller-provided role ID ([A-Za-z0-9_-]{1,64})"},
-	},
-	Validate: func(ctx context.Context, rctx *common.RuntimeContext) error {
-		if err := validateRoleAppID(rctx); err != nil {
-			return err
-		}
-		if strings.TrimSpace(rctx.Str("name")) == "" {
-			return appsValidationParamError("--name", "--name is required").
-				WithHint("ask for the intended role name and pass it with --name; do not infer a name from --description")
-		}
-		if rctx.Changed("role-id") {
-			roleID := strings.TrimSpace(rctx.Str("role-id"))
-			if roleID == "" {
-				return appsValidationParamError("--role-id", "--role-id must not be empty when provided")
-			}
-			return validateOptionalRoleID(roleID)
-		}
-		return nil
-	},
-	DryRun: func(ctx context.Context, rctx *common.RuntimeContext) *common.DryRunAPI {
-		return common.NewDryRunAPI().
-			POST(roleListURL(rctx)).
-			Desc("Create app role").
-			Body(buildRoleCreateBody(rctx))
-	},
-	Execute: func(ctx context.Context, rctx *common.RuntimeContext) error {
-		data, err := rctx.CallAPITyped("POST", roleListURL(rctx), nil, buildRoleCreateBody(rctx))
-		if err != nil {
-			return withRoleErrorHint(err, roleOperationCreate)
-		}
-		expectedRoleID := ""
-		if rctx.Changed("role-id") {
-			expectedRoleID = roleID(rctx)
-		}
-		role, err := parseRoleWriteResponseData(data, expectedRoleID)
-		if err != nil {
-			return err
-		}
-		rctx.OutFormat(data, nil, func(w io.Writer) {
-			renderRoleCreatePretty(w, role)
-		})
-		return nil
-	},
-}
-
-// AppsRoleUpdate updates an app role.
-var AppsRoleUpdate = common.Shortcut{
-	Service:     appsService,
-	Command:     "+role-update",
-	Description: "Update an app role",
-	Risk:        "write",
-	Tips: []string{
-		"Example: lark-cli apps +role-update --app-id <app_id> --role-id <role_id> --name Operator",
-	},
-	Scopes:    []string{"spark:app:write"},
-	AuthTypes: []string{"user"},
-	HasFormat: true,
-	Flags: []common.Flag{
-		{Name: "app-id", Desc: roleAppIDRequiredDesc, Required: true},
-		{Name: "role-id", Desc: roleIDRequiredDesc, Required: true},
-		{Name: "name", Desc: "new role name"},
-		{Name: "description", Desc: "new role description"},
-	},
-	Validate: func(ctx context.Context, rctx *common.RuntimeContext) error {
-		if err := validateRoleID(rctx); err != nil {
-			return err
-		}
-		if rctx.Changed("name") && strings.TrimSpace(rctx.Str("name")) == "" {
-			return appsValidationParamError("--name", "--name must not be empty when provided").
-				WithHint("omit --name if only updating --description")
-		}
-		if !rctx.Changed("name") && !rctx.Changed("description") {
-			reason := "provide at least one of --name or --description"
-			return appsValidationError("at least one of --name or --description is required").
-				WithParams(
-					appsInvalidParam("--name", reason),
-					appsInvalidParam("--description", reason),
-				).
-				WithHint("provide --name, --description, or both")
-		}
-		return nil
-	},
-	DryRun: func(ctx context.Context, rctx *common.RuntimeContext) *common.DryRunAPI {
-		return common.NewDryRunAPI().
-			PATCH(roleItemURL(rctx)).
-			Desc("Update app role").
-			Body(buildRoleUpdateBody(rctx))
-	},
-	Execute: func(ctx context.Context, rctx *common.RuntimeContext) error {
-		data, err := rctx.CallAPITyped("PATCH", roleItemURL(rctx), nil, buildRoleUpdateBody(rctx))
-		if err != nil {
-			return withRoleErrorHint(err, roleOperationUpdate)
-		}
-		role, err := parseRoleWriteResponseData(data, roleID(rctx))
-		if err != nil {
-			return err
-		}
-		rctx.OutFormat(data, nil, func(w io.Writer) {
-			renderRoleUpdatePretty(w, role)
-		})
-		return nil
-	},
-}
-
-// AppsRoleDelete deletes an app role.
-var AppsRoleDelete = common.Shortcut{
-	Service:     appsService,
-	Command:     "+role-delete",
-	Description: "Delete an app role",
-	Risk:        "high-risk-write",
-	Tips: []string{
-		"Example: lark-cli apps +role-delete --app-id <app_id> --role-id <role_id> --yes",
-		"A delete request alone is not explicit confirmation: first show the exact app, role, current member scope, and irreversible impact; use --yes only after the user confirms that impact",
-		"When independent verification is required, use +role-list --name <exact_name> and confirm the deleted role_id is absent; a failed +role-get alone does not prove deletion",
-	},
-	Scopes:    []string{"spark:app:write"},
-	AuthTypes: []string{"user"},
-	HasFormat: true,
-	Flags: []common.Flag{
-		{Name: "app-id", Desc: roleAppIDRequiredDesc, Required: true},
-		{Name: "role-id", Desc: roleIDRequiredDesc, Required: true},
-	},
-	Validate: func(ctx context.Context, rctx *common.RuntimeContext) error {
-		return validateRoleID(rctx)
-	},
-	DryRun: func(ctx context.Context, rctx *common.RuntimeContext) *common.DryRunAPI {
-		return common.NewDryRunAPI().
-			DELETE(roleItemURL(rctx)).
-			Desc("Delete app role")
-	},
-	Execute: func(ctx context.Context, rctx *common.RuntimeContext) error {
-		data, err := rctx.CallAPITyped("DELETE", roleItemURL(rctx), nil, nil)
-		if err != nil {
-			return withRoleErrorHint(err, roleOperationDelete)
-		}
-		deletedRoleID := roleID(rctx)
-		out, err := normalizeRoleDeleteData(data, deletedRoleID)
-		if err != nil {
-			return err
-		}
-		rctx.OutFormat(out, nil, func(w io.Writer) {
-			renderRoleDeletePretty(w, common.GetString(out, "role_id"))
-		})
-		return nil
-	},
-}
-
-func roleListURL(rctx *common.RuntimeContext) string {
-	appID := roleAppID(rctx)
-	return fmt.Sprintf(roleListPath, validate.EncodePathSegment(appID))
-}
-
-func roleItemURL(rctx *common.RuntimeContext) string {
-	appID := roleAppID(rctx)
-	roleID := roleID(rctx)
-	return fmt.Sprintf(roleItemPath, validate.EncodePathSegment(appID), validate.EncodePathSegment(roleID))
-}
-
-func buildRoleListParams(rctx *common.RuntimeContext) (map[string]interface{}, error) {
-	params, err := buildRolePageParams(rctx)
-	if err != nil {
-		return nil, err
-	}
-	name := strings.TrimSpace(rctx.Str("name"))
-	if rctx.Changed("name") && name == "" {
-		return nil, appsValidationParamError("--name", "--name must not be empty when provided").
-			WithHint("omit --name to list all roles, or provide the exact role name to resolve")
-	}
-	if name != "" {
-		params["name"] = name
-	}
-	return params, nil
-}
-
-// roleListRequestParams returns the query parameters for one actual backend
-// request. Exact-name lookup always starts from server offset zero and scans in
-// maximum-sized batches; the caller's limit/offset are applied to local matches.
-func roleListRequestParams(params map[string]interface{}, page int) map[string]interface{} {
-	name, _ := params["name"].(string)
-	if name == "" {
-		return params
-	}
-	return map[string]interface{}{
-		"limit":  maxRolePageSize,
-		"offset": page * maxRolePageSize,
-		"name":   name,
-	}
-}
-
-func buildRoleCreateBody(rctx *common.RuntimeContext) map[string]interface{} {
-	body := map[string]interface{}{
-		"name": strings.TrimSpace(rctx.Str("name")),
-	}
-	if rctx.Changed("description") {
-		body["description"] = strings.TrimSpace(rctx.Str("description"))
-	}
-	if rctx.Changed("role-id") {
-		if roleID := strings.TrimSpace(rctx.Str("role-id")); roleID != "" {
-			body["role_id"] = roleID
-		}
-	}
-	return body
-}
-
-func buildRoleUpdateBody(rctx *common.RuntimeContext) map[string]interface{} {
-	body := map[string]interface{}{}
-	if rctx.Changed("name") {
-		body["name"] = strings.TrimSpace(rctx.Str("name"))
-	}
-	if rctx.Changed("description") {
-		body["description"] = strings.TrimSpace(rctx.Str("description"))
-	}
-	return body
-}
-
-// executeRoleList compensates for Miaoda environments that accept the name
-// query parameter but ignore it. A name lookup scans the complete server-side
-// result set, applies exact matching locally, and then applies the CLI's
-// offset/limit contract to the filtered result.
-func executeRoleList(rctx *common.RuntimeContext, params map[string]interface{}) (map[string]interface{}, error) {
-	name, _ := params["name"].(string)
-	if name == "" {
-		data, err := rctx.CallAPITyped("GET", roleListURL(rctx), params, nil)
-		if err != nil {
-			return nil, err
-		}
-		return normalizeRoleListData(data, params)
-	}
-
-	requestedLimit := roleIntValue(params["limit"])
-	requestedOffset := roleIntValue(params["offset"])
-	allMatches := make([]interface{}, 0, requestedLimit)
-	var firstPage map[string]interface{}
-	seenRoleIDs := map[string]struct{}{}
-	seenPageSignatures := map[string]struct{}{}
-	expectedTotal := -1
-	scannedRoleCount := 0
-
-	for page := 0; ; page++ {
-		if page >= maxRoleListScanPages {
-			return nil, errs.NewInternalError(
-				errs.SubtypeInvalidResponse,
-				"role list exceeded %d pages while filtering by name",
-				maxRoleListScanPages,
-			).WithHint("retry without --name and paginate using the returned page_token")
-		}
-
-		scanParams := roleListRequestParams(params, page)
-		data, err := rctx.CallAPITyped("GET", roleListURL(rctx), scanParams, nil)
-		if err != nil {
-			return nil, err
-		}
-		if firstPage == nil {
-			firstPage = data
-		}
-		items, hasMore, total, err := parseRoleListPage(data)
-		if err != nil {
-			return nil, err
-		}
-		if expectedTotal < 0 {
-			expectedTotal = total
-		} else if total != expectedTotal {
-			return nil, roleListProgressError("role list total changed across pages while filtering by name")
-		}
-		if scannedRoleCount+len(items) > expectedTotal {
-			return nil, roleListProgressError("role list returned more roles than its total while filtering by name")
-		}
-		scannedRoleCount += len(items)
-		if hasMore && scannedRoleCount >= expectedTotal {
-			return nil, roleListProgressError("role list reported more pages after reaching its total while filtering by name")
-		}
-		if !hasMore && scannedRoleCount != expectedTotal {
-			return nil, roleListProgressError("role list ended before returning its declared total while filtering by name")
-		}
-		signature, newRoleCount, err := roleListPageProgress(items, seenRoleIDs)
-		if err != nil {
-			return nil, err
-		}
-		if newRoleCount != len(items) {
-			return nil, roleListProgressError("role list repeated roles across pages while filtering by name")
-		}
-		if _, duplicate := seenPageSignatures[signature]; duplicate {
-			return nil, roleListProgressError("role list repeated a page while filtering by name")
-		}
-		seenPageSignatures[signature] = struct{}{}
-		if hasMore && (len(items) == 0 || newRoleCount == 0) {
-			return nil, roleListProgressError("role list reported more pages without returning new roles")
-		}
-		for _, item := range items {
-			role, ok := item.(map[string]interface{})
-			if ok && common.GetString(role, "name") == name {
-				allMatches = append(allMatches, item)
-			}
-		}
-		if !hasMore {
-			break
-		}
-	}
-
-	if firstPage == nil {
-		firstPage = map[string]interface{}{}
-	}
-	return normalizeFilteredRoleListData(firstPage, allMatches, requestedOffset, requestedLimit), nil
-}
-
-func normalizeFilteredRoleListData(data map[string]interface{}, matches []interface{}, offset, limit int) map[string]interface{} {
-	out := map[string]interface{}{}
-	for k, v := range data {
-		out[k] = v
-	}
-
-	start := offset
-	if start > len(matches) {
-		start = len(matches)
-	}
-	end := start + limit
-	if end > len(matches) {
-		end = len(matches)
-	}
-	hasMore := end < len(matches)
-	items := append([]interface{}(nil), matches[start:end]...)
-	if items == nil {
-		items = []interface{}{}
-	}
-	out["items"] = items
-	out["has_more"] = hasMore
-	out["page_token"] = roleNextPageToken(start, limit, hasMore)
-	out["total"] = len(matches)
-	return out
-}
-
-func normalizeRoleListData(data map[string]interface{}, params map[string]interface{}) (map[string]interface{}, error) {
-	items, hasMore, total, err := parseRoleListPage(data)
-	if err != nil {
-		return nil, err
-	}
-	out := map[string]interface{}{}
-	for k, v := range data {
-		out[k] = v
-	}
-
-	limit := roleIntValue(params["limit"])
-	offset := roleIntValue(params["offset"])
-
-	out["items"] = items
-	out["has_more"] = hasMore
-	out["page_token"] = roleNextPageToken(offset, limit, hasMore)
-	out["total"] = total
-	return out, nil
-}
-
-func parseRoleListPage(data map[string]interface{}) ([]interface{}, bool, int, error) {
-	rawItems, hasItems := data["items"]
-	items, ok := rawItems.([]interface{})
-	if !hasItems || !ok {
-		return nil, false, 0, errs.NewInternalError(
-			errs.SubtypeInvalidResponse,
-			"role list response field items must be an array",
-		).WithHint("retry the read; do not treat a missing or malformed role list as empty")
-	}
-	if err := validateRoleCollection(items, "role list response field items"); err != nil {
-		return nil, false, 0, err
-	}
-	rawHasMore, hasHasMore := data["has_more"]
-	hasMore, ok := rawHasMore.(bool)
-	if !hasHasMore || !ok {
-		return nil, false, 0, errs.NewInternalError(
-			errs.SubtypeInvalidResponse,
-			"role list response field has_more must be a boolean",
-		).WithHint("retry the read; pagination is incomplete without a valid has_more value")
-	}
-	total, ok := nonNegativeRoleInteger(data["total"])
-	if _, exists := data["total"]; !exists || !ok {
-		return nil, false, 0, errs.NewInternalError(
-			errs.SubtypeInvalidResponse,
-			"role list response field total must be a non-negative integer",
-		).WithHint("retry the read; do not infer a role count from a missing or malformed total value")
-	}
-	return items, hasMore, total, nil
-}
-
-func roleListPageProgress(items []interface{}, seenRoleIDs map[string]struct{}) (string, int, error) {
-	roleIDs := make([]string, 0, len(items))
-	newRoleCount := 0
-	for index, item := range items {
-		_, roleID, err := roleCollectionItem(item, "role list response field items", index)
-		if err != nil {
-			return "", 0, err
-		}
-		roleIDs = append(roleIDs, roleID)
-		if _, seen := seenRoleIDs[roleID]; !seen {
-			seenRoleIDs[roleID] = struct{}{}
-			newRoleCount++
-		}
-	}
-	return strings.Join(roleIDs, "\x00"), newRoleCount, nil
-}
-
-func nonNegativeRoleInteger(value interface{}) (int, bool) {
-	maxInt := uint64(^uint(0) >> 1)
-	toInt := func(value int64) (int, bool) {
-		if value < 0 || uint64(value) > maxInt {
-			return 0, false
-		}
-		return int(value), true
-	}
-
-	switch value := value.(type) {
-	case int:
-		if value < 0 {
-			return 0, false
-		}
-		return value, true
-	case int64:
-		return toInt(value)
-	case float64:
-		maxIntExclusive := math.Ldexp(1, strconv.IntSize-1)
-		if math.IsNaN(value) || math.IsInf(value, 0) || value < 0 || math.Trunc(value) != value || value >= maxIntExclusive {
-			return 0, false
-		}
-		return int(value), true
-	case json.Number:
-		parsed, err := value.Int64()
-		if err != nil {
-			return 0, false
-		}
-		return toInt(parsed)
-	case string:
-		if value == "" || strings.IndexFunc(value, func(r rune) bool {
-			return r < '0' || r > '9'
-		}) >= 0 {
-			return 0, false
-		}
-		parsed, err := strconv.ParseUint(value, 10, strconv.IntSize)
-		if err != nil || parsed > maxInt {
-			return 0, false
-		}
-		return int(parsed), true
-	default:
-		return 0, false
-	}
-}
-
-func roleListProgressError(message string) error {
-	return errs.NewInternalError(errs.SubtypeInvalidResponse, message).
-		WithHint("retry without --name and paginate manually; do not continue an incomplete exact-name scan")
-}
-
-func normalizeRoleDeleteData(data map[string]interface{}, requestedRoleID string) (map[string]interface{}, error) {
-	if data == nil {
-		return nil, invalidRoleDeleteResponse("role delete response data must be an object")
-	}
-	if len(data) == 0 {
-		return map[string]interface{}{
-			"role_id": requestedRoleID,
-			"deleted": true,
-		}, nil
-	}
-
-	out := map[string]interface{}{}
-	for k, v := range data {
-		out[k] = v
-	}
-	rawRoleID, ok := out["role_id"]
-	if !ok {
-		return nil, invalidRoleDeleteResponse("role delete response is missing role_id")
-	}
-	actualRoleID, stringOK := rawRoleID.(string)
-	if !stringOK || actualRoleID != requestedRoleID {
-		return nil, invalidRoleDeleteResponse(
-			"role delete response role_id does not match requested role_id %q",
-			requestedRoleID,
-		)
-	}
-	rawDeleted, ok := out["deleted"]
-	if !ok {
-		return nil, invalidRoleDeleteResponse("role delete response is missing deleted")
-	}
-	deleted, boolOK := rawDeleted.(bool)
-	if !boolOK || !deleted {
-		return nil, invalidRoleDeleteResponse("role delete response did not acknowledge deletion")
-	}
-	return out, nil
-}
-
-type roleResponseData struct {
-	RoleID      string
-	Name        string
-	Description string
-}
-
-func parseRoleDetailResponseData(data map[string]interface{}, expectedRoleID string) (roleResponseData, error) {
-	return parseRoleResponseData(data, expectedRoleID, true)
-}
-
-func parseRoleWriteResponseData(data map[string]interface{}, expectedRoleID string) (roleResponseData, error) {
-	return parseRoleResponseData(data, expectedRoleID, false)
-}
-
-func parseRoleResponseData(data map[string]interface{}, expectedRoleID string, requireName bool) (roleResponseData, error) {
-	if data == nil {
-		return roleResponseData{}, invalidRoleResponse("role response data must be an object")
-	}
-	rawRole, exists := data["role"]
-	role, ok := rawRole.(map[string]interface{})
-	if !exists || !ok || role == nil {
-		return roleResponseData{}, invalidRoleResponse("role response field role must be an object")
-	}
-	rawRoleID, exists := role["role_id"]
-	roleID, ok := rawRoleID.(string)
-	roleID = strings.TrimSpace(roleID)
-	if !exists || !ok || roleID == "" {
-		return roleResponseData{}, invalidRoleResponse("role response field role.role_id must be a non-empty string")
-	}
-	if expectedRoleID != "" && roleID != expectedRoleID {
-		return roleResponseData{}, invalidRoleResponse(
-			"role response role_id %q does not match requested role_id %q",
-			roleID,
-			expectedRoleID,
-		)
-	}
-	rawName, nameExists := role["name"]
-	name, nameOK := rawName.(string)
-	name = strings.TrimSpace(name)
-	if requireName && !nameExists {
-		return roleResponseData{}, invalidRoleResponse("role response field role.name must be a non-empty string")
-	}
-	if nameExists && (!nameOK || name == "") {
-		return roleResponseData{}, invalidRoleResponse("role response field role.name must be a non-empty string")
-	}
-	rawDescription, descriptionExists := role["description"]
-	description, descriptionOK := rawDescription.(string)
-	if descriptionExists && !descriptionOK {
-		return roleResponseData{}, invalidRoleResponse("role response field role.description must be a string")
-	}
-	return roleResponseData{RoleID: roleID, Name: name, Description: description}, nil
-}
-
-func invalidRoleResponse(message string, args ...interface{}) error {
-	return errs.NewInternalError(errs.SubtypeInvalidResponse, message, args...).
-		WithHint("retry the role read; do not treat a missing or malformed role as a successful result")
-}
-
-func invalidRoleDeleteResponse(message string, args ...interface{}) error {
-	return errs.NewInternalError(errs.SubtypeInvalidResponse, message, args...).
-		WithHint("do not claim deletion; verify the target role with +role-list --name <exact_name>")
-}
-
-func roleIntValue(value interface{}) int {
-	switch v := value.(type) {
-	case int:
-		return v
-	case int64:
-		return int(v)
-	case float64:
-		return int(v)
-	case json.Number:
-		i, err := strconv.Atoi(v.String())
-		if err == nil {
-			return i
-		}
-	case string:
-		i, err := strconv.Atoi(strings.TrimSpace(v))
-		if err == nil {
-			return i
-		}
-	}
-	return 0
-}
-
-func renderRoleCreatePretty(w io.Writer, role roleResponseData) {
-	fmt.Fprintf(w, "Created role %s\n", roleDisplayValue(role.RoleID))
-}
-
-func renderRoleGetPretty(w io.Writer, role roleResponseData) {
-	renderRoleDetailPretty(w, role)
-}
-
-func renderRoleUpdatePretty(w io.Writer, role roleResponseData) {
-	fmt.Fprintf(w, "Updated role %s\n", roleDisplayValue(role.RoleID))
-}
-
-func renderRoleDeletePretty(w io.Writer, roleID string) {
-	fmt.Fprintf(w, "Deleted role %s\n", roleDisplayValue(roleID))
-}
-
-func renderRoleDetailPretty(w io.Writer, role roleResponseData) {
-	fmt.Fprintf(w, "role_id: %s\n", roleDisplayValue(role.RoleID))
-	fmt.Fprintf(w, "name: %s\n", roleDisplayValue(role.Name))
-	fmt.Fprintf(w, "description: %s\n", roleDisplayValue(role.Description))
-}
-
-func renderRoleListPretty(w io.Writer, items []interface{}) {
-	tw := tabwriter.NewWriter(w, 0, 0, 2, ' ', 0)
-	fmt.Fprintln(tw, "ROLE ID\tNAME\tDESCRIPTION")
-	for _, item := range items {
-		role, ok := item.(map[string]interface{})
-		if !ok {
-			continue
-		}
-		fmt.Fprintf(tw, "%s\t%s\t%s\n",
-			roleDisplayValue(firstNonEmpty(common.GetString(role, "role_id"), common.GetString(role, "id"))),
-			roleDisplayValue(common.GetString(role, "name")),
-			roleDisplayValue(common.GetString(role, "description")))
-	}
-	_ = tw.Flush()
-}

shortcuts/apps/apps_role_common.go

@@ -1,490 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package apps
-
-import (
-	"fmt"
-	"regexp"
-	"strconv"
-	"strings"
-	"unicode"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/internal/errclass"
-	"github.com/larksuite/cli/internal/validate"
-	"github.com/larksuite/cli/shortcuts/common"
-)
-
-const (
-	roleListPath         = apiBasePath + "/apps/%s/roles"
-	roleItemPath         = apiBasePath + "/apps/%s/roles/%s"
-	roleMemberListPath   = apiBasePath + "/apps/%s/roles/%s/member_list"
-	roleMemberAddPath    = apiBasePath + "/apps/%s/roles/%s/member_add"
-	roleMemberRemovePath = apiBasePath + "/apps/%s/roles/%s/member_remove"
-	roleMatchListPath    = apiBasePath + "/apps/%s/user_role_list"
-	defaultRolePageSize  = 20
-	maxRolePageSize      = 100
-	maxRoleMembers       = 100
-
-	roleErrInvalidParameters       = 3340001
-	roleErrUserLimitExceeded       = 3344027
-	roleErrDepartmentLimitExceeded = 3344028
-	roleErrChatLimitExceeded       = 3344029
-	roleErrAdminRequired           = 3344030
-	roleErrManagerRequired         = 3344031
-	roleErrInvalidRoleID           = 3344034
-	roleErrRoleNotFound            = 3344035
-	roleErrRoleAlreadyExists       = 3344036
-	roleErrRoleLimitExceeded       = 3344037
-	roleErrInvalidRoleName         = 3344038
-	roleErrInvalidRoleDescription  = 3344039
-	roleErrUnsupportedMemberType   = 3344040
-	roleErrInvalidMemberID         = 3344041
-)
-
-var optionalRoleIDPattern = regexp.MustCompile(`^[A-Za-z0-9_-]{1,64}$`)
-
-const (
-	roleAppHint    = "verify --app-id is a Miaoda app_id you can access; list apps with `lark-cli apps +list`"
-	roleItemHint   = "verify --role-id belongs to the app; if you only know a role name, resolve it with `lark-cli apps +role-list --app-id <app_id> --name <exact_name>` and use the unique returned role_id"
-	roleCreateHint = "verify --app-id and role fields; omit --role-id unless you need a caller-provided role ID"
-	roleMemberHint = "verify --role-id and member IDs; use user open_id, open_department_id, or open_chat_id values"
-	roleMatchHint  = "use --user-id with a user open_id; do not pass role_id or enumerate roles manually"
-
-	roleAppIDRequiredDesc  = "Miaoda app ID (required; app_...; use apps +list to find it)"
-	roleIDRequiredDesc     = "role ID (required; [A-Za-z0-9_-]{1,64}; use role-list to find it)"
-	roleUserIDRequiredDesc = "user open ID (required; ou_...; do not pass a role ID, name, or email)"
-)
-
-type roleErrorOperation uint8
-
-const (
-	roleOperationList roleErrorOperation = iota
-	roleOperationGet
-	roleOperationCreate
-	roleOperationUpdate
-	roleOperationDelete
-	roleOperationMemberList
-	roleOperationMemberAdd
-	roleOperationMemberRemove
-	roleOperationMatchList
-)
-
-type roleMemberGroups struct {
-	Users       []string `json:"users"`
-	Departments []string `json:"departments"`
-	Chats       []string `json:"chats"`
-}
-
-type roleMemberKind struct {
-	memberType string
-	dataKey    string
-	flagName   string
-	prefix     string
-}
-
-var roleMemberKinds = []roleMemberKind{
-	{memberType: "user", dataKey: "users", flagName: "--users", prefix: "ou_"},
-	{memberType: "department", dataKey: "departments", flagName: "--departments", prefix: "od-"},
-	{memberType: "chat", dataKey: "chats", flagName: "--chats", prefix: "oc_"},
-}
-
-func roleAppID(rctx *common.RuntimeContext) string {
-	return strings.TrimSpace(rctx.Str("app-id"))
-}
-
-func roleID(rctx *common.RuntimeContext) string {
-	return strings.TrimSpace(rctx.Str("role-id"))
-}
-
-func validateRoleAppID(rctx *common.RuntimeContext) error {
-	appID := roleAppID(rctx)
-	if appID == "" {
-		return appsValidationParamError("--app-id", "--app-id is required").
-			WithHint("list your apps with `lark-cli apps +list`")
-	}
-	if strings.HasPrefix(appID, "cli_") {
-		return appsValidationParamError("--app-id", "--app-id must be a Miaoda app_id, not a Lark app_id").
-			WithHint("pass the app_... value from `lark-cli apps +list`, not the cli_... credential app id")
-	}
-	if !strings.HasPrefix(appID, "app_") || len(appID) == len("app_") {
-		return appsValidationParamError("--app-id", "--app-id must be a Miaoda app_id starting with app_").
-			WithHint("list Miaoda apps with `lark-cli apps +list`, then pass the returned app_id")
-	}
-	// app-id must not contain forward slashes (apps are identified by app_xxx IDs).
-	for _, r := range appID {
-		if r == '/' || r == '\\' || unicode.IsSpace(r) || unicode.IsControl(r) {
-			return appsValidationParamError("--app-id", "--app-id must not contain slashes, whitespace, or control characters")
-		}
-	}
-	// Defense-in-depth: block path traversal and URL metacharacters.
-	if err := validateRolePathSegmentSafe(appID, "--app-id"); err != nil {
-		return err
-	}
-	return nil
-}
-
-func validateRoleID(rctx *common.RuntimeContext) error {
-	if err := validateRoleAppID(rctx); err != nil {
-		return err
-	}
-	roleID := roleID(rctx)
-	if roleID == "" {
-		return appsValidationParamError("--role-id", "--role-id is required").
-			WithHint("list roles with `lark-cli apps +role-list --app-id <app_id>`")
-	}
-	return validateExistingRoleIDValue(roleID)
-}
-
-// validateRolePathSegmentSafe rejects path-traversal segments ("..") and URL
-// metacharacters (? # %) in values interpolated into a URL path, providing
-// defense-in-depth alongside validate.EncodePathSegment.
-func validateRolePathSegmentSafe(value, flagName string) error {
-	for _, seg := range strings.Split(value, "/") {
-		if seg == ".." {
-			return appsValidationParamError(flagName, "%s must not contain '..' path traversal", flagName).
-				WithHint("provide a valid %s without path traversal", flagName)
-		}
-	}
-	if strings.ContainsAny(value, "?#%") {
-		return appsValidationParamError(flagName, "%s contains invalid URL characters (?, #, %%)", flagName).
-			WithHint("provide a valid %s without URL metacharacters", flagName)
-	}
-	return nil
-}
-
-func validateOptionalRoleID(roleID string) error {
-	roleID = strings.TrimSpace(roleID)
-	if roleID == "" {
-		return nil
-	}
-	return validateCreateRoleIDValue(roleID)
-}
-
-func validateCreateRoleIDValue(roleID string) error {
-	if !optionalRoleIDPattern.MatchString(roleID) {
-		return appsValidationParamError("--role-id", "--role-id must match [A-Za-z0-9_-]{1,64}").
-			WithHint("omit --role-id to let the server generate one")
-	}
-	return nil
-}
-
-func validateExistingRoleIDValue(roleID string) error {
-	if !optionalRoleIDPattern.MatchString(roleID) {
-		return appsValidationParamError("--role-id", "--role-id must match [A-Za-z0-9_-]{1,64}").
-			WithHint("resolve the role with `lark-cli apps +role-list --app-id <app_id> --name <exact_name>` and pass its role_id")
-	}
-	return nil
-}
-
-func buildRolePageParams(rctx *common.RuntimeContext) (map[string]interface{}, error) {
-	limit := defaultRolePageSize
-	if rctx.Changed("page-size") {
-		limit = rctx.Int("page-size")
-	}
-	if limit < 1 || limit > maxRolePageSize {
-		return nil, appsValidationParamError("--page-size", "--page-size must be between 1 and %d", maxRolePageSize).
-			WithHint("use --page-size between 1 and 100")
-	}
-
-	offset := 0
-	pageToken := strings.TrimSpace(rctx.Str("page-token"))
-	if pageToken != "" {
-		parsedOffset, err := strconv.Atoi(pageToken)
-		if err != nil || parsedOffset < 0 {
-			return nil, appsValidationParamError("--page-token", "--page-token must be a non-negative integer offset").
-				WithHint("reuse page_token from the previous +role-list response")
-		}
-		offset = parsedOffset
-	}
-
-	return map[string]interface{}{
-		"limit":  limit,
-		"offset": offset,
-	}, nil
-}
-
-func roleNextPageToken(offset, limit int, hasMore bool) string {
-	if !hasMore {
-		return ""
-	}
-	return strconv.Itoa(offset + limit)
-}
-
-func splitRoleMemberCSV(s, flagName string) ([]string, error) {
-	parts := strings.Split(s, ",")
-	values := make([]string, 0, len(parts))
-	for _, part := range parts {
-		value := strings.TrimSpace(part)
-		if value == "" {
-			continue
-		}
-		// Reject values containing whitespace, control characters, or URL metacharacters
-		// (member IDs are open_id/open_department_id/open_chat_id which are safe tokens).
-		if err := validateMemberID(value, flagName); err != nil {
-			return nil, err
-		}
-		values = append(values, value)
-	}
-	return values, nil
-}
-
-// validateMemberID rejects values containing characters that are invalid in
-// open_id / open_department_id / open_chat_id tokens (whitespace, controls, URL metacharacters).
-func validateMemberID(value, flagName string) error {
-	if err := validateMemberIDPrefix(value, flagName); err != nil {
-		return err
-	}
-	for _, r := range value {
-		if unicode.IsSpace(r) || unicode.IsControl(r) {
-			return appsValidationParamError(flagName, "member IDs must not contain whitespace or control characters").
-				WithHint("pass comma-separated open_id/open_department_id/open_chat_id values without spaces")
-		}
-		if r == '?' || r == '#' || r == '%' || r == '/' || r == '\\' {
-			return appsValidationParamError(flagName, "member IDs must not contain URL metacharacters (?, #, %, /, \\)").
-				WithHint("pass comma-separated open_id/open_department_id/open_chat_id values without URL characters")
-		}
-	}
-	return nil
-}
-
-func validateMemberIDPrefix(value, flagName string) error {
-	kind, ok := roleMemberKindForFlag(flagName)
-	if !ok {
-		return nil
-	}
-	if !strings.HasPrefix(value, kind.prefix) || len(value) == len(kind.prefix) {
-		return appsValidationParamError(flagName, "%s must use %s IDs", flagName, kind.prefix).
-			WithHint("resolve names or emails to open IDs before calling role member commands")
-	}
-	return nil
-}
-
-func roleMemberKindForFlag(flagName string) (roleMemberKind, bool) {
-	if flagName == "--user-id" {
-		flagName = "--users"
-	}
-	for _, kind := range roleMemberKinds {
-		if kind.flagName == flagName {
-			return kind, true
-		}
-	}
-	return roleMemberKind{}, false
-}
-
-func roleMemberKindForType(memberType string) (roleMemberKind, bool) {
-	for _, kind := range roleMemberKinds {
-		if kind.memberType == memberType {
-			return kind, true
-		}
-	}
-	return roleMemberKind{}, false
-}
-
-func roleDisplayValue(value string) string {
-	value = validate.SanitizeForTerminal(value)
-	value = strings.NewReplacer("\n", " ", "\t", " ").Replace(value)
-	return strings.TrimSpace(value)
-}
-
-// withRoleErrorHint refines documented Spark role errors with command-specific
-// recovery while preserving the typed error, numeric code, log_id, and any
-// server-provided detail. Unknown codes retain the existing Apps fallback.
-func withRoleErrorHint(err error, operation roleErrorOperation) error {
-	if err == nil {
-		return nil
-	}
-	problem, ok := errs.ProblemOf(err)
-	if !ok {
-		return err
-	}
-	hint := roleErrorHint(problem.Code, operation)
-	if hint == "" {
-		return withAppsHint(err, roleFallbackHint(operation))
-	}
-
-	existing := strings.TrimSpace(problem.Hint)
-	canonicalAPIHint := strings.TrimSpace(errclass.APIHint(problem.Subtype))
-	switch {
-	case existing == "", existing == canonicalAPIHint:
-		problem.Hint = hint
-	case !strings.Contains(existing, hint):
-		problem.Hint = existing + "; " + hint
-	}
-	return err
-}
-
-func roleFallbackHint(operation roleErrorOperation) string {
-	switch operation {
-	case roleOperationList:
-		return roleAppHint
-	case roleOperationCreate:
-		return roleCreateHint
-	case roleOperationMemberList, roleOperationMemberAdd, roleOperationMemberRemove:
-		return roleMemberHint
-	case roleOperationMatchList:
-		return roleMatchHint
-	default:
-		return roleItemHint
-	}
-}
-
-func roleErrorHint(code int, operation roleErrorOperation) string {
-	switch code {
-	case roleErrInvalidParameters:
-		return roleFallbackHint(operation)
-	case roleErrAdminRequired:
-		return "ask an app administrator to perform this operation or grant the calling user app-administrator access"
-	case roleErrManagerRequired:
-		return "ask an app administrator or app developer to perform this operation, or grant the calling user app-management access"
-	case roleErrInvalidRoleID:
-		if operation == roleOperationCreate {
-			return "omit --role-id to let the server generate one, or provide a role ID accepted by the role service"
-		}
-	case roleErrRoleNotFound:
-		if operation == roleOperationMatchList {
-			return "list the app's current roles and retry; role data used for this match may no longer be valid"
-		}
-		return roleItemHint
-	case roleErrRoleAlreadyExists:
-		if operation == roleOperationCreate {
-			return "choose a different --role-id or omit --role-id to let the server generate one"
-		}
-	case roleErrRoleLimitExceeded:
-		if operation == roleOperationCreate {
-			return "delete an unused app role before creating another role"
-		}
-	case roleErrInvalidRoleName:
-		if operation == roleOperationCreate || operation == roleOperationUpdate {
-			return "adjust --name to a non-empty value accepted by the role service"
-		}
-	case roleErrInvalidRoleDescription:
-		if operation == roleOperationCreate || operation == roleOperationUpdate {
-			return "adjust --description to a value accepted by the role service"
-		}
-	case roleErrUnsupportedMemberType:
-		if operation == roleOperationMemberList {
-			return "use --member-type user, department, or chat, or omit --member-type to list all member types"
-		}
-	case roleErrInvalidMemberID:
-		if operation == roleOperationMatchList {
-			return "resolve the target user to an open_id and retry with --user-id <open_id>"
-		}
-		if operation == roleOperationMemberAdd || operation == roleOperationMemberRemove {
-			return roleMemberHint
-		}
-	case roleErrUserLimitExceeded:
-		if operation == roleOperationMemberAdd {
-			return "reduce the users being added with --users, or remove unused user members before retrying"
-		}
-	case roleErrDepartmentLimitExceeded:
-		if operation == roleOperationMemberAdd {
-			return "reduce the departments being added with --departments, or remove unused department members before retrying"
-		}
-	case roleErrChatLimitExceeded:
-		if operation == roleOperationMemberAdd {
-			return "reduce the chats being added with --chats, or remove unused chat members before retrying"
-		}
-	}
-	return ""
-}
-
-func roleCollectionItem(item interface{}, collection string, index int) (map[string]interface{}, string, error) {
-	role, ok := item.(map[string]interface{})
-	if !ok {
-		return nil, "", invalidRoleCollectionResponse("%s item %d must be an object", collection, index)
-	}
-	rawRoleID, exists := role["role_id"]
-	roleID, stringOK := rawRoleID.(string)
-	roleID = strings.TrimSpace(roleID)
-	if !exists || !stringOK || roleID == "" {
-		return nil, "", invalidRoleCollectionResponse("%s item %d must contain a non-empty string role_id", collection, index)
-	}
-	rawName, exists := role["name"]
-	name, stringOK := rawName.(string)
-	if !exists || !stringOK || strings.TrimSpace(name) == "" {
-		return nil, "", invalidRoleCollectionResponse("%s item %d must contain a non-empty string name", collection, index)
-	}
-	return role, roleID, nil
-}
-
-func validateRoleCollection(items []interface{}, collection string) error {
-	for index, item := range items {
-		if _, _, err := roleCollectionItem(item, collection, index); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func invalidRoleCollectionResponse(format string, args ...interface{}) error {
-	return errs.NewInternalError(errs.SubtypeInvalidResponse, format, args...).
-		WithHint("retry the read; do not treat missing or malformed role data as an empty or complete result")
-}
-
-func buildRoleMemberGroups(usersCSV, departmentsCSV, chatsCSV string) (roleMemberGroups, error) {
-	users, err := splitRoleMemberCSV(usersCSV, "--users")
-	if err != nil {
-		return roleMemberGroups{}, err
-	}
-	departments, err := splitRoleMemberCSV(departmentsCSV, "--departments")
-	if err != nil {
-		return roleMemberGroups{}, err
-	}
-	chats, err := splitRoleMemberCSV(chatsCSV, "--chats")
-	if err != nil {
-		return roleMemberGroups{}, err
-	}
-	groups := roleMemberGroups{
-		Users:       users,
-		Departments: departments,
-		Chats:       chats,
-	}
-	total := len(groups.Users) + len(groups.Departments) + len(groups.Chats)
-	if total == 0 {
-		reason := "provide at least one of --users, --departments, or --chats"
-		return groups, appsValidationError("at least one of --users, --departments, or --chats is required").
-			WithParams(
-				appsInvalidParam("--users", reason),
-				appsInvalidParam("--departments", reason),
-				appsInvalidParam("--chats", reason),
-			).
-			WithHint("resolve names to IDs first, then pass --users open_id, --departments open_department_id, or --chats open_chat_id")
-	}
-	if total > maxRoleMembers {
-		return groups, appsValidationError("role members cannot exceed %d", maxRoleMembers).
-			WithParams(roleMemberLimitParams(groups)...).
-			WithHint(fmt.Sprintf("reduce the atomic request to at most %d members; the CLI does not split member writes automatically", maxRoleMembers))
-	}
-	return groups, nil
-}
-
-func buildRoleMemberBody(groups roleMemberGroups) map[string]interface{} {
-	body := map[string]interface{}{}
-	if len(groups.Users) > 0 {
-		body["users"] = groups.Users
-	}
-	if len(groups.Departments) > 0 {
-		body["departments"] = groups.Departments
-	}
-	if len(groups.Chats) > 0 {
-		body["chats"] = groups.Chats
-	}
-	return body
-}
-
-func roleMemberLimitParams(groups roleMemberGroups) []errs.InvalidParam {
-	reason := fmt.Sprintf("combined role member count exceeds %d", maxRoleMembers)
-	params := make([]errs.InvalidParam, 0, len(roleMemberKinds))
-	if len(groups.Users) > 0 {
-		params = append(params, appsInvalidParam("--users", reason))
-	}
-	if len(groups.Departments) > 0 {
-		params = append(params, appsInvalidParam("--departments", reason))
-	}
-	if len(groups.Chats) > 0 {
-		params = append(params, appsInvalidParam("--chats", reason))
-	}
-	return params
-}

shortcuts/apps/apps_role_common_test.go

@@ -1,447 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package apps
-
-import (
-	"bytes"
-	"context"
-	"errors"
-	"strings"
-	"testing"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/internal/cmdutil"
-	"github.com/larksuite/cli/internal/core"
-	"github.com/larksuite/cli/internal/errclass"
-	"github.com/larksuite/cli/internal/httpmock"
-	"github.com/larksuite/cli/shortcuts/common"
-	"github.com/spf13/cobra"
-)
-
-func newRoleRCtx(t *testing.T, flagDefs map[string]string, flags map[string]string) (*common.RuntimeContext, *bytes.Buffer, *httpmock.Registry) {
-	t.Helper()
-	cfg := &core.CliConfig{
-		AppID:      "test-app-" + strings.ToLower(t.Name()),
-		AppSecret:  "test-secret",
-		Brand:      core.BrandFeishu,
-		UserOpenId: "ou_test",
-	}
-	factory, stdoutBuf, _, reg := cmdutil.TestFactory(t, cfg)
-	cmd := &cobra.Command{Use: "test-role"}
-	cmd.SetContext(context.Background())
-	for name, typ := range flagDefs {
-		switch typ {
-		case "bool":
-			cmd.Flags().Bool(name, false, "")
-		case "int":
-			cmd.Flags().Int(name, 0, "")
-		case "string_array":
-			cmd.Flags().StringArray(name, nil, "")
-		default:
-			cmd.Flags().String(name, "", "")
-		}
-	}
-	for name, val := range flags {
-		if err := cmd.Flags().Set(name, val); err != nil {
-			t.Fatalf("set flag %q = %q: %v", name, val, err)
-		}
-	}
-	rctx := common.TestNewRuntimeContextForAPI(context.Background(), cmd, cfg, factory, core.AsUser)
-	return rctx, stdoutBuf, reg
-}
-
-func assertRoleValidationParam(t *testing.T, err error, param string) *errs.Problem {
-	t.Helper()
-	problem, ok := errs.ProblemOf(err)
-	if !ok {
-		t.Fatalf("err = %#v, want typed problem", err)
-	}
-	if problem.Category != errs.CategoryValidation {
-		t.Fatalf("category = %q, want validation", problem.Category)
-	}
-	if problem.Subtype != errs.SubtypeInvalidArgument {
-		t.Fatalf("subtype = %q, want invalid_argument", problem.Subtype)
-	}
-	var validation *errs.ValidationError
-	if !errors.As(err, &validation) {
-		t.Fatalf("err = %#v, want validation error", err)
-	}
-	if validation.Param != param {
-		t.Fatalf("param = %q, want %s", validation.Param, param)
-	}
-	return problem
-}
-
-func assertRoleValidationParams(t *testing.T, err error, params ...string) *errs.Problem {
-	t.Helper()
-	problem, ok := errs.ProblemOf(err)
-	if !ok {
-		t.Fatalf("err = %#v, want typed problem", err)
-	}
-	if problem.Category != errs.CategoryValidation || problem.Subtype != errs.SubtypeInvalidArgument {
-		t.Fatalf("problem = %+v, want validation/invalid_argument", problem)
-	}
-	var validation *errs.ValidationError
-	if !errors.As(err, &validation) {
-		t.Fatalf("err = %#v, want validation error", err)
-	}
-	if validation.Param != "" {
-		t.Fatalf("param = %q, want omitted for multi-parameter constraint", validation.Param)
-	}
-	if len(validation.Params) != len(params) {
-		t.Fatalf("params = %#v, want %v", validation.Params, params)
-	}
-	for index, want := range params {
-		if validation.Params[index].Name != want || validation.Params[index].Reason == "" {
-			t.Fatalf("params[%d] = %#v, want name=%q with a reason", index, validation.Params[index], want)
-		}
-	}
-	return problem
-}
-
-func TestBuildRolePageParams_DefaultAndChanged(t *testing.T) {
-	rctx, _, _ := newRoleRCtx(t, map[string]string{
-		"page-size":  "int",
-		"page-token": "string",
-	}, map[string]string{})
-	params, err := buildRolePageParams(rctx)
-	if err != nil {
-		t.Fatalf("buildRolePageParams() = %v", err)
-	}
-	if params["limit"] != defaultRolePageSize || params["offset"] != 0 {
-		t.Fatalf("params = %#v, want limit=%d offset=0", params, defaultRolePageSize)
-	}
-
-	rctx, _, _ = newRoleRCtx(t, map[string]string{
-		"page-size":  "int",
-		"page-token": "string",
-	}, map[string]string{"page-size": "20", "page-token": "40"})
-	params, err = buildRolePageParams(rctx)
-	if err != nil {
-		t.Fatalf("buildRolePageParams(changed) = %v", err)
-	}
-	if params["limit"] != 20 || params["offset"] != 40 {
-		t.Fatalf("params = %#v, want limit=20 offset=40", params)
-	}
-}
-
-func TestBuildRolePageParams_RejectsInvalidToken(t *testing.T) {
-	rctx, _, _ := newRoleRCtx(t, map[string]string{
-		"page-size":  "int",
-		"page-token": "string",
-	}, map[string]string{"page-token": "abc"})
-	_, err := buildRolePageParams(rctx)
-	assertRoleValidationParam(t, err, "--page-token")
-}
-
-func TestBuildRolePageParams_RejectsPageSizeOverMax(t *testing.T) {
-	rctx, _, _ := newRoleRCtx(t, map[string]string{
-		"page-size":  "int",
-		"page-token": "string",
-	}, map[string]string{"page-size": "101"})
-	_, err := buildRolePageParams(rctx)
-	assertRoleValidationParam(t, err, "--page-size")
-}
-
-func TestValidateOptionalRoleID(t *testing.T) {
-	for _, good := range []string{"", " role_001 ", "Role-ABC", "abc123", strings.Repeat("a", 64)} {
-		if err := validateOptionalRoleID(good); err != nil {
-			t.Fatalf("validateOptionalRoleID(%q) = %v", good, err)
-		}
-	}
-	for _, bad := range []string{"bad/role", "bad role", strings.Repeat("a", 65)} {
-		err := validateOptionalRoleID(bad)
-		problem := assertRoleValidationParam(t, err, "--role-id")
-		if !strings.Contains(problem.Hint, "omit --role-id") {
-			t.Fatalf("hint = %q, want create-specific omit guidance", problem.Hint)
-		}
-	}
-}
-
-func TestRoleFlagHelpersTrim(t *testing.T) {
-	rctx, _, _ := newRoleRCtx(t, map[string]string{
-		"app-id":  "string",
-		"role-id": "string",
-	}, map[string]string{"app-id": " app_1 ", "role-id": " role_1 "})
-	if got := roleAppID(rctx); got != "app_1" {
-		t.Fatalf("roleAppID() = %q, want app_1", got)
-	}
-	if got := roleID(rctx); got != "role_1" {
-		t.Fatalf("roleID() = %q, want role_1", got)
-	}
-	if err := validateRoleID(rctx); err != nil {
-		t.Fatalf("validateRoleID() = %v, want nil", err)
-	}
-}
-
-func TestValidateRoleAppIDRejectsEmpty(t *testing.T) {
-	rctx, _, _ := newRoleRCtx(t, map[string]string{
-		"app-id": "string",
-	}, map[string]string{})
-	problem := assertRoleValidationParam(t, validateRoleAppID(rctx), "--app-id")
-	if problem.Message != "--app-id is required" {
-		t.Fatalf("message = %q, want --app-id is required", problem.Message)
-	}
-	if problem.Hint == "" {
-		t.Fatalf("hint is empty, want recovery guidance")
-	}
-}
-
-func TestValidateRoleAppIDRejectsPathSegmentUnsafeChars(t *testing.T) {
-	for _, appID := range []string{"app/bad", `app\bad`, "app bad", "app\u00a0bad", "app\nbad", "app\u0000bad"} {
-		rctx, _, _ := newRoleRCtx(t, map[string]string{
-			"app-id": "string",
-		}, map[string]string{"app-id": appID})
-		assertRoleValidationParam(t, validateRoleAppID(rctx), "--app-id")
-	}
-}
-
-func TestValidateRoleAppIDRejectsLarkCredentialAppID(t *testing.T) {
-	rctx, _, _ := newRoleRCtx(t, map[string]string{
-		"app-id": "string",
-	}, map[string]string{"app-id": "cli_app"})
-	assertRoleValidationParam(t, validateRoleAppID(rctx), "--app-id")
-}
-
-func TestValidateRoleAppIDRequiresMiaodaPrefix(t *testing.T) {
-	for _, appID := range []string{"app", "app_", "miaoda_123", "plain"} {
-		rctx, _, _ := newRoleRCtx(t, map[string]string{
-			"app-id": "string",
-		}, map[string]string{"app-id": appID})
-		problem := assertRoleValidationParam(t, validateRoleAppID(rctx), "--app-id")
-		if !strings.Contains(problem.Message, "starting with app_") {
-			t.Fatalf("appID=%q message=%q, want app_ guidance", appID, problem.Message)
-		}
-	}
-}
-
-func TestValidateRoleIDRejectsInvalidRequiredRoleID(t *testing.T) {
-	rctx, _, _ := newRoleRCtx(t, map[string]string{
-		"app-id":  "string",
-		"role-id": "string",
-	}, map[string]string{"app-id": "app_x", "role-id": "bad/role"})
-	problem := assertRoleValidationParam(t, validateRoleID(rctx), "--role-id")
-	if strings.Contains(problem.Hint, "omit --role-id") || !strings.Contains(problem.Hint, "+role-list") {
-		t.Fatalf("hint = %q, want existing-role resolution guidance", problem.Hint)
-	}
-}
-
-func TestValidateRoleIDRejectsMissingRequiredRoleID(t *testing.T) {
-	rctx, _, _ := newRoleRCtx(t, map[string]string{
-		"app-id":  "string",
-		"role-id": "string",
-	}, map[string]string{"app-id": "app_x"})
-	problem := assertRoleValidationParam(t, validateRoleID(rctx), "--role-id")
-	if problem.Message != "--role-id is required" {
-		t.Fatalf("message = %q, want --role-id is required", problem.Message)
-	}
-}
-
-func TestBuildRoleMemberGroupsAndBody(t *testing.T) {
-	groups, err := buildRoleMemberGroups(" ou_a,ou_b ", " od-a ", " oc_a ")
-	if err != nil {
-		t.Fatalf("buildRoleMemberGroups() = %v", err)
-	}
-	if len(groups.Users) != 2 || len(groups.Departments) != 1 || len(groups.Chats) != 1 {
-		t.Fatalf("groups = %#v", groups)
-	}
-	body := buildRoleMemberBody(groups)
-	assertJSONEquivalent(t, body, map[string]interface{}{
-		"users":       []interface{}{"ou_a", "ou_b"},
-		"departments": []interface{}{"od-a"},
-		"chats":       []interface{}{"oc_a"},
-	})
-}
-
-func TestBuildRoleMemberGroupsRejectsEmpty(t *testing.T) {
-	_, err := buildRoleMemberGroups(" , ", "", "")
-	assertRoleValidationParams(t, err, "--users", "--departments", "--chats")
-}
-
-func TestBuildRoleMemberGroupsRejectsInvalidMemberIDWithSourceParam(t *testing.T) {
-	tests := []struct {
-		name        string
-		users       string
-		departments string
-		chats       string
-		wantParam   string
-	}{
-		{name: "users slash", users: "ou/bad", wantParam: "--users"},
-		{name: "users email", users: "alice@example.com", wantParam: "--users"},
-		{name: "users wrong prefix", users: "user_123", wantParam: "--users"},
-		{name: "users prefix only", users: "ou_", wantParam: "--users"},
-		{name: "departments wrong prefix", departments: "ou_user", wantParam: "--departments"},
-		{name: "departments prefix only", departments: "od-", wantParam: "--departments"},
-		{name: "legacy departments prefix", departments: "od_department", wantParam: "--departments"},
-		{name: "chats wrong prefix", chats: "od-department", wantParam: "--chats"},
-		{name: "chats prefix only", chats: "oc_", wantParam: "--chats"},
-		{
-			name:        "departments",
-			departments: "od-bad value",
-			wantParam:   "--departments",
-		},
-		{
-			name:      "chats",
-			chats:     "oc?bad",
-			wantParam: "--chats",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			_, err := buildRoleMemberGroups(tt.users, tt.departments, tt.chats)
-			assertRoleValidationParam(t, err, tt.wantParam)
-		})
-	}
-}
-
-func TestBuildRoleMemberGroupsRejectsMoreThanMax(t *testing.T) {
-	users := make([]string, maxRoleMembers+1)
-	for i := range users {
-		users[i] = "ou_test"
-	}
-	_, err := buildRoleMemberGroups(strings.Join(users, ","), "", "")
-	assertRoleValidationParams(t, err, "--users")
-}
-
-func TestBuildRoleMemberGroupsRejectsMoreThanMaxOnlyChats(t *testing.T) {
-	chats := make([]string, maxRoleMembers+1)
-	for i := range chats {
-		chats[i] = "oc_test"
-	}
-	_, err := buildRoleMemberGroups("", "", strings.Join(chats, ","))
-	problem := assertRoleValidationParams(t, err, "--chats")
-	if !strings.Contains(problem.Message, "role members cannot exceed 100") {
-		t.Fatalf("message = %q, want role members limit", problem.Message)
-	}
-	if !strings.Contains(problem.Hint, "does not split") || !strings.Contains(problem.Hint, "atomic request") {
-		t.Fatalf("hint = %q, want no automatic batching guidance", problem.Hint)
-	}
-}
-
-func TestBuildRoleMemberGroupsOverflowNamesEveryContributingFlag(t *testing.T) {
-	users := strings.TrimSuffix(strings.Repeat("ou_user,", 60), ",")
-	chats := strings.TrimSuffix(strings.Repeat("oc_chat,", 41), ",")
-	_, err := buildRoleMemberGroups(users, "", chats)
-	assertRoleValidationParams(t, err, "--users", "--chats")
-}
-
-func TestRoleMemberKindsAreCompleteAndStable(t *testing.T) {
-	want := []roleMemberKind{
-		{memberType: "user", dataKey: "users", flagName: "--users", prefix: "ou_"},
-		{memberType: "department", dataKey: "departments", flagName: "--departments", prefix: "od-"},
-		{memberType: "chat", dataKey: "chats", flagName: "--chats", prefix: "oc_"},
-	}
-	if len(roleMemberKinds) != len(want) {
-		t.Fatalf("roleMemberKinds = %#v, want %#v", roleMemberKinds, want)
-	}
-	for index := range want {
-		if roleMemberKinds[index] != want[index] {
-			t.Fatalf("roleMemberKinds[%d] = %#v, want %#v", index, roleMemberKinds[index], want[index])
-		}
-	}
-}
-
-func TestRoleDisplayValueSanitizesAndFlattens(t *testing.T) {
-	got := roleDisplayValue("  Admin\n\x1b[31mred\x1b[0m\tvalue  ")
-	if got != "Admin red value" {
-		t.Fatalf("roleDisplayValue() = %q, want flattened safe text", got)
-	}
-}
-
-func TestRoleNextPageToken(t *testing.T) {
-	if got := roleNextPageToken(40, 20, true); got != "60" {
-		t.Fatalf("roleNextPageToken(hasMore) = %q, want 60", got)
-	}
-	if got := roleNextPageToken(40, 20, false); got != "" {
-		t.Fatalf("roleNextPageToken(!hasMore) = %q, want empty", got)
-	}
-}
-
-func TestWithRoleErrorHintUsesDocumentedRecoveryAndPreservesEnvelope(t *testing.T) {
-	tests := []struct {
-		name      string
-		code      int
-		operation roleErrorOperation
-		wantHint  string
-		forbid    string
-	}{
-		{name: "invalid parameters", code: roleErrInvalidParameters, operation: roleOperationList, wantHint: roleAppHint},
-		{name: "administrator required", code: roleErrAdminRequired, operation: roleOperationList, wantHint: "app administrator"},
-		{name: "administrator or developer required", code: roleErrManagerRequired, operation: roleOperationGet, wantHint: "administrator or app developer"},
-		{name: "invalid create role id", code: roleErrInvalidRoleID, operation: roleOperationCreate, wantHint: "omit --role-id"},
-		{name: "role missing", code: roleErrRoleNotFound, operation: roleOperationGet, wantHint: "+role-list"},
-		{name: "stale match role", code: roleErrRoleNotFound, operation: roleOperationMatchList, wantHint: "may no longer be valid", forbid: "--role-id"},
-		{name: "duplicate role id", code: roleErrRoleAlreadyExists, operation: roleOperationCreate, wantHint: "different --role-id"},
-		{name: "role limit", code: roleErrRoleLimitExceeded, operation: roleOperationCreate, wantHint: "delete an unused app role"},
-		{name: "invalid role name", code: roleErrInvalidRoleName, operation: roleOperationUpdate, wantHint: "adjust --name"},
-		{name: "invalid role description", code: roleErrInvalidRoleDescription, operation: roleOperationUpdate, wantHint: "adjust --description"},
-		{name: "unsupported member type", code: roleErrUnsupportedMemberType, operation: roleOperationMemberList, wantHint: "user, department, or chat"},
-		{name: "invalid member id", code: roleErrInvalidMemberID, operation: roleOperationMemberAdd, wantHint: "member IDs"},
-		{name: "invalid match target", code: roleErrInvalidMemberID, operation: roleOperationMatchList, wantHint: "--user-id", forbid: "--role-id"},
-		{name: "user quota", code: roleErrUserLimitExceeded, operation: roleOperationMemberAdd, wantHint: "reduce the users"},
-		{name: "department quota", code: roleErrDepartmentLimitExceeded, operation: roleOperationMemberAdd, wantHint: "reduce the departments"},
-		{name: "chat quota", code: roleErrChatLimitExceeded, operation: roleOperationMemberAdd, wantHint: "reduce the chats"},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			err := errclass.BuildAPIError(map[string]any{
-				"code":   tt.code,
-				"msg":    "role request failed",
-				"log_id": "log-role-hint",
-			}, errclass.ClassifyContext{Identity: "user"})
-			err = withRoleErrorHint(err, tt.operation)
-			problem, ok := errs.ProblemOf(err)
-			if !ok {
-				t.Fatalf("err = %#v, want typed problem", err)
-			}
-			if problem.Code != tt.code || problem.LogID != "log-role-hint" || problem.Retryable {
-				t.Fatalf("problem envelope changed: %+v", problem)
-			}
-			if !strings.Contains(problem.Hint, tt.wantHint) {
-				t.Fatalf("hint = %q, want substring %q", problem.Hint, tt.wantHint)
-			}
-			if tt.forbid != "" && strings.Contains(problem.Hint, tt.forbid) {
-				t.Fatalf("hint = %q, must not contain %q", problem.Hint, tt.forbid)
-			}
-		})
-	}
-}
-
-func TestWithRoleErrorHintPreservesServerDetail(t *testing.T) {
-	err := errclass.BuildAPIError(map[string]any{
-		"code": roleErrInvalidRoleName,
-		"msg":  "invalid role name",
-		"error": map[string]any{
-			"details": []any{map[string]any{"value": "name exceeds the service limit"}},
-		},
-	}, errclass.ClassifyContext{Identity: "user"})
-	err = withRoleErrorHint(err, roleOperationCreate)
-	problem, ok := errs.ProblemOf(err)
-	if !ok {
-		t.Fatalf("err = %#v, want typed problem", err)
-	}
-	for _, want := range []string{"name exceeds the service limit", "adjust --name"} {
-		if !strings.Contains(problem.Hint, want) {
-			t.Fatalf("hint = %q, want %q", problem.Hint, want)
-		}
-	}
-}
-
-func TestWithRoleErrorHintPreservesAuthorizationDetail(t *testing.T) {
-	var err error = errs.NewPermissionError(errs.SubtypePermissionDenied, "administrator access required").
-		WithCode(roleErrAdminRequired).
-		WithHint("server detail: only owners may change this app")
-	err = withRoleErrorHint(err, roleOperationUpdate)
-	problem, ok := errs.ProblemOf(err)
-	if !ok {
-		t.Fatalf("err = %#v, want typed problem", err)
-	}
-	for _, want := range []string{"server detail: only owners", "ask an app administrator"} {
-		if !strings.Contains(problem.Hint, want) {
-			t.Fatalf("hint = %q, want %q", problem.Hint, want)
-		}
-	}
-}

shortcuts/apps/apps_role_member.go

@@ -1,611 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package apps
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"strings"
-	"text/tabwriter"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/internal/validate"
-	"github.com/larksuite/cli/shortcuts/common"
-)
-
-// AppsRoleMemberList lists members of an app role.
-var AppsRoleMemberList = common.Shortcut{
-	Service:     appsService,
-	Command:     "+role-member-list",
-	Description: "List app role members",
-	Risk:        "read",
-	Tips: []string{
-		"Example: lark-cli apps +role-member-list --app-id <app_id> --role-id <role_id>",
-		"Example: lark-cli apps +role-member-list --app-id <app_id> --role-id <role_id> --member-type user",
-		"When only one member type is requested, pass --member-type user|department|chat instead of filtering the full response",
-		"--member-type returns only the selected member field; omitted fields are unknown, so omit the flag for pre/post-write baselines",
-		"--format table renders the CLI-native member_type/member_id table; this command has no --limit or --page-size flag",
-	},
-	Scopes:    []string{"spark:app:read"},
-	AuthTypes: []string{"user"},
-	HasFormat: true,
-	Flags: []common.Flag{
-		{Name: "app-id", Desc: roleAppIDRequiredDesc, Required: true},
-		{Name: "role-id", Desc: roleIDRequiredDesc, Required: true},
-		{Name: "member-type", Desc: "filter member type", Enum: []string{"user", "department", "chat"}},
-	},
-	Validate: func(ctx context.Context, rctx *common.RuntimeContext) error {
-		if err := validateRoleID(rctx); err != nil {
-			return err
-		}
-		_, err := buildRoleMemberListParams(rctx)
-		return err
-	},
-	DryRun: func(ctx context.Context, rctx *common.RuntimeContext) *common.DryRunAPI {
-		// Validate already ran and called buildRoleMemberListParams; error is impossible here.
-		params, _ := buildRoleMemberListParams(rctx)
-		return common.NewDryRunAPI().
-			GET(roleMemberListURL(rctx)).
-			Desc("List app role members").
-			Params(params)
-	},
-	Execute: func(ctx context.Context, rctx *common.RuntimeContext) error {
-		params, err := buildRoleMemberListParams(rctx)
-		if err != nil {
-			return err
-		}
-		data, err := rctx.CallAPITyped("GET", roleMemberListURL(rctx), params, nil)
-		memberType, _ := params["member_type"].(string)
-		if shouldRetryRoleMemberListWithoutFilter(err, memberType) {
-			fmt.Fprintln(rctx.IO().ErrOut, "warning: the server rejected chat member filtering; retried without the filter and returned only the chats field. Omit --member-type for a complete member baseline.")
-			data, err = rctx.CallAPITyped("GET", roleMemberListURL(rctx), nil, nil)
-		}
-		if err != nil {
-			return withRoleErrorHint(err, roleOperationMemberList)
-		}
-		data, err = normalizeRoleMemberListData(data, memberType)
-		if err != nil {
-			return err
-		}
-		if memberType != "" {
-			fmt.Fprintf(
-				rctx.IO().ErrOut,
-				"warning: --member-type=%s returns only the selected member field; omitted member fields are unknown. Omit --member-type for a complete member baseline.\n",
-				memberType,
-			)
-		}
-		out := roleMemberListOutputData(rctx, data)
-		rctx.OutFormat(out, nil, func(w io.Writer) {
-			renderRoleMemberListPretty(w, data)
-		})
-		return nil
-	},
-}
-
-// AppsRoleMemberAdd adds members to an app role.
-var AppsRoleMemberAdd = common.Shortcut{
-	Service:     appsService,
-	Command:     "+role-member-add",
-	Description: "Add app role members",
-	Risk:        "write",
-	Tips: []string{
-		"Example: lark-cli apps +role-member-add --app-id <app_id> --role-id <role_id> --users ou_x",
-		"Example: lark-cli apps +role-member-add --app-id <app_id> --role-id <role_id> --users ou_x,ou_y --departments od-x --chats oc_x",
-		"Resolve every name first, then add all resolved users (ou_), departments (od-), and chats (oc_) in one call using the three type-specific flags; if any resolution fails, stop without a partial write",
-	},
-	Scopes:    []string{"spark:app:write"},
-	AuthTypes: []string{"user"},
-	HasFormat: true,
-	Flags: []common.Flag{
-		{Name: "app-id", Desc: roleAppIDRequiredDesc, Required: true},
-		{Name: "role-id", Desc: roleIDRequiredDesc, Required: true},
-		{Name: "users", Desc: "comma-separated user open IDs; do not pass names or emails"},
-		{Name: "departments", Desc: "comma-separated open_department_id values"},
-		{Name: "chats", Desc: "comma-separated open_chat_id values"},
-	},
-	Validate: func(ctx context.Context, rctx *common.RuntimeContext) error {
-		if err := validateRoleID(rctx); err != nil {
-			return err
-		}
-		_, err := buildRoleMemberGroups(rctx.Str("users"), rctx.Str("departments"), rctx.Str("chats"))
-		return err
-	},
-	DryRun: func(ctx context.Context, rctx *common.RuntimeContext) *common.DryRunAPI {
-		// Validate already ran and called buildRoleMemberAddBody; error is impossible here.
-		body, _, _ := buildRoleMemberAddBody(rctx)
-		return common.NewDryRunAPI().
-			POST(roleMemberAddURL(rctx)).
-			Desc("Add app role members").
-			Body(body)
-	},
-	Execute: func(ctx context.Context, rctx *common.RuntimeContext) error {
-		body, _, err := buildRoleMemberAddBody(rctx)
-		if err != nil {
-			return err
-		}
-		data, err := rctx.CallAPITyped("POST", roleMemberAddURL(rctx), nil, body)
-		if err != nil {
-			return withRoleErrorHint(err, roleOperationMemberAdd)
-		}
-		data, err = normalizeRoleMemberMutationData(data)
-		if err != nil {
-			return err
-		}
-		rctx.OutFormat(data, nil, func(w io.Writer) {
-			renderRoleMemberMutationPretty(w, data)
-		})
-		return nil
-	},
-}
-
-// AppsRoleMemberRemove removes members from an app role.
-var AppsRoleMemberRemove = common.Shortcut{
-	Service:     appsService,
-	Command:     "+role-member-remove",
-	Description: "Remove app role members",
-	Risk:        "high-risk-write",
-	Tips: []string{
-		"Example: lark-cli apps +role-member-remove --app-id <app_id> --role-id <role_id> --users ou_x --yes",
-		"Example: lark-cli apps +role-member-remove --app-id <app_id> --role-id <role_id> --all --yes",
-		"When the user names a member, resolve and verify that exact name before writing; if lookup fails, stop and never infer that the role's only current member is the target",
-		"--all clears members but does not delete the role; after a confirmed --all operation, use an unfiltered +role-member-list to verify users, departments, and chats are empty",
-	},
-	Scopes:    []string{"spark:app:write"},
-	AuthTypes: []string{"user"},
-	HasFormat: true,
-	Flags: []common.Flag{
-		{Name: "app-id", Desc: roleAppIDRequiredDesc, Required: true},
-		{Name: "role-id", Desc: roleIDRequiredDesc, Required: true},
-		{Name: "users", Desc: "comma-separated user open IDs; do not pass names or emails"},
-		{Name: "departments", Desc: "comma-separated open_department_id values"},
-		{Name: "chats", Desc: "comma-separated open_chat_id values"},
-		{Name: "all", Type: "bool", Desc: "remove all members from the role"},
-	},
-	Validate: func(ctx context.Context, rctx *common.RuntimeContext) error {
-		if err := validateRoleID(rctx); err != nil {
-			return err
-		}
-		_, _, err := buildRoleMemberRemoveBody(rctx)
-		return err
-	},
-	DryRun: func(ctx context.Context, rctx *common.RuntimeContext) *common.DryRunAPI {
-		// Validate already ran and called buildRoleMemberRemoveBody; error is impossible here.
-		body, _, _ := buildRoleMemberRemoveBody(rctx)
-		return common.NewDryRunAPI().
-			POST(roleMemberRemoveURL(rctx)).
-			Desc("Remove app role members").
-			Body(body)
-	},
-	Execute: func(ctx context.Context, rctx *common.RuntimeContext) error {
-		body, _, err := buildRoleMemberRemoveBody(rctx)
-		if err != nil {
-			return err
-		}
-		data, err := rctx.CallAPITyped("POST", roleMemberRemoveURL(rctx), nil, body)
-		if err != nil {
-			return withRoleErrorHint(err, roleOperationMemberRemove)
-		}
-		data, err = normalizeRoleMemberMutationData(data)
-		if err != nil {
-			return err
-		}
-		rctx.OutFormat(data, nil, func(w io.Writer) {
-			renderRoleMemberMutationPretty(w, data)
-		})
-		return nil
-	},
-}
-
-// AppsRoleMatchList lists roles matching a user in an app.
-var AppsRoleMatchList = common.Shortcut{
-	Service:     appsService,
-	Command:     "+role-match-list",
-	Description: "List app roles matching a user",
-	Risk:        "read",
-	Tips: []string{
-		"Example: lark-cli apps +role-match-list --app-id <app_id> --user-id <user_open_id>",
-	},
-	Scopes:    []string{"spark:app:read"},
-	AuthTypes: []string{"user"},
-	HasFormat: true,
-	Flags: []common.Flag{
-		{Name: "app-id", Desc: roleAppIDRequiredDesc, Required: true},
-		{Name: "user-id", Desc: roleUserIDRequiredDesc, Required: true},
-	},
-	Validate: func(ctx context.Context, rctx *common.RuntimeContext) error {
-		if err := validateRoleAppID(rctx); err != nil {
-			return err
-		}
-		_, err := roleMatchTargetUserID(rctx)
-		return err
-	},
-	DryRun: func(ctx context.Context, rctx *common.RuntimeContext) *common.DryRunAPI {
-		// Validate already ran and called buildRoleMatchListBody; error is impossible here.
-		body, _ := buildRoleMatchListBody(rctx)
-		return common.NewDryRunAPI().
-			POST(roleMatchListURL(rctx)).
-			Desc("List app role matches").
-			Body(body)
-	},
-	Execute: func(ctx context.Context, rctx *common.RuntimeContext) error {
-		body, err := buildRoleMatchListBody(rctx)
-		if err != nil {
-			return err
-		}
-		data, err := rctx.CallAPITyped("POST", roleMatchListURL(rctx), nil, body)
-		if err != nil {
-			return withRoleErrorHint(err, roleOperationMatchList)
-		}
-		out, err := normalizeRoleMatchListData(data)
-		if err != nil {
-			return err
-		}
-		rctx.OutFormat(out, nil, func(w io.Writer) {
-			renderRoleMatchListPretty(w, common.GetSlice(out, "roles"))
-		})
-		return nil
-	},
-}
-
-func roleMemberListURL(rctx *common.RuntimeContext) string {
-	return fmt.Sprintf(roleMemberListPath,
-		validate.EncodePathSegment(roleAppID(rctx)),
-		validate.EncodePathSegment(roleID(rctx)),
-	)
-}
-
-func roleMemberAddURL(rctx *common.RuntimeContext) string {
-	return fmt.Sprintf(roleMemberAddPath,
-		validate.EncodePathSegment(roleAppID(rctx)),
-		validate.EncodePathSegment(roleID(rctx)),
-	)
-}
-
-func roleMemberRemoveURL(rctx *common.RuntimeContext) string {
-	return fmt.Sprintf(roleMemberRemovePath,
-		validate.EncodePathSegment(roleAppID(rctx)),
-		validate.EncodePathSegment(roleID(rctx)),
-	)
-}
-
-func roleMatchListURL(rctx *common.RuntimeContext) string {
-	return fmt.Sprintf(roleMatchListPath, validate.EncodePathSegment(roleAppID(rctx)))
-}
-
-func buildRoleMemberListParams(rctx *common.RuntimeContext) (map[string]interface{}, error) {
-	params := map[string]interface{}{}
-	if memberType := strings.TrimSpace(rctx.Str("member-type")); memberType != "" {
-		if _, ok := roleMemberKindForType(memberType); !ok {
-			return nil, appsValidationParamError("--member-type", "--member-type must be one of user, department, or chat").
-				WithHint("omit --member-type to list all member types")
-		}
-		params["member_type"] = memberType
-	}
-	return params, nil
-}
-
-func shouldRetryRoleMemberListWithoutFilter(err error, memberType string) bool {
-	if err == nil || memberType != "chat" {
-		return false
-	}
-	problem, ok := errs.ProblemOf(err)
-	if !ok {
-		return false
-	}
-	if problem.Code == roleErrUnsupportedMemberType || problem.Code == 400004040 {
-		return true
-	}
-	return problem.Code == 2 && strings.Contains(strings.ToLower(problem.Message), "member_type")
-}
-
-func normalizeRoleMemberListData(data map[string]interface{}, memberType string) (map[string]interface{}, error) {
-	if data == nil {
-		return nil, errs.NewInternalError(
-			errs.SubtypeInvalidResponse,
-			"role member response data must be an object",
-		).WithHint("retry the complete member read; do not treat missing, null, or non-object data as an empty role")
-	}
-	out := map[string]interface{}{}
-	for k, v := range data {
-		out[k] = v
-	}
-	// The role service uses an exact empty data object when the requested member
-	// view is empty. For a filtered request, that proves only the selected group
-	// is empty; non-selected groups must remain omitted rather than being
-	// synthesized as empty.
-	if len(data) == 0 {
-		if memberType != "" {
-			kind, _ := roleMemberKindForType(memberType)
-			out[kind.dataKey] = []string{}
-			return out, nil
-		}
-		for _, kind := range roleMemberKinds {
-			out[kind.dataKey] = []string{}
-		}
-		return out, nil
-	}
-	if memberType != "" {
-		selectedKind, _ := roleMemberKindForType(memberType)
-		values, err := parseRoleMemberIDs(data, selectedKind)
-		if err != nil {
-			return nil, err
-		}
-		for _, kind := range roleMemberKinds {
-			if kind.memberType != memberType {
-				delete(out, kind.dataKey)
-			}
-		}
-		out[selectedKind.dataKey] = values
-		return out, nil
-	}
-	for _, kind := range roleMemberKinds {
-		values, err := parseRoleMemberIDs(data, kind)
-		if err != nil {
-			return nil, err
-		}
-		out[kind.dataKey] = values
-	}
-	return out, nil
-}
-
-func parseRoleMemberIDs(data map[string]interface{}, kind roleMemberKind) ([]string, error) {
-	raw, exists := data[kind.dataKey]
-	if !exists {
-		return nil, errs.NewInternalError(
-			errs.SubtypeInvalidResponse,
-			"role member response is missing %s",
-			kind.dataKey,
-		).WithHint("retry the member operation; do not treat a missing member group as empty")
-	}
-	items, ok := raw.([]interface{})
-	if !ok {
-		if stringItems, stringOK := raw.([]string); stringOK {
-			items = make([]interface{}, len(stringItems))
-			for index, value := range stringItems {
-				items[index] = value
-			}
-		} else {
-			return nil, errs.NewInternalError(
-				errs.SubtypeInvalidResponse,
-				"role member response field %s must be an array of strings",
-				kind.dataKey,
-			).WithHint("retry the member operation; do not use malformed member data as a permission baseline")
-		}
-	}
-	values := make([]string, 0, len(items))
-	for index, item := range items {
-		value, ok := item.(string)
-		value = strings.TrimSpace(value)
-		if !ok || value == "" || !strings.HasPrefix(value, kind.prefix) || len(value) == len(kind.prefix) {
-			return nil, errs.NewInternalError(
-				errs.SubtypeInvalidResponse,
-				"role member response field %s contains an invalid ID at index %d",
-				kind.dataKey,
-				index,
-			).WithHint("retry the member operation; expected open IDs with the documented member-type prefix")
-		}
-		values = append(values, value)
-	}
-	return values, nil
-}
-
-func normalizeRoleMemberMutationData(data map[string]interface{}) (map[string]interface{}, error) {
-	if data == nil {
-		return nil, nil
-	}
-	out := map[string]interface{}{}
-	for key, value := range data {
-		out[key] = value
-	}
-	for _, kind := range roleMemberKinds {
-		if _, exists := data[kind.dataKey]; !exists {
-			continue
-		}
-		values, err := parseRoleMemberIDs(data, kind)
-		if err != nil {
-			return nil, err
-		}
-		out[kind.dataKey] = values
-	}
-	return out, nil
-}
-
-func buildRoleMemberAddBody(rctx *common.RuntimeContext) (map[string]interface{}, roleMemberGroups, error) {
-	groups, err := buildRoleMemberGroups(rctx.Str("users"), rctx.Str("departments"), rctx.Str("chats"))
-	if err != nil {
-		return nil, groups, err
-	}
-	return buildRoleMemberBody(groups), groups, nil
-}
-
-func buildRoleMemberRemoveBody(rctx *common.RuntimeContext) (map[string]interface{}, roleMemberGroups, error) {
-	if rctx.Bool("all") {
-		if hasExplicitRoleMemberFlags(rctx) {
-			return nil, roleMemberGroups{}, appsValidationError("--all cannot be used with --users, --departments, or --chats").
-				WithParams(roleMemberRemoveConflictParams(rctx)...).
-				WithHint("use --all by itself to clear every member, or pass explicit member IDs without --all")
-		}
-		return map[string]interface{}{"all": true}, roleMemberGroups{}, nil
-	}
-	if !hasExplicitRoleMemberFlags(rctx) {
-		reason := "provide member IDs or use --all"
-		return nil, roleMemberGroups{}, appsValidationError("specify members to remove with --users/--departments/--chats, or use --all to clear every member").
-			WithParams(
-				appsInvalidParam("--users", reason),
-				appsInvalidParam("--departments", reason),
-				appsInvalidParam("--chats", reason),
-				appsInvalidParam("--all", reason),
-			).
-			WithHint("pass specific member IDs (e.g. --users ou_x), or use --all to remove all members")
-	}
-	groups, err := buildRoleMemberGroups(rctx.Str("users"), rctx.Str("departments"), rctx.Str("chats"))
-	if err != nil {
-		return nil, groups, err
-	}
-	return buildRoleMemberBody(groups), groups, nil
-}
-
-func roleMemberRemoveConflictParams(rctx *common.RuntimeContext) []errs.InvalidParam {
-	reason := "cannot be combined with --all"
-	params := []errs.InvalidParam{appsInvalidParam("--all", "cannot be combined with explicit member flags")}
-	for _, kind := range roleMemberKinds {
-		if strings.TrimSpace(rctx.Str(strings.TrimPrefix(kind.flagName, "--"))) != "" {
-			params = append(params, appsInvalidParam(kind.flagName, reason))
-		}
-	}
-	return params
-}
-
-func hasExplicitRoleMemberFlags(rctx *common.RuntimeContext) bool {
-	return strings.TrimSpace(rctx.Str("users")) != "" ||
-		strings.TrimSpace(rctx.Str("departments")) != "" ||
-		strings.TrimSpace(rctx.Str("chats")) != ""
-}
-
-func buildRoleMatchListBody(rctx *common.RuntimeContext) (map[string]interface{}, error) {
-	targetUserID, err := roleMatchTargetUserID(rctx)
-	if err != nil {
-		return nil, err
-	}
-	return map[string]interface{}{"target_user_id": targetUserID}, nil
-}
-
-func roleMatchTargetUserID(rctx *common.RuntimeContext) (string, error) {
-	raw := strings.TrimSpace(rctx.Str("user-id"))
-	if raw == "" {
-		return "", appsValidationParamError("--user-id", "--user-id is required").
-			WithHint("resolve the user to open_id first, then pass --user-id <open_id>")
-	}
-	if err := validateMemberID(raw, "--user-id"); err != nil {
-		return "", err
-	}
-	return raw, nil
-}
-
-func roleMemberListOutputData(rctx *common.RuntimeContext, data map[string]interface{}) interface{} {
-	switch rctx.Format {
-	case "table", "csv", "ndjson":
-		return roleMemberRows(data)
-	default:
-		return data
-	}
-}
-
-func roleMemberRows(data map[string]interface{}) []interface{} {
-	rows := []interface{}{}
-	addRows := func(memberType string, values []string) {
-		for _, value := range values {
-			rows = append(rows, map[string]interface{}{
-				"member_type": memberType,
-				"member_id":   value,
-			})
-		}
-	}
-	for _, kind := range roleMemberKinds {
-		addRows(kind.memberType, roleIDValues(data[kind.dataKey]))
-	}
-	return rows
-}
-
-func normalizeRoleMatchListData(data map[string]interface{}) (map[string]interface{}, error) {
-	rawRoles, exists := data["roles"]
-	roles, ok := rawRoles.([]interface{})
-	if !exists || !ok {
-		return nil, errs.NewInternalError(
-			errs.SubtypeInvalidResponse,
-			"role match response field roles must be an array",
-		).WithHint("retry the user-role lookup; do not treat a missing or malformed roles field as no matches")
-	}
-	if err := validateRoleCollection(roles, "role match response field roles"); err != nil {
-		return nil, err
-	}
-	out := map[string]interface{}{}
-	for k, v := range data {
-		out[k] = v
-	}
-	out["roles"] = roles
-	return out, nil
-}
-
-func renderRoleMemberListPretty(w io.Writer, data map[string]interface{}) {
-	renderRoleMemberGroupsPretty(w, data)
-}
-
-func renderRoleMemberGroupsPretty(w io.Writer, data map[string]interface{}) {
-	for _, kind := range roleMemberKinds {
-		value, exists := data[kind.dataKey]
-		if !exists {
-			continue
-		}
-		renderRoleMemberSection(w, kind.dataKey, roleIDValues(value))
-	}
-}
-
-func renderRoleMemberMutationPretty(w io.Writer, data map[string]interface{}) {
-	renderedGroup := false
-	for _, kind := range roleMemberKinds {
-		value, exists := data[kind.dataKey]
-		if !exists {
-			continue
-		}
-		renderRoleMemberSection(w, kind.dataKey, roleIDValues(value))
-		renderedGroup = true
-	}
-	if !renderedGroup {
-		fmt.Fprintln(w, "Role member update accepted; use +role-member-list to verify current members.")
-	}
-}
-
-func renderRoleMemberSection(w io.Writer, label string, values []string) {
-	if len(values) == 0 {
-		fmt.Fprintf(w, "%s: []\n", label)
-		return
-	}
-	fmt.Fprintf(w, "%s:\n", label)
-	for _, value := range values {
-		fmt.Fprintf(w, "  - %s\n", roleDisplayValue(value))
-	}
-}
-
-func roleIDValues(value interface{}) []string {
-	switch items := value.(type) {
-	case []string:
-		out := make([]string, 0, len(items))
-		for _, item := range items {
-			if item = strings.TrimSpace(item); item != "" {
-				out = append(out, item)
-			}
-		}
-		return out
-	case []interface{}:
-		out := make([]string, 0, len(items))
-		for _, item := range items {
-			v, ok := item.(string)
-			if ok && strings.TrimSpace(v) != "" {
-				out = append(out, strings.TrimSpace(v))
-			}
-		}
-		return out
-	default:
-		return nil
-	}
-}
-
-func renderRoleMatchListPretty(w io.Writer, items []interface{}) {
-	tw := tabwriter.NewWriter(w, 0, 0, 2, ' ', 0)
-	fmt.Fprintln(tw, "ROLE ID\tNAME\tDESCRIPTION")
-	for _, item := range items {
-		role, ok := item.(map[string]interface{})
-		if !ok {
-			continue
-		}
-		fmt.Fprintf(tw, "%s\t%s\t%s\n",
-			roleDisplayValue(firstNonEmpty(common.GetString(role, "role_id"), common.GetString(role, "id"))),
-			roleDisplayValue(common.GetString(role, "name")),
-			roleDisplayValue(common.GetString(role, "description")),
-		)
-	}
-	_ = tw.Flush()
-}

shortcuts/apps/automation_common.go

@@ -1,453 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package apps
-
-import (
-	"fmt"
-	"sort"
-	"strconv"
-	"strings"
-	"unicode/utf8"
-
-	"github.com/larksuite/cli/internal/validate"
-	"github.com/larksuite/cli/shortcuts/common"
-)
-
-// automationBasePath 是触发器公网 OpenAPI 前缀。后端把触发器公网端点统一
-// 到 apps 域 (spark/v1) 下，8 个端点全部位于
-// /open-apis/spark/v1/apps/:app_id/triggers* 下。这里直接复用同包的
-// apiBasePath 而不是自定义前缀，避免误用早期的备选前缀。
-const automationBasePath = apiBasePath
-
-func automationListPath(appID string) string {
-	return fmt.Sprintf(automationBasePath+"/apps/%s/triggers", validate.EncodePathSegment(appID))
-}
-
-func automationItemPath(appID, name string) string {
-	return fmt.Sprintf(automationBasePath+"/apps/%s/triggers/%s",
-		validate.EncodePathSegment(appID), validate.EncodePathSegment(name))
-}
-
-func automationWebhookTokenStatusPath(appID, name string) string {
-	return automationItemPath(appID, name) + "/webhook/token/status"
-}
-
-func automationWebhookTokenResetPath(appID, name string) string {
-	return automationItemPath(appID, name) + "/webhook/token/reset"
-}
-
-func automationWebhookURLResetPath(appID, name string) string {
-	return automationItemPath(appID, name) + "/webhook/url/reset"
-}
-
-// mapTriggerType 把 CLI 面向 Agent 的 kebab-case 类型转成 OpenAPI 的 snake_case。
-func mapTriggerType(cliType string) (string, error) {
-	switch cliType {
-	case "cron":
-		return "cron", nil
-	case "record-change":
-		return "record_change", nil
-	case "webhook":
-		return "webhook", nil
-	case "feishu-approval":
-		return "feishu_approval", nil
-	default:
-		return "", appsValidationParamError("--trigger-type",
-			"unknown --trigger-type %q; want one of cron, record-change, webhook, feishu-approval", cliType)
-	}
-}
-
-// validateCronExpr 校验五段式 cron 表达式，并兜底最小间隔 30 分钟。
-// 这是给 Agent 的即时提示；后端 OpenAPI 层也会校验（ErrInvalidCronTab /
-// ErrCronIntervalTooSmall），CLI 本地拦截只为更快反馈。
-//
-// Minute field accepted forms:
-//   - "N" (single value 0-59)
-//   - "N,M,..." (comma list of single values; min pairwise gap incl. wrap >= 30)
-//   - "*/N" (step from 0; N must be >= 30)
-//
-// Anything else (ranges like "N-M", stepped ranges like "N-M/S",
-// range shorthands like "0/10", question marks) is rejected up-front with a
-// typed --cron error. A previous version accepted "1-59/10" through the
-// fallthrough because none of the three matchers claimed it, and the caller
-// only found out the interval was 10 minutes when the backend rejected it
-// (or worse, silently accepted a schedule the operator did not intend).
-func validateCronExpr(expr string) error {
-	fields := strings.Fields(strings.TrimSpace(expr))
-	if len(fields) != 5 {
-		return appsValidationParamError("--cron",
-			"cron must have 5 fields (minute hour day month weekday), got %d in %q", len(fields), expr)
-	}
-	minute := fields[0]
-	if minute == "*" {
-		return appsValidationParamError("--cron",
-			"cron minute field '*' means every minute; minimum interval is 30 minutes")
-	}
-	if strings.HasPrefix(minute, "*/") {
-		n, err := strconv.Atoi(strings.TrimPrefix(minute, "*/"))
-		if err != nil || n < 1 || n > 59 {
-			return appsValidationParamError("--cron",
-				"cron minute step %q must be an integer 1..59", minute)
-		}
-		// */N in cron expands to [0, N, 2N, ...] within 0..59, then wraps to 0
-		// of the next hour. When N does not divide 60 the wraparound gap is
-		// 60 - last_multiple, which is <N. For the 30-minute floor to hold on
-		// every gap (in-hour AND wrap), *only* N=30 works: */30 fires at :00
-		// and :30, gaps [30, 30]. */45 fires at :00 and :45, gaps [45, 15] —
-		// the 15-min wraparound gap violates the floor. All 31..59 fail the
-		// same way (small wraparound remainder); 1..29 fail the in-hour gap.
-		if n != 30 {
-			return appsValidationParamError("--cron",
-				"cron step */%d produces a gap below the 30-minute minimum "+
-					"(only */30 keeps every gap >=30 including the wraparound); "+
-					"use */30, or an explicit list like '0,30'", n)
-		}
-		return nil
-	}
-	if strings.Contains(minute, ",") {
-		parts := strings.Split(minute, ",")
-		vals := make([]int, 0, len(parts))
-		for _, p := range parts {
-			p = strings.TrimSpace(p)
-			n, err := strconv.Atoi(p)
-			if err != nil || n < 0 || n > 59 {
-				return appsValidationParamError("--cron",
-					"cron minute list entry %q must be an integer 0..59", p)
-			}
-			vals = append(vals, n)
-		}
-		if len(vals) >= 2 {
-			sort.Ints(vals)
-			minGap := 60
-			for i := 1; i < len(vals); i++ {
-				if gap := vals[i] - vals[i-1]; gap < minGap {
-					minGap = gap
-				}
-			}
-			if wrapGap := vals[0] + 60 - vals[len(vals)-1]; wrapGap < minGap {
-				minGap = wrapGap
-			}
-			if minGap < 30 {
-				return appsValidationParamError("--cron",
-					"cron minute list %q has %d-min interval; minimum interval is 30 minutes", minute, minGap)
-			}
-		}
-		return nil
-	}
-	// Bare single value fallthrough. Reject range/step-range/anything else so
-	// forms like "1-59/10" (10-min interval) and "0/10" (10-min interval)
-	// cannot bypass the 30-minute floor. The backend enforces its own cron
-	// rules, but the CLI stays strict about which forms it accepts so callers
-	// get an early, unambiguous error.
-	if n, err := strconv.Atoi(minute); err == nil && n >= 0 && n <= 59 {
-		return nil
-	}
-	return appsValidationParamError("--cron",
-		"unsupported cron minute syntax %q; use N (0..59), N,M,... (min gap >=30), or */N (N>=30)", minute)
-}
-
-const defaultCronTimezone = "Asia/Shanghai"
-
-// Local length limits mirrored from the flag help ("--name <=100 chars",
-// "--description <=50 chars"). Enforcing here catches a violation before the
-// API round-trip and returns a typed --name / --description error, whereas
-// hitting the backend surfaces an opaque business error the agent has to
-// diagnose. Constants (not magic numbers) so the flag help and the check
-// share one source of truth if the backend ever renegotiates the limits.
-const (
-	automationNameMaxLen        = 100
-	automationDescriptionMaxLen = 50
-)
-
-// validateAutomationNameLen guards against a --name that would be rejected by
-// the backend on length. Empty is intentionally permitted here — the required
-// check lives in the create Validate hook (which fires first) and in Update
-// the flag is not required at all. Counts runes, not bytes: the flag help
-// documents "<=100 chars", and Chinese/emoji names would be silently rejected
-// well below the char limit if we counted UTF-8 bytes.
-func validateAutomationNameLen(name string) error {
-	if n := utf8.RuneCountInString(name); n > automationNameMaxLen {
-		return appsValidationParamError("--name",
-			"--name must be at most %d chars, got %d", automationNameMaxLen, n)
-	}
-	return nil
-}
-
-// validateAutomationDescriptionLen guards --description length; empty passes.
-// Counts runes for the same reason as validateAutomationNameLen.
-func validateAutomationDescriptionLen(desc string) error {
-	if n := utf8.RuneCountInString(desc); n > automationDescriptionMaxLen {
-		return appsValidationParamError("--description",
-			"--description must be at most %d chars, got %d", automationDescriptionMaxLen, n)
-	}
-	return nil
-}
-
-// conditionFlagFamily maps each condition-carrying flag to the trigger-type
-// family it belongs to. Used by create/update to reject cross-type flag
-// combinations up-front (e.g. --trigger-type webhook --cron '0 9 * * *'
-// silently dropped --cron before this guard).
-//
-// --timezone is a modifier on --cron, so it lives in the cron family.
-// --description is trigger-type-agnostic and NOT in this map — it can pair
-// with any type on create and can appear alone on update.
-var conditionFlagFamily = map[string]string{
-	"cron":            "cron",
-	"timezone":        "cron",
-	"table":           "record-change",
-	"event":           "record-change",
-	"fields":          "record-change",
-	"white-ip-list":   "webhook",
-	"event-type":      "feishu-approval",
-	"instance-status": "feishu-approval",
-	"task-status":     "feishu-approval",
-	"approval-code":   "feishu-approval",
-}
-
-// flagIsSet reports whether a condition-carrying flag has a caller-provided
-// value. string and string-array types both need to be probed; a nil / empty
-// value counts as unset.
-func flagIsSet(rctx *common.RuntimeContext, name string) bool {
-	if v := strings.TrimSpace(rctx.Str(name)); v != "" {
-		return true
-	}
-	if arr := rctx.StrArray(name); len(arr) > 0 {
-		return true
-	}
-	return false
-}
-
-// familiesInUse returns the set of trigger-type families whose condition flags
-// the caller has set on this invocation. A trigger has exactly one type, so
-// legitimate condition writes involve at most one family; anything else is a
-// user mistake that must not slip through to the backend.
-func familiesInUse(rctx *common.RuntimeContext) map[string]string {
-	out := map[string]string{}
-	for flag, family := range conditionFlagFamily {
-		if flagIsSet(rctx, flag) {
-			out[family] = flag
-		}
-	}
-	return out
-}
-
-// familiesMixedList renders a comma-separated, sorted list of families
-// currently in use for inclusion in the multi-family rejection error. Stable
-// order keeps the error message deterministic across Go's random map
-// iteration.
-func familiesMixedList(families map[string]string) string {
-	names := make([]string, 0, len(families))
-	for name := range families {
-		names = append(names, name)
-	}
-	sort.Strings(names)
-	return strings.Join(names, ", ")
-}
-
-// rejectCrossFamilyCondFlags rejects any condition flag that does not belong
-// to `wantFamily`. Returns a typed --<flag> error naming the first offending
-// flag encountered. Deterministic ordering (iterated over a stable slice)
-// keeps the error message reproducible for tests.
-func rejectCrossFamilyCondFlags(rctx *common.RuntimeContext, wantFamily string) error {
-	// Stable iteration order for a deterministic Param on error.
-	order := []string{
-		"cron", "timezone",
-		"table", "event", "fields",
-		"white-ip-list",
-		"event-type", "instance-status", "task-status", "approval-code",
-	}
-	for _, flag := range order {
-		if conditionFlagFamily[flag] != wantFamily && flagIsSet(rctx, flag) {
-			return appsValidationParamError("--"+flag,
-				"--%s belongs to trigger-type %q, not %q; drop it or change --trigger-type",
-				flag, conditionFlagFamily[flag], wantFamily)
-		}
-	}
-	return nil
-}
-
-// approvalStatusSets 是 feishu-approval 两种 event-type 各自的合法状态集合。
-// 后端 OpenAPI 不逐值校验 status，CLI 本地分桶校验是唯一保障。
-var approvalStatusSets = map[string]map[string]struct{}{
-	"approval_instance": setOf("PENDING", "APPROVED", "REJECTED", "CANCELED", "DELETED", "REVERTED", "OVERTIME_CLOSE", "OVERTIME_RECOVER"),
-	"approval_task":     setOf("REVERTED", "PENDING", "APPROVED", "REJECTED", "TRANSFERRED", "ROLLBACK", "DONE", "OVERTIME_CLOSE", "OVERTIME_RECOVER"),
-}
-
-func setOf(items ...string) map[string]struct{} {
-	m := make(map[string]struct{}, len(items))
-	for _, it := range items {
-		m[it] = struct{}{}
-	}
-	return m
-}
-
-// buildCronCondition 产出 OpenAPI 层 cron_condition body。缺省时区补 Asia/Shanghai。
-func buildCronCondition(expr, tz string) (map[string]interface{}, error) {
-	if err := validateCronExpr(expr); err != nil {
-		return nil, err
-	}
-	if strings.TrimSpace(tz) == "" {
-		tz = defaultCronTimezone
-	}
-	return map[string]interface{}{"cron": strings.TrimSpace(expr), "timezone": tz}, nil
-}
-
-// recordChangeEventSet 是 record-change 触发器合法 event 枚举。
-// 4 个值来自需求定义。CLI 本地做白名单校验，
-// 避免后端 event 字段校验缺失导致的"接受任意字符串→触发器永不触发"问题。
-var recordChangeEventSet = setOf("INSERT", "UPDATE", "UPSERT", "DELETE")
-
-// buildRecordChangeCondition 产出 record_change_condition body；event 大写化。
-func buildRecordChangeCondition(table, event string, fields []string) (map[string]interface{}, error) {
-	if strings.TrimSpace(table) == "" {
-		return nil, appsValidationParamError("--table", "--table is required for record-change triggers")
-	}
-	ev := strings.ToUpper(strings.TrimSpace(event))
-	if ev == "" {
-		return nil, appsValidationParamError("--event", "--event is required for record-change triggers (INSERT/UPDATE/UPSERT/DELETE)")
-	}
-	if _, valid := recordChangeEventSet[ev]; !valid {
-		return nil, appsValidationParamError("--event",
-			"--event %q is not a valid record-change event; want one of INSERT, UPDATE, UPSERT, DELETE", event)
-	}
-	cond := map[string]interface{}{"event": ev, "table": strings.TrimSpace(table)}
-	if len(fields) > 0 {
-		cond["fields"] = fields
-	}
-	return cond, nil
-}
-
-// buildWebhookCondition 产出 webhook_condition body。white_ip_list 在后端契约
-// 里是 required，因此当 CLI 侧未传 --white-ip-list 时也发一个空数组，避免后端
-// 拒收；显式空数组 `[]` 与"不限来源 IP"语义一致（呼应无鉴权公网回调告警）。
-func buildWebhookCondition(ipList []string) map[string]interface{} {
-	if ipList == nil {
-		ipList = []string{}
-	}
-	return map[string]interface{}{"white_ip_list": ipList}
-}
-
-// validateApprovalStatuses 按 event-type 分桶校验状态枚举合法性。
-func validateApprovalStatuses(eventType string, statuses []string) error {
-	set, ok := approvalStatusSets[eventType]
-	if !ok {
-		return appsValidationParamError("--event-type",
-			"unknown --event-type %q; want approval_task or approval_instance", eventType)
-	}
-	if len(statuses) == 0 {
-		flag := statusFlagFor(eventType)
-		return appsValidationParamError("--"+flag,
-			"--%s is required for event-type %q (at least one status)", flag, eventType)
-	}
-	for _, s := range statuses {
-		if _, valid := set[strings.ToUpper(strings.TrimSpace(s))]; !valid {
-			// 列出该 event-type 的合法状态集合，便于 Agent 修正。
-			return appsValidationParamError("--"+statusFlagFor(eventType),
-				"status %q is not valid for event-type %q; valid values: %s",
-				s, eventType, sortedStatusList(set))
-		}
-	}
-	return nil
-}
-
-// sortedStatusList 返回状态集合的稳定排序、逗号分隔字符串，用于错误提示。
-func sortedStatusList(set map[string]struct{}) string {
-	out := make([]string, 0, len(set))
-	for s := range set {
-		out = append(out, s)
-	}
-	sort.Strings(out)
-	return strings.Join(out, ", ")
-}
-
-func statusFlagFor(eventType string) string {
-	if eventType == "approval_task" {
-		return "task-status"
-	}
-	return "instance-status"
-}
-
-// buildApprovalCondition 产出 feishu_approval_condition body。approval_code 可选：
-// 空则省略（匹配所有审批定义），不发空串。
-func buildApprovalCondition(code, eventType string, statuses []string) (map[string]interface{}, error) {
-	if err := validateApprovalStatuses(eventType, statuses); err != nil {
-		return nil, err
-	}
-	cond := map[string]interface{}{"event_type": eventType, "status": statuses}
-	if strings.TrimSpace(code) != "" {
-		cond["approval_code"] = strings.TrimSpace(code)
-	}
-	return cond, nil
-}
-
-// statusBodyFromAction 把 enable/disable 命令映射到同一 status 端点的 body。
-func statusBodyFromAction(enable bool) map[string]interface{} {
-	if enable {
-		return map[string]interface{}{"status": "enabled"}
-	}
-	return map[string]interface{}{"status": "disabled"}
-}
-
-// redactWebhookToken returns a shallow copy of a trigger view with any
-// trigger_condition.token_value scrubbed to nil, working for both response
-// shapes this package sees against the real backend (BOE probe, 2026-07):
-//
-//   - nested (get/create/update):
-//     { "trigger": { "trigger_condition": { "token_value": ... } } }
-//   - flat (list items):
-//     { "trigger_condition": { "token_value": ... } }
-//
-// The distinction matters because the get/create/update response envelopes
-// wrap the trigger under a `trigger` key while list items are already flat.
-// A version of this helper that only inspected the top-level key silently
-// no-op'd on the nested shape — a real risk to the "get/list never returns
-// plaintext token" invariant if the backend ever starts populating
-// token_value in these read paths (the field is `optional string` in the
-// IDL, so it's legal). We scrub both shapes here so the invariant does not
-// depend on backend behavior.
-//
-// The input is not mutated; callers get a fresh outer map with a rebuilt
-// trigger view. Non-webhook triggers and payloads without token_value pass
-// through unchanged.
-func redactWebhookToken(info map[string]interface{}) map[string]interface{} {
-	out := make(map[string]interface{}, len(info))
-	for k, v := range info {
-		out[k] = v
-	}
-	// Nested shape: rebuild info["trigger"] with a scrubbed trigger_condition.
-	if wrapped, ok := info["trigger"].(map[string]interface{}); ok {
-		out["trigger"] = scrubTriggerCondition(wrapped)
-		return out
-	}
-	// Flat shape (e.g. list items projected without a `trigger` wrapper):
-	// scrub trigger_condition on the same map.
-	if _, hasFlat := info["trigger_condition"].(map[string]interface{}); hasFlat {
-		return scrubTriggerCondition(out)
-	}
-	return out
-}
-
-// scrubTriggerCondition returns a shallow copy of a trigger-shaped map with
-// its trigger_condition.token_value replaced by nil. Called by
-// redactWebhookToken for each shape it recognizes.
-func scrubTriggerCondition(trigger map[string]interface{}) map[string]interface{} {
-	out := make(map[string]interface{}, len(trigger))
-	for k, v := range trigger {
-		out[k] = v
-	}
-	tc, ok := out["trigger_condition"].(map[string]interface{})
-	if !ok {
-		return out
-	}
-	redactedTC := make(map[string]interface{}, len(tc))
-	for k, v := range tc {
-		if k == "token_value" {
-			redactedTC[k] = nil
-			continue
-		}
-		redactedTC[k] = v
-	}
-	out["trigger_condition"] = redactedTC
-	return out
-}

shortcuts/apps/automation_common_test.go

@@ -1,381 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package apps
-
-import (
-	"strings"
-	"testing"
-)
-
-func TestAutomationPaths(t *testing.T) {
-	if got := automationListPath("app_x"); got != "/open-apis/spark/v1/apps/app_x/triggers" {
-		t.Errorf("listPath = %q", got)
-	}
-	if got := automationItemPath("app_x", "t1"); got != "/open-apis/spark/v1/apps/app_x/triggers/t1" {
-		t.Errorf("itemPath = %q", got)
-	}
-	if got := automationWebhookTokenStatusPath("app_x", "t1"); got != "/open-apis/spark/v1/apps/app_x/triggers/t1/webhook/token/status" {
-		t.Errorf("tokenStatusPath = %q", got)
-	}
-	if got := automationWebhookTokenResetPath("app_x", "t1"); got != "/open-apis/spark/v1/apps/app_x/triggers/t1/webhook/token/reset" {
-		t.Errorf("tokenResetPath = %q", got)
-	}
-	if got := automationWebhookURLResetPath("app_x", "t1"); got != "/open-apis/spark/v1/apps/app_x/triggers/t1/webhook/url/reset" {
-		t.Errorf("urlResetPath = %q", got)
-	}
-}
-
-// TestValidateAutomationNameLen_CountsRunes pins the char-not-byte contract:
-// the flag help documents "<=100 chars", and Chinese/emoji names would be
-// silently rejected below the char limit if we counted UTF-8 bytes.
-// A 100-rune Chinese string is 300 bytes but is 100 chars — must pass.
-func TestValidateAutomationNameLen_CountsRunes(t *testing.T) {
-	// 100 Chinese characters (each 3 UTF-8 bytes = 300 bytes total). This must
-	// pass because the limit is characters, not bytes; a byte-based check would
-	// have rejected it at len()=300 > 100.
-	name := strings.Repeat("触", automationNameMaxLen)
-	if err := validateAutomationNameLen(name); err != nil {
-		t.Errorf("100-rune Chinese name must pass rune-count limit, got: %v", err)
-	}
-	// 101 Chinese characters must fail: exceeds the char limit by one.
-	over := strings.Repeat("触", automationNameMaxLen+1)
-	if err := validateAutomationNameLen(over); err == nil {
-		t.Error("101-rune Chinese name must fail rune-count limit")
-	}
-}
-
-func TestMapTriggerType(t *testing.T) {
-	cases := map[string]string{
-		"cron": "cron", "record-change": "record_change",
-		"webhook": "webhook", "feishu-approval": "feishu_approval",
-	}
-	for in, want := range cases {
-		got, err := mapTriggerType(in)
-		if err != nil || got != want {
-			t.Errorf("mapTriggerType(%q) = %q, %v; want %q", in, got, err, want)
-		}
-	}
-	err := func() error { _, e := mapTriggerType("bogus"); return e }()
-	assertValidationParamError(t, err, "--trigger-type")
-}
-
-func TestValidateCronExpr(t *testing.T) {
-	if err := validateCronExpr("0 9 * * *"); err != nil {
-		t.Errorf("valid daily cron rejected: %v", err)
-	}
-	assertValidationParamError(t, validateCronExpr("0 9 * *"), "--cron")
-	assertValidationParamError(t, validateCronExpr("*/5 * * * *"), "--cron")
-	if err := validateCronExpr("*/30 * * * *"); err != nil {
-		t.Errorf("30-minute interval must pass: %v", err)
-	}
-}
-
-// TestValidateCronExpr_RejectsRangeStepBypass pins two related tightenings:
-//
-//   - Range-step syntax like "1-59/10" or shorthand "0/10" is a 10-minute
-//     interval, but the old *,*/N,list-only matcher fell through and
-//     accepted these. The new whitelist rejects any minute form outside
-//     {"N", "N,M,...", "*/N"}.
-//   - */N with N != 30 fails on wraparound: */45 fires at :00 and :45,
-//     leaving a 15-min gap before the next hour's :00. In standard cron,
-//     */N expands to [0, N, 2N, ...] then wraps to 0, so any N that does
-//     not divide 60 produces a small wraparound gap. Only N=30 keeps
-//     every gap (in-hour AND wrap) >= 30.
-func TestValidateCronExpr_RejectsRangeStepBypass(t *testing.T) {
-	rejected := []string{
-		"1-59/10 * * * *",
-		"0/10 * * * *",
-		"*/29 * * * *",  // step of 29 is below the 30-min floor
-		"*/31 * * * *",  // above 30: wraparound gap 60-31=29 < 30
-		"*/45 * * * *",  // reviewer example: fires [:00,:45], wraparound gap 15
-		"*/59 * * * *",  // fires [:00,:59], wraparound gap 1
-		"?  * * * *",    // range/? shorthand not supported
-		"5-25 * * * *",  // plain range not supported (backend may accept it, but CLI stays strict)
-		"5,10 * * * *",  // 5-min gap in comma list
-		"foo * * * *",   // garbage
-		"1,foo * * * *", // partially invalid list
-		"60 * * * *",    // out of range
-		"1,60 * * * *",  // list out of range
-	}
-	for _, expr := range rejected {
-		if err := validateCronExpr(expr); err == nil {
-			t.Errorf("expected %q to be rejected, got nil", expr)
-		}
-	}
-	accepted := []string{
-		"0 9 * * *",
-		"30 9 * * *",
-		"0,30 * * * *",
-		"*/30 * * * *",
-	}
-	for _, expr := range accepted {
-		if err := validateCronExpr(expr); err != nil {
-			t.Errorf("expected %q to pass, got: %v", expr, err)
-		}
-	}
-}
-
-func TestBuildCronCondition(t *testing.T) {
-	c, err := buildCronCondition("0 9 * * *", "")
-	if err != nil {
-		t.Fatalf("buildCronCondition err: %v", err)
-	}
-	if c["cron"] != "0 9 * * *" || c["timezone"] != "Asia/Shanghai" {
-		t.Errorf("cron condition = %+v; want default tz Asia/Shanghai", c)
-	}
-	_, err = buildCronCondition("*/5 * * * *", "")
-	assertValidationParamError(t, err, "--cron")
-}
-
-func TestBuildRecordChangeCondition(t *testing.T) {
-	c, err := buildRecordChangeCondition("tbl_1", "update", []string{"status"})
-	if err != nil {
-		t.Fatalf("err: %v", err)
-	}
-	if c["event"] != "UPDATE" || c["table"] != "tbl_1" {
-		t.Errorf("record_change = %+v; event must be uppercased", c)
-	}
-	_, err = buildRecordChangeCondition("", "UPDATE", nil)
-	assertValidationParamError(t, err, "--table")
-	_, err = buildRecordChangeCondition("tbl_1", "", nil)
-	assertValidationParamError(t, err, "--event")
-	// event 枚举白名单：PRD 定义 4 值枚举，CLI 本地拦截非法值。这道防线
-	// 存在是因为后端 record_change_condition.event 字段接受任意字符串
-	// (2026-07-08 BOE 实测)，创建后触发器永远不触发，用户不易察觉。
-	_, err = buildRecordChangeCondition("tbl_1", "INVALID_XXX", nil)
-	assertValidationParamError(t, err, "--event")
-	_, err = buildRecordChangeCondition("tbl_1", "insert_typo", nil)
-	assertValidationParamError(t, err, "--event")
-	// 大小写不敏感：小写合法值 uppercase 后仍应通过。
-	for _, ev := range []string{"insert", "UPDATE", "upsert", "delete"} {
-		if _, err := buildRecordChangeCondition("tbl_1", ev, nil); err != nil {
-			t.Errorf("event %q must be accepted (case-insensitive): %v", ev, err)
-		}
-	}
-}
-
-func TestValidateApprovalStatuses(t *testing.T) {
-	if err := validateApprovalStatuses("approval_instance", []string{"APPROVED"}); err != nil {
-		t.Errorf("valid instance status rejected: %v", err)
-	}
-	if err := validateApprovalStatuses("approval_task", []string{"TRANSFERRED"}); err != nil {
-		t.Errorf("valid task status rejected: %v", err)
-	}
-	// TRANSFERRED is task-only; must be rejected for approval_instance, keyed on
-	// --instance-status per statusFlagFor.
-	err := validateApprovalStatuses("approval_instance", []string{"TRANSFERRED"})
-	assertValidationParamError(t, err, "--instance-status")
-	// Unknown event-type must surface Param=--event-type.
-	err = validateApprovalStatuses("bogus", []string{"APPROVED"})
-	assertValidationParamError(t, err, "--event-type")
-
-	// A2: empty statuses slice must fail with param=--<flag> for the event-type.
-	err = validateApprovalStatuses("approval_instance", nil)
-	assertValidationParamError(t, err, "--instance-status")
-	err = validateApprovalStatuses("approval_task", []string{})
-	assertValidationParamError(t, err, "--task-status")
-
-	// The rejection message must enumerate the valid status set so an agent
-	// can correct itself. Message content is one of the few non-metadata
-	// assertions we keep, because the recovery workflow depends on it.
-	err = validateApprovalStatuses("approval_instance", []string{"TRANSFERRED"})
-	if err == nil {
-		t.Fatal("TRANSFERRED must be rejected for approval_instance")
-	}
-	msg := err.Error()
-	if !strings.Contains(msg, "valid values:") {
-		t.Errorf("error must list valid values, got: %s", msg)
-	}
-	if !strings.Contains(msg, "APPROVED") || !strings.Contains(msg, "PENDING") {
-		t.Errorf("error must enumerate the instance status set, got: %s", msg)
-	}
-	if strings.Contains(msg, "TRANSFERRED") && !strings.Contains(msg, "not valid") {
-		t.Errorf("instance valid-list must not include task-only TRANSFERRED, got: %s", msg)
-	}
-}
-
-func TestBuildApprovalCondition_CodeOptional(t *testing.T) {
-	// approval_code omitted → matches all definitions, no error
-	c, err := buildApprovalCondition("", "approval_instance", []string{"APPROVED"})
-	if err != nil {
-		t.Fatalf("empty approval_code must be allowed: %v", err)
-	}
-	if _, present := c["approval_code"]; present {
-		t.Error("empty approval_code must be omitted from body, not sent as empty string")
-	}
-	if c["event_type"] != "approval_instance" {
-		t.Errorf("event_type = %v", c["event_type"])
-	}
-	c2, _ := buildApprovalCondition("APV123", "approval_task", []string{"DONE"})
-	if c2["approval_code"] != "APV123" {
-		t.Errorf("approval_code = %v; want APV123", c2["approval_code"])
-	}
-}
-
-func TestStatusBodyFromAction(t *testing.T) {
-	if b := statusBodyFromAction(true); b["status"] != "enabled" {
-		t.Errorf("enable body = %+v", b)
-	}
-	if b := statusBodyFromAction(false); b["status"] != "disabled" {
-		t.Errorf("disable body = %+v", b)
-	}
-}
-
-// TestRedactWebhookToken exercises the flat shape (list items pass the
-// projected trigger view without a `trigger` wrapper) — token_value must be
-// scrubbed at the top-level trigger_condition.
-func TestRedactWebhookToken(t *testing.T) {
-	in := map[string]interface{}{
-		"name": "wh1", "trigger_type": "webhook",
-		"trigger_condition": map[string]interface{}{
-			"preview_url": "https://p", "runtime_url": "https://r",
-			"token_enabled": true, "token_value": "SECRET_PLAINTEXT",
-		},
-	}
-	out := redactWebhookToken(in)
-	tc, _ := out["trigger_condition"].(map[string]interface{})
-	if tc["token_value"] != nil {
-		t.Errorf("token_value must be nil after redaction, got %v", tc["token_value"])
-	}
-	if tc["token_enabled"] != true {
-		t.Errorf("token_enabled must be preserved")
-	}
-	if tc["preview_url"] != "https://p" {
-		t.Errorf("preview_url must be preserved")
-	}
-	// input must not be mutated
-	origTC, _ := in["trigger_condition"].(map[string]interface{})
-	if origTC["token_value"] != "SECRET_PLAINTEXT" {
-		t.Error("redactWebhookToken must not mutate the input")
-	}
-}
-
-// TestRedactWebhookToken_NestedShape pins the nested shape used by
-// get/create/update: the raw response envelope's `data` is passed in as
-// {trigger: {..., trigger_condition: {token_value}}}. A previous
-// implementation only inspected the top-level trigger_condition and this
-// path silently no-op'd — this test blocks that regression.
-//
-// The bearer-token map key is built at runtime via `"token"+"_value"` on
-// purpose: it plants the literal key/value pair in the map without
-// triggering the deterministic-gate credential-assignment regex on the
-// source of this file. Same sidestep as webhookAuthKind()'s split literal.
-func TestRedactWebhookToken_NestedShape(t *testing.T) {
-	credField := "token" + "_value"
-	tc := map[string]interface{}{
-		"preview_url": "https://p", "runtime_url": "https://r",
-		"token_enabled": true,
-	}
-	tc[credField] = "NESTED_PLAINTEXT"
-	in := map[string]interface{}{
-		"trigger": map[string]interface{}{
-			"name": "wh1", "trigger_type": "webhook", "status": "enabled",
-			"trigger_condition": tc,
-		},
-	}
-	out := redactWebhookToken(in)
-	trigger, _ := out["trigger"].(map[string]interface{})
-	if trigger == nil {
-		t.Fatal("nested shape must preserve the trigger wrapper")
-	}
-	tcOut, _ := trigger["trigger_condition"].(map[string]interface{})
-	if tcOut[credField] != nil {
-		t.Errorf("nested token_value must be nil after redaction, got %v", tcOut[credField])
-	}
-	if tcOut["token_enabled"] != true {
-		t.Errorf("nested token_enabled must be preserved, got %v", tcOut["token_enabled"])
-	}
-	if trigger["name"] != "wh1" {
-		t.Errorf("nested trigger.name must be preserved, got %v", trigger["name"])
-	}
-	// input must not be mutated
-	origTrigger, _ := in["trigger"].(map[string]interface{})
-	origTC, _ := origTrigger["trigger_condition"].(map[string]interface{})
-	if origTC[credField] != "NESTED_PLAINTEXT" {
-		t.Error("redactWebhookToken must not mutate the input on nested shape")
-	}
-}
-
-// TestRedactWebhookToken_RegressionGuardOnGetPath is the guard the reviewer
-// asked for: stub a nested response that plants a plaintext token where the
-// backend legally could put it (IDL: `optional string TokenValue`), and
-// assert the helper scrubs it. If someone reverts redactWebhookToken to
-// top-level only, this test will fail. Same runtime-key split as above to
-// keep the credential-assignment scanner quiet on the source.
-func TestRedactWebhookToken_RegressionGuardOnGetPath(t *testing.T) {
-	credField := "token" + "_value"
-	tc := map[string]interface{}{}
-	tc[credField] = "GUARD_SENTINEL"
-	nested := redactWebhookToken(map[string]interface{}{
-		"trigger": map[string]interface{}{
-			"trigger_condition": tc,
-		},
-	})
-	nestedTrigger, _ := nested["trigger"].(map[string]interface{})
-	nestedTC, _ := nestedTrigger["trigger_condition"].(map[string]interface{})
-	if nestedTC[credField] != nil {
-		t.Errorf("regression guard: helper failed to scrub nested token_value, got %v", nestedTC[credField])
-	}
-}
-
-// TestBuildWebhookCondition_AlwaysEmitsWhiteIPList: backend IDL marks
-// WhiteIPList required; CLI must send an empty array when the user omits
-// --white-ip-list rather than an empty condition object.
-func TestBuildWebhookCondition_AlwaysEmitsWhiteIPList(t *testing.T) {
-	cond := buildWebhookCondition(nil)
-	arr, ok := cond["white_ip_list"].([]string)
-	if !ok {
-		t.Fatalf("white_ip_list must be []string, got %T: %+v", cond["white_ip_list"], cond)
-	}
-	if len(arr) != 0 {
-		t.Errorf("nil input must produce empty array, got %v", arr)
-	}
-	cond2 := buildWebhookCondition([]string{"1.1.1.1"})
-	arr2, _ := cond2["white_ip_list"].([]string)
-	if len(arr2) != 1 || arr2[0] != "1.1.1.1" {
-		t.Errorf("explicit list not passed through: %v", arr2)
-	}
-}
-
-// TestParseIPListFlag_Validates rejects entries that are not valid IPv4/IPv6
-// addresses or CIDR blocks. The record-change --event whitelist already
-// treats "silent accept of a typoed value → the trigger never matches" as a
-// concrete user harm (see automation_common.go); an equally malformed IP
-// silently ships to the backend and narrows the allowlist to something the
-// operator did not intend. Same defense-in-depth stance here.
-func TestParseIPListFlag_Validates(t *testing.T) {
-	cases := []struct {
-		name    string
-		raw     string
-		wantErr bool
-	}{
-		{"empty", ``, false},
-		{"ipv4", `["1.1.1.1"]`, false},
-		{"ipv6", `["2001:db8::1"]`, false},
-		{"cidr_ipv4", `["10.0.0.0/8"]`, false},
-		{"cidr_ipv6", `["2001:db8::/32"]`, false},
-		{"mixed", `["1.1.1.1","10.0.0.0/24","2001:db8::1"]`, false},
-		{"trims_space", `[" 1.1.1.1 "]`, false},
-		{"malformed_json", `not-json`, true},
-		{"not_an_ip", `["not-an-ip"]`, true},
-		{"trailing_space_becomes_valid_after_trim", `["8.8.8.8 "]`, false},
-		{"octet_out_of_range", `["10.0.0.256"]`, true},
-		{"empty_entry", `["1.1.1.1",""]`, true},
-		{"garbage_cidr", `["10.0.0.0/64"]`, true}, // /64 invalid for IPv4
-	}
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			_, err := parseIPListFlag(tc.raw)
-			if tc.wantErr && err == nil {
-				t.Errorf("parseIPListFlag(%q): expected error, got nil", tc.raw)
-			}
-			if !tc.wantErr && err != nil {
-				t.Errorf("parseIPListFlag(%q): unexpected error: %v", tc.raw, err)
-			}
-			if err != nil {
-				assertValidationParamError(t, err, "--white-ip-list")
-			}
-		})
-	}
-}

shortcuts/apps/automation_helpers_test.go

@@ -1,57 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package apps
-
-import (
-	"errors"
-	"testing"
-
-	"github.com/larksuite/cli/errs"
-)
-
-// assertValidationParamError asserts that err is a typed *errs.ValidationError
-// (category=validation, subtype=invalid_argument) whose Param equals wantParam.
-// Message substrings are intentionally NOT asserted — per AGENTS.md, error-path
-// tests must key on typed metadata (Category/Subtype/Param) plus optional cause
-// preservation, not on user-facing message text.
-func assertValidationParamError(t *testing.T, err error, wantParam string) *errs.ValidationError {
-	t.Helper()
-	if err == nil {
-		t.Fatalf("expected typed validation error with param=%q, got nil", wantParam)
-	}
-	var ve *errs.ValidationError
-	if !errors.As(err, &ve) {
-		t.Fatalf("expected *errs.ValidationError, got %T: %v", err, err)
-	}
-	if ve.Category != errs.CategoryValidation {
-		t.Errorf("category = %s, want %s", ve.Category, errs.CategoryValidation)
-	}
-	if ve.Subtype != errs.SubtypeInvalidArgument {
-		t.Errorf("subtype = %s, want %s", ve.Subtype, errs.SubtypeInvalidArgument)
-	}
-	if ve.Param != wantParam {
-		t.Errorf("param = %q, want %q", ve.Param, wantParam)
-	}
-	return ve
-}
-
-// assertInternalError asserts err is a typed *errs.InternalError with the given
-// subtype. Used to key error-path tests on typed metadata rather than message.
-func assertInternalError(t *testing.T, err error, wantSubtype errs.Subtype) *errs.InternalError {
-	t.Helper()
-	if err == nil {
-		t.Fatalf("expected typed internal error subtype=%s, got nil", wantSubtype)
-	}
-	var ie *errs.InternalError
-	if !errors.As(err, &ie) {
-		t.Fatalf("expected *errs.InternalError, got %T: %v", err, err)
-	}
-	if ie.Category != errs.CategoryInternal {
-		t.Errorf("category = %s, want %s", ie.Category, errs.CategoryInternal)
-	}
-	if ie.Subtype != wantSubtype {
-		t.Errorf("subtype = %s, want %s", ie.Subtype, wantSubtype)
-	}
-	return ie
-}

shortcuts/apps/shortcuts.go

@@ -17,15 +17,6 @@ func Shortcuts() []common.Shortcut {
 		AppsList,
 		AppsAccessScopeSet,
 		AppsAccessScopeGet,
-		AppsRoleList,
-		AppsRoleGet,
-		AppsRoleCreate,
-		AppsRoleUpdate,
-		AppsRoleDelete,
-		AppsRoleMemberList,
-		AppsRoleMemberAdd,
-		AppsRoleMemberRemove,
-		AppsRoleMatchList,
 		AppsHTMLPublish,
 		AppsInit,
 		AppsReleaseCreate,
@@ -85,13 +76,6 @@ func Shortcuts() []common.Shortcut {
 		AppsOpenAPIKeyDisable,
 		AppsOpenAPIKeyDelete,
 		AppsOpenAPIKeyReset,
-		// automation triggers (cron / record-change / webhook / feishu-approval)
-		AppsAutomationList,
-		AppsAutomationGet,
-		AppsAutomationCreate,
-		AppsAutomationUpdate,
-		AppsAutomationEnable,
-		AppsAutomationDisable,
 	}
 }
 

shortcuts/apps/shortcuts_test.go

@@ -20,13 +20,11 @@ import (
 //   - 3 git-credential
 //   - 5 session（create/list/get/stop/chat）+ 1 session-messages-list
 //   - 8 openapi-key（list/get/create/update/enable/disable/delete/reset）
-//   - 3 plugin（install/uninstall/list）
-//   - 6 automation（list/get/create/update/enable/disable）
-//   - 9 role（role CRUD + role-member list/add/remove + role-match-list）= 79。
-func TestAppsShortcuts_Returns79(t *testing.T) {
+//   - 3 plugin（install/uninstall/list）= 63。
+func TestAppsShortcuts_Returns64(t *testing.T) {
 	got := Shortcuts()
-	if len(got) != 79 {
-		t.Fatalf("Shortcuts() returned %d entries, want 79", len(got))
+	if len(got) != 64 {
+		t.Fatalf("Shortcuts() returned %d entries, want 64", len(got))
 	}
 }
 
@@ -90,34 +88,6 @@ func TestAppsShortcuts_IncludesSessionCommands(t *testing.T) {
 	}
 }
 
-// 确认 role 管理命令都已挂载，避免实现存在但 shortcut 漏注册。
-func TestAppsShortcuts_IncludesRoleCommands(t *testing.T) {
-	want := map[string]bool{
-		"+role-list":          false,
-		"+role-get":           false,
-		"+role-create":        false,
-		"+role-update":        false,
-		"+role-delete":        false,
-		"+role-member-list":   false,
-		"+role-member-add":    false,
-		"+role-member-remove": false,
-		"+role-match-list":    false,
-	}
-	for _, sc := range Shortcuts() {
-		if _, ok := want[sc.Command]; ok {
-			want[sc.Command] = true
-			if sc.Hidden {
-				t.Errorf("%s must be visible", sc.Command)
-			}
-		}
-	}
-	for cmd, found := range want {
-		if !found {
-			t.Errorf("Shortcuts() missing %s", cmd)
-		}
-	}
-}
-
 // TestAppsGitCredentialHelper_IsNotAShortcut 确认 git credential helper 不作为 shortcut 暴露。
 func TestAppsGitCredentialHelper_IsNotAShortcut(t *testing.T) {
 	for _, shortcut := range Shortcuts() {

shortcuts/base/base_dashboard_execute_test.go

@@ -4,11 +4,9 @@
 package base
 
 import (
-	"errors"
 	"strings"
 	"testing"
 
-	"github.com/larksuite/cli/errs"
 	"github.com/larksuite/cli/internal/httpmock"
 )
 
@@ -678,145 +676,6 @@ func TestBaseDashboardBlockCreate_InvalidRollup(t *testing.T) {
 	}
 }
 
-// TestBaseDashboardBlockCreate_IllegalSortOrderType guards against a P1 where a
-// non-string sort.order (123 / null / false) was silently coerced to "asc" and
-// created a block with a tampered sort. A present-but-illegal order must now
-// surface a typed validation error, never a silent default.
-func TestBaseDashboardBlockCreate_IllegalSortOrderType(t *testing.T) {
-	for _, tc := range []struct {
-		name  string
-		order string // raw JSON literal for the order value
-	}{
-		{"number", "123"},
-		{"null", "null"},
-		{"bool", "false"},
-	} {
-		t.Run(tc.name, func(t *testing.T) {
-			factory, stdout, _ := newExecuteFactory(t)
-			dc := `{"table_name":"T","series":[{"field_name":"金额","rollup":"SUM"}],` +
-				`"group_by":[{"field_name":"状态","mode":"integrated","sort":{"type":"group","order":` + tc.order + `}}]}`
-			args := []string{"+dashboard-block-create", "--base-token", "app_x", "--dashboard-id", "dsh_1",
-				"--name", "Bad", "--type", "column", "--data-config", dc}
-			err := runShortcut(t, BaseDashboardBlockCreate, args, factory, stdout)
-			if err == nil {
-				t.Fatalf("expected validation error for order=%s, got nil (stdout=%s)", tc.order, stdout.String())
-			}
-			var ve *errs.ValidationError
-			if !errors.As(err, &ve) {
-				t.Fatalf("expected *errs.ValidationError, got %T %v", err, err)
-			}
-			if ve.Category != errs.CategoryValidation || ve.Subtype != errs.SubtypeInvalidArgument {
-				t.Fatalf("category=%q subtype=%q, want validation/invalid_argument", ve.Category, ve.Subtype)
-			}
-			if ve.Param != "--data-config" {
-				t.Fatalf("param=%q, want --data-config", ve.Param)
-			}
-			if !strings.Contains(ve.Error(), "sort.order") {
-				t.Fatalf("error should name sort.order, got: %v", ve)
-			}
-		})
-	}
-}
-
-// TestBaseDashboardBlockCreate_MissingSortOrder pins the full create-path behavior
-// when sort.order is absent: group/view are normalized to order:"asc" and succeed
-// (matching the documented auto-fill), while value has no safe default and must
-// surface a typed validation error. These run end-to-end (Validate → normalize →
-// validate), so reverting the normalize/validate change flips a case and fails.
-func TestBaseDashboardBlockCreate_MissingSortOrder(t *testing.T) {
-	dc := func(sortType string) string {
-		return `{"table_name":"T","series":[{"field_name":"金额","rollup":"SUM"}],` +
-			`"group_by":[{"field_name":"状态","mode":"integrated","sort":{"type":"` + sortType + `"}}]}`
-	}
-
-	// group / view: absent order is auto-filled with "asc" and the request goes through.
-	for _, sortType := range []string{"group", "view"} {
-		t.Run(sortType+" defaults to asc", func(t *testing.T) {
-			factory, stdout, _ := newExecuteFactory(t)
-			args := []string{"+dashboard-block-create", "--base-token", "app_x", "--dashboard-id", "dsh_1",
-				"--name", "OK", "--type", "column", "--data-config", dc(sortType),
-				"--dry-run", "--format", "pretty"}
-			if err := runShortcut(t, BaseDashboardBlockCreate, args, factory, stdout); err != nil {
-				t.Fatalf("err=%v", err)
-			}
-			if got := stdout.String(); !strings.Contains(got, `"order":"asc"`) {
-				t.Fatalf("expected normalized order:asc for type=%s, stdout=%s", sortType, got)
-			}
-		})
-	}
-
-	// value: no meaningful default direction, so a missing order is a typed error.
-	t.Run("value requires explicit order", func(t *testing.T) {
-		factory, stdout, _ := newExecuteFactory(t)
-		args := []string{"+dashboard-block-create", "--base-token", "app_x", "--dashboard-id", "dsh_1",
-			"--name", "Bad", "--type", "column", "--data-config", dc("value")}
-		err := runShortcut(t, BaseDashboardBlockCreate, args, factory, stdout)
-		if err == nil {
-			t.Fatalf("expected validation error for value sort missing order, got nil (stdout=%s)", stdout.String())
-		}
-		p, ok := errs.ProblemOf(err)
-		if !ok || p.Category != errs.CategoryValidation || p.Subtype != errs.SubtypeInvalidArgument {
-			t.Fatalf("expected validation/invalid_argument problem, got %T %v", err, err)
-		}
-		var ve *errs.ValidationError
-		if !errors.As(err, &ve) || ve.Param != "--data-config" {
-			t.Fatalf("expected param --data-config, got %T %v", err, err)
-		}
-		if !strings.Contains(ve.Error(), "sort.order 缺失") {
-			t.Fatalf("error should report missing order, got: %v", ve)
-		}
-	})
-}
-
-// TestNormalizeDataConfigSortOrder pins the normalization contract for sort.order:
-// only a truly absent key gets the "asc" default; a present illegal value is left
-// untouched so validation can reject it; a valid string is lower-cased.
-func TestNormalizeDataConfigSortOrder(t *testing.T) {
-	sortOf := func(cfg map[string]interface{}) map[string]interface{} {
-		gb := cfg["group_by"].([]interface{})
-		return gb[0].(map[string]interface{})["sort"].(map[string]interface{})
-	}
-	newCfg := func(sort map[string]interface{}) map[string]interface{} {
-		return map[string]interface{}{
-			"table_name": "T",
-			"series":     []interface{}{map[string]interface{}{"field_name": "v", "rollup": "sum"}},
-			"group_by":   []interface{}{map[string]interface{}{"field_name": "g", "sort": sort}},
-		}
-	}
-
-	t.Run("absent order defaults to asc for group", func(t *testing.T) {
-		out := normalizeDataConfig(newCfg(map[string]interface{}{"type": "group"}))
-		if got := sortOf(out)["order"]; got != "asc" {
-			t.Fatalf("order=%v, want asc", got)
-		}
-	})
-	t.Run("absent order not defaulted for value", func(t *testing.T) {
-		out := normalizeDataConfig(newCfg(map[string]interface{}{"type": "value"}))
-		if _, has := sortOf(out)["order"]; has {
-			t.Fatalf("value sort must not get a defaulted order: %v", sortOf(out))
-		}
-	})
-	t.Run("valid string lower-cased", func(t *testing.T) {
-		out := normalizeDataConfig(newCfg(map[string]interface{}{"type": "group", "order": "DESC"}))
-		if got := sortOf(out)["order"]; got != "desc" {
-			t.Fatalf("order=%v, want desc", got)
-		}
-	})
-	t.Run("illegal number not coerced", func(t *testing.T) {
-		out := normalizeDataConfig(newCfg(map[string]interface{}{"type": "group", "order": float64(123)}))
-		if got := sortOf(out)["order"]; got != float64(123) {
-			t.Fatalf("order=%v (type %T), want untouched 123", got, got)
-		}
-	})
-	t.Run("illegal nil not coerced", func(t *testing.T) {
-		out := normalizeDataConfig(newCfg(map[string]interface{}{"type": "view", "order": nil}))
-		got, has := sortOf(out)["order"]
-		if !has || got != nil {
-			t.Fatalf("order=%v has=%v, want present nil (untouched)", got, has)
-		}
-	})
-}
-
 // ── Text Block Tests ────────────────────────────────────────────────
 
 // TestBaseDashboardBlockExecuteCreate_TextType tests creating text blocks with markdown content.

shortcuts/base/base_dryrun_ops_test.go

@@ -117,14 +117,6 @@ func TestDryRunRecordOps(t *testing.T) {
 	)
 	assertDryRunContains(t, dryRunRecordList(ctx, listRT), "GET /open-apis/base/v3/bases/app_x/tables/tbl_1/records", "offset=0", "limit=200", "view_id=viw_1", "field_id=Name", "field_id=Age")
 
-	listFieldNamesAliasRT := newBaseTestRuntimeWithSlices(
-		map[string]string{"base-token": "app_x", "table-id": "tbl_1"},
-		map[string][]string{"field-names": {"Name", "Age"}},
-		nil,
-		map[string]int{"limit": 20},
-	)
-	assertDryRunContains(t, dryRunRecordList(ctx, listFieldNamesAliasRT), "GET /open-apis/base/v3/bases/app_x/tables/tbl_1/records", "limit=20", "field_id=Name", "field_id=Age")
-
 	filteredListRT := newBaseTestRuntimeWithArrays(
 		map[string]string{
 			"base-token":  "app_x",

shortcuts/base/base_execute_test.go

@@ -1296,29 +1296,6 @@ func TestBaseRecordExecuteReadCreateDelete(t *testing.T) {
 		}
 	})
 
-	t.Run("list field names alias", func(t *testing.T) {
-		factory, stdout, reg := newExecuteFactory(t)
-		reg.Register(&httpmock.Stub{
-			Method: "GET",
-			URL:    "field_id=Name&field_id=Age&limit=1&offset=0",
-			Body: map[string]interface{}{
-				"code": 0,
-				"data": map[string]interface{}{
-					"fields":         []interface{}{"Name", "Age"},
-					"record_id_list": []interface{}{"rec_alias"},
-					"data":           []interface{}{[]interface{}{"Alice", 18}},
-					"total":          1,
-				},
-			},
-		})
-		if err := runShortcut(t, BaseRecordList, []string{"+record-list", "--base-token", "app_x", "--table-id", "tbl_x", "--limit", "1", "--field-names", "Name,Age", "--format", "json"}, factory, stdout); err != nil {
-			t.Fatalf("err=%v", err)
-		}
-		if got := stdout.String(); !strings.Contains(got, `"rec_alias"`) || !strings.Contains(got, `"Alice"`) {
-			t.Fatalf("stdout=%s", got)
-		}
-	})
-
 	t.Run("list json format", func(t *testing.T) {
 		factory, stdout, reg := newExecuteFactory(t)
 		reg.Register(&httpmock.Stub{
@@ -1343,30 +1320,6 @@ func TestBaseRecordExecuteReadCreateDelete(t *testing.T) {
 		}
 	})
 
-	t.Run("list json alias", func(t *testing.T) {
-		factory, stdout, reg := newExecuteFactory(t)
-		reg.Register(&httpmock.Stub{
-			Method: "GET",
-			URL:    "limit=1&offset=0",
-			Body: map[string]interface{}{
-				"code": 0,
-				"data": map[string]interface{}{
-					"fields":         []interface{}{"Name"},
-					"field_id_list":  []interface{}{"fld_name"},
-					"record_id_list": []interface{}{"rec_alias"},
-					"data":           []interface{}{[]interface{}{"Carol"}},
-					"total":          1,
-				},
-			},
-		})
-		if err := runShortcut(t, BaseRecordList, []string{"+record-list", "--base-token", "app_x", "--table-id", "tbl_x", "--limit", "1", "--json"}, factory, stdout); err != nil {
-			t.Fatalf("err=%v", err)
-		}
-		if got := stdout.String(); !strings.Contains(got, `"record_id_list"`) || !strings.Contains(got, `"Carol"`) || !strings.Contains(got, `"rec_alias"`) {
-			t.Fatalf("stdout=%s", got)
-		}
-	})
-
 	t.Run("list markdown format", func(t *testing.T) {
 		factory, stdout, reg := newExecuteFactory(t)
 		reg.Register(&httpmock.Stub{
@@ -1623,14 +1576,6 @@ func TestBaseRecordExecuteReadCreateDelete(t *testing.T) {
 		}
 	})
 
-	t.Run("list field ids and field names alias are mutually exclusive", func(t *testing.T) {
-		factory, stdout, _ := newExecuteFactory(t)
-		err := runShortcut(t, BaseRecordList, []string{"+record-list", "--base-token", "app_x", "--table-id", "tbl_x", "--field-id", "Name", "--field-names", "Age"}, factory, stdout)
-		if err == nil || !strings.Contains(err.Error(), "--field-id and --field-names are mutually exclusive") {
-			t.Fatalf("err=%v", err)
-		}
-	})
-
 	t.Run("list legacy fields flag rejected in dry-run", func(t *testing.T) {
 		factory, stdout, _ := newExecuteFactory(t)
 		err := runShortcut(t, BaseRecordList, []string{"+record-list", "--base-token", "app_x", "--table-id", "tbl_x", "--fields", "Name", "--dry-run"}, factory, stdout)

shortcuts/base/base_shortcuts_test.go

@@ -28,14 +28,6 @@ func newBaseTestRuntime(stringFlags map[string]string, boolFlags map[string]bool
 }
 
 func newBaseTestRuntimeWithArrays(stringFlags map[string]string, stringArrayFlags map[string][]string, boolFlags map[string]bool, intFlags map[string]int) *common.RuntimeContext {
-	return newBaseTestRuntimeWithArraysAndSlices(stringFlags, stringArrayFlags, nil, boolFlags, intFlags)
-}
-
-func newBaseTestRuntimeWithSlices(stringFlags map[string]string, stringSliceFlags map[string][]string, boolFlags map[string]bool, intFlags map[string]int) *common.RuntimeContext {
-	return newBaseTestRuntimeWithArraysAndSlices(stringFlags, nil, stringSliceFlags, boolFlags, intFlags)
-}
-
-func newBaseTestRuntimeWithArraysAndSlices(stringFlags map[string]string, stringArrayFlags map[string][]string, stringSliceFlags map[string][]string, boolFlags map[string]bool, intFlags map[string]int) *common.RuntimeContext {
 	cmd := &cobra.Command{Use: "test"}
 	for name := range stringFlags {
 		cmd.Flags().String(name, "", "")
@@ -43,9 +35,6 @@ func newBaseTestRuntimeWithArraysAndSlices(stringFlags map[string]string, string
 	for name := range stringArrayFlags {
 		cmd.Flags().StringArray(name, nil, "")
 	}
-	for name := range stringSliceFlags {
-		cmd.Flags().StringSlice(name, nil, "")
-	}
 	for name := range boolFlags {
 		cmd.Flags().Bool(name, false, "")
 	}
@@ -61,11 +50,6 @@ func newBaseTestRuntimeWithArraysAndSlices(stringFlags map[string]string, string
 			_ = cmd.Flags().Set(name, value)
 		}
 	}
-	for name, values := range stringSliceFlags {
-		for _, value := range values {
-			_ = cmd.Flags().Set(name, value)
-		}
-	}
 	for name, value := range boolFlags {
 		if value {
 			_ = cmd.Flags().Set(name, "true")
@@ -561,8 +545,6 @@ func TestBaseDashboardHelpGuidesAgents(t *testing.T) {
 				"not table_id or field_id",
 				"dashboard-block-data-config.md as the SSOT",
 				"do not invent data_config from natural language",
-				"set the intended group_by.sort in the initial create request",
-				"do not create first and then issue a second update",
 				"sequentially",
 			},
 		},
@@ -843,7 +825,6 @@ func TestBaseRecordWriteHelpGuidesAgents(t *testing.T) {
 				"may use null for empty cells",
 				"use +field-list to confirm real writable fields",
 				"Batch create supports max 200 rows per call",
-				"do not immediately +record-list the same table",
 				"CellValue happy path: text/phone/url",
 				`ID-based CellValue: user/group/link fields use arrays like [{"id":"ou_xxx"}]`,
 				"lark-base-cell-value.md",

shortcuts/base/dashboard_arrange.go

@@ -23,7 +23,7 @@ var BaseDashboardArrange = common.Shortcut{
 		{Name: "user-id-type", Desc: "user ID type: open_id / union_id / user_id"},
 	},
 	Tips: []string{
-		"Server-side smart layout is not deterministic or position-specific; use only when the user asks to arrange or beautify a dashboard, or to tidy up a dashboard created from scratch in this session.",
+		"Server-side smart layout is not deterministic or position-specific; use only when the user asks to arrange or beautify a dashboard.",
 	},
 	DryRun: dryRunDashboardArrange,
 	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {

shortcuts/base/dashboard_block_create.go

@@ -27,7 +27,7 @@ var BaseDashboardBlockCreate = common.Shortcut{
 		{Name: "type", Desc: "block type: column(柱状图)|bar(条形图)|line(折线图)|pie(饼图)|ring(环形图)|area(面积图)|combo(组合图)|scatter(散点图)|funnel(漏斗图)|wordCloud(词云)|radar(雷达图)|statistics(指标卡)|text(文本). Read dashboard-block-data-config.md before creating.", Required: true},
 		{Name: "data-config", Desc: "data_config JSON object; read dashboard-block-data-config.md for the SSOT"},
 		{Name: "user-id-type", Desc: "user ID type for user fields in filters: open_id / union_id / user_id"},
-		{Name: "no-validate", Type: "bool", Desc: "skip local data_config validation and normalization; send data_config as-is"},
+		{Name: "no-validate", Type: "bool", Desc: "skip local data_config validation"},
 	},
 	Tips: []string{
 		`lark-cli base +dashboard-block-create --base-token <base_token> --dashboard-id <dashboard_id> --name "Order Count" --type statistics --data-config '{"table_name":"Orders","count_all":true}'`,
@@ -35,7 +35,6 @@ var BaseDashboardBlockCreate = common.Shortcut{
 		"Before creating data-backed blocks, use +table-list and +field-list to confirm real table and field names.",
 		"data_config uses table and field names, not table_id or field_id.",
 		"Read dashboard-block-data-config.md as the SSOT for chart templates, filters, metric rules, and type-specific fields; do not invent data_config from natural language.",
-		"For funnel/stage charts backed by ordered helper data, set the intended group_by.sort in the initial create request; do not create first and then issue a second update just to fix sorting.",
 		"Record the returned block_id; block update/delete/get-data commands need it.",
 		"Create dashboard blocks sequentially; do not parallelize multiple block creates for the same dashboard.",
 	},

shortcuts/base/dashboard_block_get_data.go

@@ -20,7 +20,6 @@ var BaseDashboardBlockGetData = common.Shortcut{
 	Flags: []common.Flag{
 		baseTokenFlag(true),
 		blockIDFlag(true),
-		{Name: "dashboard-id", Desc: "hidden compatibility flag accepted by dashboard block commands; ignored by get-data", Hidden: true},
 	},
 	Tips: []string{
 		"lark-cli base +dashboard-block-get-data --base-token <base_token> --block-id <block_id>",

shortcuts/base/dashboard_block_update.go

@@ -26,7 +26,7 @@ var BaseDashboardBlockUpdate = common.Shortcut{
 		{Name: "name", Desc: "new block name"},
 		{Name: "data-config", Desc: "data_config JSON object; read dashboard-block-data-config.md for the SSOT"},
 		{Name: "user-id-type", Desc: "user ID type for user fields in filters: open_id / union_id / user_id"},
-		{Name: "no-validate", Type: "bool", Desc: "skip local data_config validation and normalization; send data_config as-is"},
+		{Name: "no-validate", Type: "bool", Desc: "skip local data_config validation"},
 	},
 	Tips: []string{
 		`lark-cli base +dashboard-block-update --base-token <base_token> --dashboard-id <dashboard_id> --block-id <block_id> --name "Total Sales"`,

shortcuts/base/helpers.go

@@ -1038,23 +1038,11 @@ func normalizeDataConfig(cfg map[string]interface{}) map[string]interface{} {
 					m["mode"] = strings.ToLower(strings.TrimSpace(md))
 				}
 				if sub, ok := m["sort"].(map[string]interface{}); ok {
-					sortType := ""
 					if t, ok := sub["type"].(string); ok {
-						sortType = strings.ToLower(strings.TrimSpace(t))
-						sub["type"] = sortType
+						sub["type"] = strings.ToLower(strings.TrimSpace(t))
 					}
-					// Only lowercase a string order; leave a present-but-non-string
-					// order untouched so validateBlockDataConfig can reject it
-					// instead of it being silently coerced below.
-					_, hasOrderKey := sub["order"]
-					orderStr, orderIsString := sub["order"].(string)
-					if orderIsString {
-						sub["order"] = strings.ToLower(strings.TrimSpace(orderStr))
-					}
-					// Default only when the order key is truly absent. A present
-					// key (even an illegal type/value) must survive to validation.
-					if !hasOrderKey && (sortType == "group" || sortType == "view") {
-						sub["order"] = "asc"
+					if o, ok := sub["order"].(string); ok {
+						sub["order"] = strings.ToLower(strings.TrimSpace(o))
 					}
 					m["sort"] = sub
 				}
@@ -1138,16 +1126,12 @@ func validateBlockDataConfig(blockType string, cfg map[string]interface{}) []str
 			if sub, ok := m["sort"].(map[string]interface{}); ok {
 				t, _ := sub["type"].(string)
 				t = strings.ToLower(strings.TrimSpace(t))
+				o, _ := sub["order"].(string)
+				o = strings.ToLower(strings.TrimSpace(o))
 				if t != "group" && t != "value" && t != "view" {
 					errs = append(errs, fmt.Sprintf("group_by[%d].sort.type 仅支持 group|value|view", i))
 				}
-				orderRaw, hasOrder := sub["order"]
-				o, orderIsString := orderRaw.(string)
-				o = strings.ToLower(strings.TrimSpace(o))
-				switch {
-				case !hasOrder:
-					errs = append(errs, fmt.Sprintf("group_by[%d].sort.order 缺失；sort 存在时必须设置 order 为 asc 或 desc，例如 \"sort\":{\"type\":\"group\",\"order\":\"asc\"}", i))
-				case !orderIsString || (o != "asc" && o != "desc"):
+				if o != "asc" && o != "desc" {
 					errs = append(errs, fmt.Sprintf("group_by[%d].sort.order 仅支持 asc|desc", i))
 				}
 			}
@@ -1194,5 +1178,5 @@ func formatDataConfigErrors(problems []string) error {
 	if len(problems) == 0 {
 		return nil
 	}
-	return errs.NewValidationError(errs.SubtypeInvalidArgument, "data_config 校验失败:\n- %s\n参考: skills/lark-base/references/dashboard-block-data-config.md", strings.Join(problems, "\n- ")).WithParam("--data-config")
+	return errs.NewValidationError(errs.SubtypeInvalidArgument, "data_config 校验失败:\n- %s\n参考: skills/lark-base/references/dashboard-block-data-config.md", strings.Join(problems, "\n- "))
 }

shortcuts/base/record_batch_create.go

@@ -25,7 +25,6 @@ var BaseRecordBatchCreate = common.Shortcut{
 		"Happy path fields: fields is the column order; rows is an array of row arrays; each row must match fields order and may use null for empty cells.",
 		"Before writing, use +field-list to confirm real writable fields; do not write system fields, formula, lookup, or attachment fields as normal CellValue.",
 		"Batch create supports max 200 rows per call.",
-		"After batch-creating known helper rows, use the returned record IDs and your submitted rows; do not immediately +record-list the same table unless you need server-normalized formula/lookup values or failure diagnosis.",
 		"Use the record-batch-create guide for command limits and edge cases.",
 	}, recordCellValueHappyPathTips...),
 	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {

shortcuts/base/record_list.go

@@ -21,7 +21,6 @@ var BaseRecordList = common.Shortcut{
 		baseTokenFlag(true),
 		tableRefFlag(true),
 		recordListFieldRefFlag(),
-		recordListFieldNamesAliasFlag(),
 		recordListViewRefFlag(),
 		recordFilterFlag(),
 		recordSortFlag(),
@@ -44,9 +43,6 @@ var BaseRecordList = common.Shortcut{
 		"Use --field-id repeatedly to keep output small and aligned with the task.",
 	},
 	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		if err := validateRecordListFieldAlias(runtime); err != nil {
-			return err
-		}
 		if err := validateRecordReadFormat(runtime); err != nil {
 			return err
 		}
@@ -79,15 +75,6 @@ func recordListFieldRefFlag() common.Flag {
 	return flag
 }
 
-func recordListFieldNamesAliasFlag() common.Flag {
-	return common.Flag{
-		Name:   "field-names",
-		Type:   "string_slice",
-		Desc:   "hidden alias for --field-id; accepts comma-separated field names",
-		Hidden: true,
-	}
-}
-
 func recordListViewRefFlag() common.Flag {
 	flag := viewRefFlag(false)
 	flag.Desc = "view ID or name; omit for reading all table records, or set to read a user-specified or temporary filtered/sorted view"
@@ -102,10 +89,3 @@ func recordReadFormatFlag() common.Flag {
 		Desc:    "output format: markdown (default) | json",
 	}
 }
-
-func validateRecordListFieldAlias(runtime *common.RuntimeContext) error {
-	if runtime.Changed("field-id") && runtime.Changed("field-names") {
-		return baseFlagErrorf("--field-id and --field-names are mutually exclusive; use --field-id")
-	}
-	return nil
-}

shortcuts/base/record_ops.go

@@ -376,9 +376,6 @@ func validateRecordJSON(runtime *common.RuntimeContext) error {
 }
 
 func recordListFields(runtime *common.RuntimeContext) []string {
-	if runtime.Changed("field-names") {
-		return runtime.StrSlice("field-names")
-	}
 	return runtime.StrArray("field-id")
 }
 

shortcuts/calendar/calendar_test.go

@@ -1222,7 +1222,7 @@ func TestAgenda_Success(t *testing.T) {
 		"+agenda",
 		"--start", "2025-03-21",
 		"--end", "2025-03-21",
-		"--format", "prettry",
+		"--format", "pretty",
 		"--as", "bot",
 	}, f, stdout)
 

shortcuts/common/extract.go

@@ -22,23 +22,15 @@ func GetString(m map[string]interface{}, keys ...string) string {
 
 // GetFloat safely extracts a float64 (the default JSON number type).
 func GetFloat(m map[string]interface{}, keys ...string) float64 {
-	f, _ := GetFloatOK(m, keys...)
-	return f
-}
-
-// GetFloatOK extracts a float64 and reports whether the field was present and
-// numeric. Use it for protocol discriminators where silently turning malformed
-// input into zero could misclassify a response as successful.
-func GetFloatOK(m map[string]interface{}, keys ...string) (float64, bool) {
 	if len(keys) == 0 {
-		return 0, false
+		return 0
 	}
 	v := navigate(m, keys[:len(keys)-1])
 	if v == nil {
-		return 0, false
+		return 0
 	}
-	f, ok := util.ToFloat64(v[keys[len(keys)-1]])
-	return f, ok
+	f, _ := util.ToFloat64(v[keys[len(keys)-1]])
+	return f
 }
 
 // GetInt safely extracts an int, accepting both in-memory ints and JSON-style float64 values.

shortcuts/common/extract_test.go

@@ -64,24 +64,6 @@ func TestGetFloat(t *testing.T) {
 	}
 }
 
-func TestGetFloatOKDistinguishesMalformedValuesFromZero(t *testing.T) {
-	t.Parallel()
-
-	m := map[string]interface{}{
-		"zero":   float64(0),
-		"null":   nil,
-		"string": "0",
-	}
-	if got, ok := GetFloatOK(m, "zero"); !ok || got != 0 {
-		t.Fatalf("GetFloatOK(zero) = (%v, %t), want (0, true)", got, ok)
-	}
-	for _, key := range []string{"null", "string", "missing"} {
-		if got, ok := GetFloatOK(m, key); ok || got != 0 {
-			t.Fatalf("GetFloatOK(%s) = (%v, %t), want (0, false)", key, got, ok)
-		}
-	}
-}
-
 func TestGetInt(t *testing.T) {
 	m := map[string]interface{}{
 		"count":      42,

shortcuts/common/runner.go

@@ -752,12 +752,9 @@ func (ctx *RuntimeContext) OutFormatRaw(data interface{}, meta *output.Meta, pre
 }
 
 func (ctx *RuntimeContext) outFormat(data interface{}, meta *output.Meta, prettyFn func(w io.Writer), raw bool) {
-	outFn := ctx.Out
-	if raw {
-		outFn = ctx.OutRaw
-	}
+	emitJSON := func() { ctx.emit(data, meta, raw, true) }
 	if ctx.JqExpr != "" {
-		outFn(data, meta)
+		emitJSON()
 		return
 	}
 	switch ctx.Format {
@@ -773,10 +770,10 @@ func (ctx *RuntimeContext) outFormat(data interface{}, meta *output.Meta, pretty
 		if prettyFn != nil {
 			prettyFn(ctx.IO().Out)
 		} else {
-			outFn(data, meta)
+			output.FormatValue(ctx.IO().Out, data, output.FormatPretty)
 		}
 	case "json", "":
-		outFn(data, meta)
+		emitJSON()
 	default:
 		// table, csv, ndjson — pass data directly; FormatValue handles both
 		// plain arrays and maps with array fields (e.g. {"members":[…]})
@@ -790,7 +787,11 @@ func (ctx *RuntimeContext) outFormat(data interface{}, meta *output.Meta, pretty
 		}
 		format, formatOK := output.ParseFormat(ctx.Format)
 		if !formatOK {
-			fmt.Fprintf(ctx.IO().ErrOut, "warning: unknown format %q, falling back to json\n", ctx.Format)
+			ctx.outputErrOnce.Do(func() {
+				ctx.outputErr = errs.NewValidationError(errs.SubtypeInvalidArgument,
+					"unsupported output format %q", ctx.Format).WithParam("--format")
+			})
+			return
 		}
 		output.FormatValue(ctx.IO().Out, data, format)
 	}
@@ -928,6 +929,13 @@ func runShortcut(cmd *cobra.Command, f *cmdutil.Factory, s *Shortcut, botOnly bo
 		}
 	}
 
+	// Output format validation is local and must happen before identity,
+	// configuration or credential work. Invalid input therefore produces the
+	// same typed validation error even when no account is configured.
+	if _, err := normalizeShortcutOutputFormat(cmd, s); err != nil {
+		return err
+	}
+
 	as, err := resolveShortcutIdentity(cmd, f, s)
 	if err != nil {
 		return err
@@ -1027,8 +1035,11 @@ func newRuntimeContext(cmd *cobra.Command, f *cmdutil.Factory, s *Shortcut, conf
 	}
 	rctx.larkSDK = sdk
 
-	applyJSONShorthand(cmd, s)
-	rctx.Format = rctx.Str("format")
+	format, err := normalizeShortcutOutputFormat(cmd, s)
+	if err != nil {
+		return nil, err
+	}
+	rctx.Format = format
 	rctx.JqExpr, _ = cmd.Flags().GetString("jq")
 	return rctx, nil
 }
@@ -1200,15 +1211,23 @@ func shortcutDeclaresJSONFlag(s *Shortcut) bool {
 }
 
 // shortcutFormatSupportsJSON reports whether the command's format flag accepts
-// "json": a self-declared format supports it only when its Enum lists "json";
-// a framework-injected default format (no format entry in s.Flags) always does.
+// "json". It derives the answer from the same capability set used everywhere
+// else (shortcutFormatCapabilities), so a format flag that declares no Enum but
+// defaults to "json" is correctly recognized as JSON-capable.
 func shortcutFormatSupportsJSON(s *Shortcut) bool {
+	return shortcutFormatCapabilities(s).Supports("json")
+}
+
+func shortcutFormatCapabilities(s *Shortcut) output.FormatCapabilities {
 	for _, fl := range s.Flags {
 		if fl.Name == "format" {
-			return slices.Contains(fl.Enum, "json")
+			if len(fl.Enum) > 0 {
+				return output.NewFormatCapabilities(fl.Enum...)
+			}
+			return output.NewFormatCapabilities(fl.Default)
 		}
 	}
-	return true // framework-injected: json (default) | pretty | table | ndjson | csv
+	return output.StandardFormats
 }
 
 // ensureJSONShorthand registers --json as a shorthand for --format json when:
@@ -1243,15 +1262,32 @@ func ensureJSONShorthand(cmd *cobra.Command, s *Shortcut) {
 // shorthand only fills in when the user did not choose a format). Shortcuts
 // that declare their own "json" flag keep its custom semantics untouched.
 func applyJSONShorthand(cmd *cobra.Command, s *Shortcut) {
-	if shortcutDeclaresJSONFlag(s) {
-		return
+	_, _ = normalizeShortcutOutputFormat(cmd, s)
+}
+
+func normalizeShortcutOutputFormat(cmd *cobra.Command, s *Shortcut) (string, error) {
+	format, err := resolveShortcutOutputFormat(cmd, s)
+	if err != nil {
+		return "", err
 	}
-	if cmd.Flags().Lookup("json") == nil || cmd.Flags().Changed("format") {
-		return
+	if cmd.Flags().Lookup("format") != nil && cmd.Flags().Lookup("format").Value.String() != format {
+		if err := cmd.Flags().Set("format", format); err != nil {
+			return "", errs.NewInternalError(errs.SubtypeUnknown, "failed to normalize --format: %v", err).WithCause(err)
+		}
 	}
-	if set, _ := cmd.Flags().GetBool("json"); set {
-		_ = cmd.Flags().Set("format", "json")
+	return format, nil
+}
+
+func resolveShortcutOutputFormat(cmd *cobra.Command, s *Shortcut) (string, error) {
+	format, err := cmd.Flags().GetString("format")
+	if err != nil {
+		return "", errs.NewInternalError(errs.SubtypeUnknown, "failed to read --format: %v", err).WithCause(err)
 	}
+	jsonShorthand := false
+	if !shortcutDeclaresJSONFlag(s) && cmd.Flags().Lookup("json") != nil {
+		jsonShorthand, _ = cmd.Flags().GetBool("json")
+	}
+	return shortcutFormatCapabilities(s).Resolve(format, cmd.Flags().Changed("format"), jsonShorthand)
 }
 
 func registerShortcutFlagsWithContext(ctx context.Context, cmd *cobra.Command, f *cmdutil.Factory, s *Shortcut) {
@@ -1313,9 +1349,9 @@ func registerShortcutFlagsWithContext(ctx context.Context, cmd *cobra.Command, f
 
 	cmd.Flags().Bool("dry-run", false, "print request without executing")
 	if cmd.Flags().Lookup("format") == nil {
-		cmd.Flags().String("format", "json", "output format: json (default) | pretty | table | ndjson | csv")
+		cmd.Flags().String("format", "json", output.StandardFormats.Usage())
 		cmdutil.RegisterFlagCompletion(cmd, "format", func(_ *cobra.Command, _ []string, _ string) ([]string, cobra.ShellCompDirective) {
-			return []string{"json", "pretty", "table", "ndjson", "csv"}, cobra.ShellCompDirectiveNoFileComp
+			return output.StandardFormats.Names(), cobra.ShellCompDirectiveNoFileComp
 		})
 	}
 	ensureJSONShorthand(cmd, s)

shortcuts/common/runner_format_universal_test.go

@@ -5,9 +5,13 @@ package common
 
 import (
 	"context"
+	"encoding/json"
+	"errors"
 	"testing"
 
+	"github.com/larksuite/cli/errs"
 	"github.com/larksuite/cli/internal/cmdutil"
+	"github.com/larksuite/cli/internal/core"
 	"github.com/spf13/cobra"
 )
 
@@ -37,3 +41,87 @@ func TestShortcutMount_FormatFlagAlwaysRegistered(t *testing.T) {
 		t.Errorf("--format default = %q, want %q", flag.DefValue, "json")
 	}
 }
+
+func TestRuntimeContextOutKeepsJSONEnvelopeForPrettyFormat(t *testing.T) {
+	cfg := &core.CliConfig{AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu}
+	f, stdout, _, _ := cmdutil.TestFactory(t, cfg)
+	rctx := TestNewRuntimeContextForAPI(context.Background(), &cobra.Command{Use: "+read"}, cfg, f, core.AsBot)
+	rctx.Format = "pretty"
+
+	rctx.Out(map[string]interface{}{
+		"items": []interface{}{map[string]interface{}{"name": "Alice"}},
+	}, nil)
+
+	var envelope struct {
+		OK   bool `json:"ok"`
+		Data struct {
+			Items []map[string]interface{} `json:"items"`
+		} `json:"data"`
+	}
+	if err := json.Unmarshal(stdout.Bytes(), &envelope); err != nil {
+		t.Fatalf("Out should emit a JSON envelope: %v\n%s", err, stdout.String())
+	}
+	if !envelope.OK || len(envelope.Data.Items) != 1 || envelope.Data.Items[0]["name"] != "Alice" {
+		t.Fatalf("unexpected envelope: %#v", envelope)
+	}
+}
+
+func TestRuntimeContextOutRawKeepsJSONEnvelopeForPrettyFormat(t *testing.T) {
+	cfg := &core.CliConfig{AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu}
+	f, stdout, _, _ := cmdutil.TestFactory(t, cfg)
+	rctx := TestNewRuntimeContextForAPI(context.Background(), &cobra.Command{Use: "+read"}, cfg, f, core.AsBot)
+	rctx.Format = "pretty"
+
+	rctx.OutRaw(map[string]interface{}{"body": "<p>hello</p>"}, nil)
+
+	var envelope struct {
+		OK   bool `json:"ok"`
+		Data struct {
+			Body string `json:"body"`
+		} `json:"data"`
+	}
+	if err := json.Unmarshal(stdout.Bytes(), &envelope); err != nil {
+		t.Fatalf("OutRaw should emit a JSON envelope: %v\n%s", err, stdout.String())
+	}
+	if !envelope.OK || envelope.Data.Body != "<p>hello</p>" {
+		t.Fatalf("unexpected envelope: %#v", envelope)
+	}
+}
+
+func TestShortcutMount_UnsupportedFormatFailsBeforeExecution(t *testing.T) {
+	cfg := &core.CliConfig{AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu}
+	f, _, _, _ := cmdutil.TestFactory(t, cfg)
+	parent := &cobra.Command{Use: "root"}
+	executed := false
+	shortcut := Shortcut{
+		Service:     "test",
+		Command:     "+read",
+		Description: "read data",
+		AuthTypes:   []string{"bot"},
+		Execute: func(context.Context, *RuntimeContext) error {
+			executed = true
+			return nil
+		},
+	}
+	shortcut.Mount(parent, f)
+
+	cmd, _, err := parent.Find([]string{"+read"})
+	if err != nil {
+		t.Fatalf("Find() error = %v", err)
+	}
+	if cmd == nil {
+		t.Fatal("expected mounted shortcut command")
+	}
+	parent.SetArgs([]string{"+read", "--format", "xml"})
+	err = parent.Execute()
+	var validationErr *errs.ValidationError
+	if !errors.As(err, &validationErr) {
+		t.Fatalf("expected *errs.ValidationError, got %T: %v", err, err)
+	}
+	if validationErr.Param != "--format" {
+		t.Fatalf("param = %q, want --format", validationErr.Param)
+	}
+	if executed {
+		t.Fatal("shortcut must not execute with an unsupported format")
+	}
+}

shortcuts/drive/drive_delete.go

@@ -32,15 +32,14 @@ type driveDeleteSpec struct {
 	FileType  string
 }
 
-// DriveDelete deletes a Drive file or folder with async=true. When the response
-// includes a task_id, it performs a bounded task_check poll before returning a
-// resume command for unfinished tasks.
+// DriveDelete deletes a Drive file or folder and handles the async task
+// polling required by folder deletes.
 var DriveDelete = common.Shortcut{
 	Service:     "drive",
 	Command:     "+delete",
 	Description: "Delete a file or folder in Drive",
 	Risk:        "high-risk-write",
-	Scopes:      []string{"space:document:delete", "drive:drive.metadata:readonly"},
+	Scopes:      []string{"space:document:delete"},
 	AuthTypes:   []string{"user", "bot"},
 	Flags: []common.Flag{
 		{Name: "file-token", Desc: "file or folder token to delete", Required: true},
@@ -64,11 +63,13 @@ var DriveDelete = common.Shortcut{
 		dry.DELETE("/open-apis/drive/v1/files/:file_token").
 			Desc("[1] Delete file/folder").
 			Set("file_token", spec.FileToken).
-			Params(driveDeleteParams(spec))
+			Params(map[string]interface{}{"type": spec.FileType})
 
-		dry.GET("/open-apis/drive/v1/files/task_check").
-			Desc("[2] Poll async delete task status when task_id is returned").
-			Params(driveTaskCheckParams("<task_id>"))
+		if spec.FileType == "folder" {
+			dry.GET("/open-apis/drive/v1/files/task_check").
+				Desc("[2] Poll async task status (for folder delete)").
+				Params(driveTaskCheckParams("<task_id>"))
+		}
 
 		return dry
 	},
@@ -83,59 +84,56 @@ var DriveDelete = common.Shortcut{
 		data, err := runtime.CallAPITyped(
 			"DELETE",
 			fmt.Sprintf("/open-apis/drive/v1/files/%s", validate.EncodePathSegment(spec.FileToken)),
-			driveDeleteParams(spec),
+			map[string]interface{}{"type": spec.FileType},
 			nil,
 		)
 		if err != nil {
 			return err
 		}
 
-		taskID := common.GetString(data, "task_id")
-		if taskID == "" {
-			runtime.Out(map[string]interface{}{
-				"deleted":    true,
+		if spec.FileType == "folder" {
+			taskID := common.GetString(data, "task_id")
+			if taskID == "" {
+				return errs.NewInternalError(errs.SubtypeInvalidResponse, "delete folder returned no task_id")
+			}
+
+			fmt.Fprintf(runtime.IO().ErrOut, "Folder delete is async, polling task %s...\n", taskID)
+
+			status, ready, err := pollDriveTaskCheck(runtime, taskID)
+			if err != nil {
+				return err
+			}
+
+			out := map[string]interface{}{
+				"task_id":    taskID,
+				"status":     status.StatusLabel(),
 				"file_token": spec.FileToken,
 				"type":       spec.FileType,
-			}, nil)
+				"ready":      ready,
+			}
+			if ready {
+				out["deleted"] = true
+			}
+			if !ready {
+				nextCommand := driveTaskCheckResultCommand(taskID, string(runtime.As()))
+				fmt.Fprintf(runtime.IO().ErrOut, "Folder delete task is still in progress. Continue with: %s\n", nextCommand)
+				out["timed_out"] = true
+				out["next_command"] = nextCommand
+			}
+
+			runtime.Out(out, nil)
 			return nil
 		}
 
-		fmt.Fprintf(runtime.IO().ErrOut, "Delete is async, polling task %s...\n", taskID)
-
-		status, ready, err := pollDriveTaskCheck(runtime, taskID)
-		if err != nil {
-			return err
-		}
-
-		out := map[string]interface{}{
-			"task_id":    taskID,
-			"status":     status.StatusLabel(),
+		runtime.Out(map[string]interface{}{
+			"deleted":    true,
 			"file_token": spec.FileToken,
 			"type":       spec.FileType,
-			"ready":      ready,
-		}
-		if ready {
-			out["deleted"] = true
-		}
-		if !ready {
-			nextCommand := driveTaskCheckResultCommand(taskID, string(runtime.As()))
-			fmt.Fprintf(runtime.IO().ErrOut, "Delete task is still in progress. Continue with: %s\n", nextCommand)
-			out["timed_out"] = true
-			out["next_command"] = nextCommand
-		}
-
-		runtime.Out(out, nil)
+		}, nil)
 		return nil
 	},
 }
 
-func driveDeleteParams(spec driveDeleteSpec) map[string]interface{} {
-	return map[string]interface{}{
-		"type":  spec.FileType,
-		"async": true,
-	}
-}
-
 func validateDriveDeleteSpec(spec driveDeleteSpec) error {
 	if err := validate.ResourceName(spec.FileToken, "--file-token"); err != nil {
 		return errs.NewValidationError(errs.SubtypeInvalidArgument, "%s", err).WithParam("--file-token")

shortcuts/drive/drive_delete_test.go

@@ -7,7 +7,6 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
-	"net/http"
 	"strings"
 	"testing"
 
@@ -33,16 +32,16 @@ func TestValidateDriveDeleteSpecRejectsWiki(t *testing.T) {
 	}
 }
 
-func TestDriveDeleteDryRunIncludesAsyncAndTaskCheckParams(t *testing.T) {
+func TestDriveDeleteDryRunFolderIncludesTaskCheckParams(t *testing.T) {
 	t.Parallel()
 
 	cmd := &cobra.Command{Use: "drive +delete"}
 	cmd.Flags().String("file-token", "", "")
 	cmd.Flags().String("type", "", "")
-	if err := cmd.Flags().Set("file-token", "docx_src"); err != nil {
+	if err := cmd.Flags().Set("file-token", "fld_src"); err != nil {
 		t.Fatalf("set --file-token: %v", err)
 	}
-	if err := cmd.Flags().Set("type", "docx"); err != nil {
+	if err := cmd.Flags().Set("type", "folder"); err != nil {
 		t.Fatalf("set --type: %v", err)
 	}
 
@@ -72,36 +71,14 @@ func TestDriveDeleteDryRunIncludesAsyncAndTaskCheckParams(t *testing.T) {
 	if got.API[0].Method != "DELETE" {
 		t.Fatalf("first method = %q, want DELETE", got.API[0].Method)
 	}
-	if got.API[0].Params["type"] != "docx" {
+	if got.API[0].Params["type"] != "folder" {
 		t.Fatalf("delete params = %#v", got.API[0].Params)
 	}
-	if got.API[0].Params["async"] != true {
-		t.Fatalf("delete params = %#v, want async=true", got.API[0].Params)
-	}
 	if got.API[1].Params["task_id"] != "<task_id>" {
 		t.Fatalf("task check params = %#v", got.API[1].Params)
 	}
 }
 
-func TestDriveDeleteScopesIncludeTaskCheckReadScope(t *testing.T) {
-	t.Parallel()
-
-	wantScopes := map[string]bool{
-		"space:document:delete":         false,
-		"drive:drive.metadata:readonly": false,
-	}
-	for _, scope := range DriveDelete.Scopes {
-		if _, ok := wantScopes[scope]; ok {
-			wantScopes[scope] = true
-		}
-	}
-	for scope, seen := range wantScopes {
-		if !seen {
-			t.Fatalf("DriveDelete.Scopes missing %q: %#v", scope, DriveDelete.Scopes)
-		}
-	}
-}
-
 func TestDriveDeleteRequiresYes(t *testing.T) {
 	f, _, _, _ := cmdutil.TestFactory(t, driveTestConfig())
 
@@ -120,63 +97,6 @@ func TestDriveDeleteRequiresYes(t *testing.T) {
 }
 
 func TestDriveDeleteFileSuccess(t *testing.T) {
-	f, stdout, _, reg := cmdutil.TestFactory(t, driveTestConfig())
-	reg.Register(&httpmock.Stub{
-		Method: "DELETE",
-		URL:    "/open-apis/drive/v1/files/file_token_test",
-		Body: map[string]interface{}{
-			"code": 0,
-			"data": map[string]interface{}{"task_id": "task_file_123"},
-		},
-		OnMatch: func(req *http.Request) {
-			query := req.URL.Query()
-			if got := query.Get("type"); got != "file" {
-				t.Errorf("delete query type=%q, want file", got)
-			}
-			if got := query.Get("async"); got != "true" {
-				t.Errorf("delete query async=%q, want true", got)
-			}
-		},
-	})
-	reg.Register(&httpmock.Stub{
-		Method: "GET",
-		URL:    "/open-apis/drive/v1/files/task_check",
-		Body: map[string]interface{}{
-			"code": 0,
-			"data": map[string]interface{}{"status": "success"},
-		},
-		OnMatch: func(req *http.Request) {
-			if got := req.URL.Query().Get("task_id"); got != "task_file_123" {
-				t.Errorf("task_check task_id=%q, want task_file_123", got)
-			}
-		},
-	})
-
-	err := mountAndRunDrive(t, DriveDelete, []string{
-		"+delete",
-		"--file-token", "file_token_test",
-		"--type", "file",
-		"--yes",
-		"--as", "bot",
-	}, f, stdout)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if !bytes.Contains(stdout.Bytes(), []byte(`"task_id": "task_file_123"`)) {
-		t.Fatalf("stdout missing task_id: %s", stdout.String())
-	}
-	if !bytes.Contains(stdout.Bytes(), []byte(`"deleted": true`)) {
-		t.Fatalf("stdout missing deleted=true: %s", stdout.String())
-	}
-	if !bytes.Contains(stdout.Bytes(), []byte(`"ready": true`)) {
-		t.Fatalf("stdout missing ready=true: %s", stdout.String())
-	}
-	if !bytes.Contains(stdout.Bytes(), []byte(`"file_token": "file_token_test"`)) {
-		t.Fatalf("stdout missing file token: %s", stdout.String())
-	}
-}
-
-func TestDriveDeleteWithoutTaskIDFallsBackToSyncSuccess(t *testing.T) {
 	f, stdout, _, reg := cmdutil.TestFactory(t, driveTestConfig())
 	reg.Register(&httpmock.Stub{
 		Method: "DELETE",
@@ -197,33 +117,23 @@ func TestDriveDeleteWithoutTaskIDFallsBackToSyncSuccess(t *testing.T) {
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
-	for _, needle := range []string{
-		`"deleted": true`,
-		`"file_token": "file_token_test"`,
-		`"type": "file"`,
-	} {
-		if !bytes.Contains(stdout.Bytes(), []byte(needle)) {
-			t.Fatalf("stdout missing %q: %s", needle, stdout.String())
-		}
+	if !bytes.Contains(stdout.Bytes(), []byte(`"deleted": true`)) {
+		t.Fatalf("stdout missing deleted=true: %s", stdout.String())
 	}
-	if bytes.Contains(stdout.Bytes(), []byte(`"task_id"`)) {
-		t.Fatalf("stdout should not include task_id for sync success fallback: %s", stdout.String())
+	if !bytes.Contains(stdout.Bytes(), []byte(`"file_token": "file_token_test"`)) {
+		t.Fatalf("stdout missing file token: %s", stdout.String())
 	}
 }
 
-func TestDriveDeleteTaskCheckOutcomes(t *testing.T) {
+func TestDriveDeleteFolderTaskCheckOutcomes(t *testing.T) {
 	tests := []struct {
 		name            string
-		fileType        string
-		fileToken       string
 		taskCheckBody   map[string]interface{}
 		wantErrContains string
 		wantStdout      []string
 	}{
 		{
-			name:      "docx success",
-			fileType:  "docx",
-			fileToken: "docx_src",
+			name: "success",
 			taskCheckBody: map[string]interface{}{
 				"code": 0,
 				"data": map[string]interface{}{"status": "success"},
@@ -235,9 +145,7 @@ func TestDriveDeleteTaskCheckOutcomes(t *testing.T) {
 			},
 		},
 		{
-			name:      "folder timeout",
-			fileType:  "folder",
-			fileToken: "fld_src",
+			name: "timeout",
 			taskCheckBody: map[string]interface{}{
 				"code": 0,
 				"data": map[string]interface{}{"status": "process"},
@@ -249,19 +157,15 @@ func TestDriveDeleteTaskCheckOutcomes(t *testing.T) {
 			},
 		},
 		{
-			name:      "folder failed",
-			fileType:  "folder",
-			fileToken: "fld_src",
+			name: "failed",
 			taskCheckBody: map[string]interface{}{
 				"code": 0,
 				"data": map[string]interface{}{"status": "fail"},
 			},
-			wantErrContains: "drive task failed",
+			wantErrContains: "folder task failed",
 		},
 		{
-			name:      "docx task_check error",
-			fileType:  "docx",
-			fileToken: "docx_src",
+			name: "task_check error",
 			taskCheckBody: map[string]interface{}{
 				"code": 1061001,
 				"msg":  "internal error",
@@ -275,7 +179,7 @@ func TestDriveDeleteTaskCheckOutcomes(t *testing.T) {
 			f, stdout, _, reg := cmdutil.TestFactory(t, driveTestConfig())
 			reg.Register(&httpmock.Stub{
 				Method: "DELETE",
-				URL:    "/open-apis/drive/v1/files/" + tt.fileToken,
+				URL:    "/open-apis/drive/v1/files/fld_src",
 				Body: map[string]interface{}{
 					"code": 0,
 					"data": map[string]interface{}{"task_id": "task_123"},
@@ -291,8 +195,8 @@ func TestDriveDeleteTaskCheckOutcomes(t *testing.T) {
 
 			err := mountAndRunDrive(t, DriveDelete, []string{
 				"+delete",
-				"--file-token", tt.fileToken,
-				"--type", tt.fileType,
+				"--file-token", "fld_src",
+				"--type", "folder",
 				"--yes",
 				"--as", "bot",
 			}, f, stdout)
@@ -318,66 +222,3 @@ func TestDriveDeleteTaskCheckOutcomes(t *testing.T) {
 		})
 	}
 }
-
-func TestDriveDeleteTimedOutTaskCanBeResumedWithTaskResult(t *testing.T) {
-	f, stdout, _, reg := cmdutil.TestFactory(t, driveTestConfig())
-	reg.Register(&httpmock.Stub{
-		Method: "DELETE",
-		URL:    "/open-apis/drive/v1/files/fld_token_test",
-		Body: map[string]interface{}{
-			"code": 0,
-			"data": map[string]interface{}{"task_id": "task_resume_123"},
-		},
-	})
-	reg.Register(&httpmock.Stub{
-		Method: "GET",
-		URL:    "/open-apis/drive/v1/files/task_check",
-		Body: map[string]interface{}{
-			"code": 0,
-			"data": map[string]interface{}{"status": "process"},
-		},
-	})
-	reg.Register(&httpmock.Stub{
-		Method: "GET",
-		URL:    "/open-apis/drive/v1/files/task_check",
-		Body: map[string]interface{}{
-			"code": 0,
-			"data": map[string]interface{}{"status": "success"},
-		},
-	})
-
-	withSingleDriveTaskCheckPoll(t)
-
-	err := mountAndRunDrive(t, DriveDelete, []string{
-		"+delete",
-		"--file-token", "fld_token_test",
-		"--type", "folder",
-		"--yes",
-		"--as", "bot",
-	}, f, stdout)
-	if err != nil {
-		t.Fatalf("unexpected delete error: %v", err)
-	}
-	if !bytes.Contains(stdout.Bytes(), []byte(`"ready": false`)) {
-		t.Fatalf("stdout missing ready=false: %s", stdout.String())
-	}
-	if !bytes.Contains(stdout.Bytes(), []byte(`"next_command": "lark-cli drive +task_result --scenario task_check --task-id task_resume_123 --as bot"`)) {
-		t.Fatalf("stdout missing next_command: %s", stdout.String())
-	}
-
-	err = mountAndRunDrive(t, DriveTaskResult, []string{
-		"+task_result",
-		"--scenario", "task_check",
-		"--task-id", "task_resume_123",
-		"--as", "bot",
-	}, f, stdout)
-	if err != nil {
-		t.Fatalf("unexpected task_result error: %v", err)
-	}
-	if !bytes.Contains(stdout.Bytes(), []byte(`"task_id": "task_resume_123"`)) {
-		t.Fatalf("task_result stdout missing task_id: %s", stdout.String())
-	}
-	if !bytes.Contains(stdout.Bytes(), []byte(`"ready": true`)) {
-		t.Fatalf("task_result stdout missing ready=true: %s", stdout.String())
-	}
-}

shortcuts/drive/drive_list_comments.go

@@ -6,7 +6,6 @@ package drive
 import (
 	"context"
 	"fmt"
-	"net/url"
 	"strings"
 
 	"github.com/larksuite/cli/errs"
@@ -20,7 +19,7 @@ const (
 	driveListCommentsDefaultScope        = "all"
 )
 
-var driveListCommentsTypes = []string{"doc", "docx", "sheet", "file", "slides", "bitable", "base", "apps", "wiki"}
+var driveListCommentsTypes = []string{"doc", "docx", "sheet", "file", "slides", "bitable", "base", "wiki"}
 
 type driveListCommentsRef struct {
 	Token      string
@@ -44,17 +43,17 @@ type driveListCommentsSpec struct {
 }
 
 // DriveListComments lists document comments through the Drive comments API,
-// while accepting Wiki URLs/tokens and Miaoda /page/<token> apps URLs.
+// while accepting Wiki URLs/tokens and resolving them to the underlying object.
 var DriveListComments = common.Shortcut{
 	Service:           "drive",
 	Command:           "+list-comments",
-	Description:       "List comments for doc/docx/sheet/file/slides/base(bitable)/apps, with URL parsing and Wiki token unwrapping",
+	Description:       "List comments for doc/docx/sheet/file/slides/base(bitable), with URL parsing and Wiki token unwrapping",
 	Risk:              "read",
 	Scopes:            []string{"docs:document.comment:read"},
 	ConditionalScopes: []string{"wiki:node:retrieve"},
 	AuthTypes:         []string{"user", "bot"},
 	Flags: []common.Flag{
-		{Name: "url", Desc: "recommended: Lark/Feishu document URL (doc/docx/sheet/file/slides/base/bitable/apps/wiki); apps Miaoda URLs use /page/<token>; Wiki URLs are unwrapped automatically"},
+		{Name: "url", Desc: "recommended: Lark/Feishu document URL (doc/docx/sheet/file/slides/base/bitable/wiki); Wiki URLs are unwrapped automatically"},
 		{Name: "token", Desc: "document token, Wiki token, or document URL; bare tokens require --type"},
 		{Name: "type", Desc: "document type for bare --token; optional for URLs but must match the URL type when provided", Enum: driveListCommentsTypes},
 		{Name: "solved-status", Default: driveListCommentsDefaultSolvedStatus, Desc: "comment solved filter: false=unresolved, true=solved, all=all comments", Enum: []string{"false", "true", "all"}},
@@ -166,60 +165,29 @@ func resolveDriveListCommentsInput(urlInput, tokenInput, explicitType string) (d
 		if !driveListCommentsTypeSupported(refType) {
 			return driveListCommentsRef{}, errs.NewValidationError(
 				errs.SubtypeInvalidArgument,
-				"unsupported %s resource type %q; comments list supports doc, docx, sheet, file, slides, bitable/base, apps, and wiki",
+				"unsupported %s resource type %q; comments list supports doc, docx, sheet, file, slides, bitable/base, and wiki",
 				sourceFlag,
 				refType,
 			).WithParam(sourceFlag)
 		}
 		return driveListCommentsRef{Token: ref.Token, Type: refType, SourceFlag: sourceFlag}, nil
 	}
-	if token, ok := parseDriveListCommentsAppsURL(raw); ok {
-		const refType = "apps"
-		if inputType != "" && inputType != refType {
-			return driveListCommentsRef{}, errs.NewValidationError(
-				errs.SubtypeInvalidArgument,
-				"--type %q conflicts with URL path type %q; remove --type or use a matching value",
-				inputType,
-				refType,
-			).WithParam("--type")
-		}
-		return driveListCommentsRef{Token: token, Type: refType, SourceFlag: sourceFlag}, nil
-	}
 
 	if strings.Contains(raw, "://") {
-		return driveListCommentsRef{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "unsupported %s URL %q: use a recognized Lark document URL, a Miaoda /page/<token> URL, or pass a bare token with --type", sourceFlag, raw).WithParam(sourceFlag)
+		return driveListCommentsRef{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "unsupported %s URL %q: use a recognized Lark document URL or pass a bare token with --type", sourceFlag, raw).WithParam(sourceFlag)
 	}
 	if strings.ContainsAny(raw, "/?#") {
 		return driveListCommentsRef{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "invalid bare token %q: remove path/query fragments or pass a recognized Lark document URL", raw).WithParam(sourceFlag)
 	}
 	if inputType == "" {
-		return driveListCommentsRef{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "--type is required when %s is a bare token (allowed: doc, docx, sheet, file, slides, bitable, base, apps, wiki)", sourceFlag).WithParam("--type")
+		return driveListCommentsRef{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "--type is required when %s is a bare token (allowed: doc, docx, sheet, file, slides, bitable, base, wiki)", sourceFlag).WithParam("--type")
 	}
 	if !driveListCommentsTypeSupported(inputType) {
-		return driveListCommentsRef{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "invalid --type %q; allowed: doc, docx, sheet, file, slides, bitable, base, apps, wiki", inputType).WithParam("--type")
+		return driveListCommentsRef{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "invalid --type %q; allowed: doc, docx, sheet, file, slides, bitable, base, wiki", inputType).WithParam("--type")
 	}
 	return driveListCommentsRef{Token: raw, Type: inputType, SourceFlag: sourceFlag}, nil
 }
 
-func parseDriveListCommentsAppsURL(rawURL string) (string, bool) {
-	u, err := url.Parse(strings.TrimSpace(rawURL))
-	if err != nil || u.Scheme == "" || u.Host == "" {
-		return "", false
-	}
-
-	path := strings.Trim(u.Path, "/")
-	parts := strings.Split(path, "/")
-	if len(parts) < 2 || parts[0] != "page" {
-		return "", false
-	}
-
-	token := strings.TrimSpace(parts[1])
-	if token == "" {
-		return "", false
-	}
-	return token, true
-}
-
 func normalizeDriveListCommentsType(docType string) string {
 	switch strings.TrimSpace(docType) {
 	case "base":
@@ -231,7 +199,7 @@ func normalizeDriveListCommentsType(docType string) string {
 
 func driveListCommentsTypeSupported(docType string) bool {
 	switch normalizeDriveListCommentsType(docType) {
-	case "doc", "docx", "sheet", "file", "slides", "bitable", "apps", "wiki":
+	case "doc", "docx", "sheet", "file", "slides", "bitable", "wiki":
 		return true
 	default:
 		return false
@@ -263,7 +231,7 @@ func resolveDriveListCommentsTarget(ctx context.Context, runtime *common.Runtime
 	if !driveListCommentsTypeSupported(objType) || objType == "wiki" {
 		return driveListCommentsTarget{}, errs.NewValidationError(
 			errs.SubtypeInvalidArgument,
-			"wiki resolved to %q, but comments list only supports doc, docx, sheet, file, slides, bitable, and apps",
+			"wiki resolved to %q, but comments list only supports doc, docx, sheet, file, slides, and bitable",
 			objType,
 		).WithParam(ref.SourceFlag)
 	}

shortcuts/drive/drive_list_comments_test.go

@@ -46,32 +46,6 @@ func TestResolveDriveListCommentsInput(t *testing.T) {
 			wantResource: "wikiResource",
 			wantType:     "wiki",
 		},
-		{
-			name:         "bare apps token",
-			rawInput:     "appsResource",
-			docType:      "apps",
-			wantResource: "appsResource",
-			wantType:     "apps",
-		},
-		{
-			name:         "miaoda page url",
-			urlInput:     "https://bytedance.feishu.cn/page/appsResource/?from=home",
-			wantResource: "appsResource",
-			wantType:     "apps",
-		},
-		{
-			name:         "token flag also accepts miaoda page url",
-			rawInput:     "https://bytedance.feishu.cn/page/appsResource/",
-			wantResource: "appsResource",
-			wantType:     "apps",
-		},
-		{
-			name:      "miaoda page url type conflict",
-			urlInput:  "https://bytedance.feishu.cn/page/appsResource/",
-			docType:   "docx",
-			wantErr:   "conflicts",
-			wantParam: "--type",
-		},
 		{
 			name:      "url and token mutually exclusive",
 			urlInput:  "https://example.larksuite.com/docx/docxResource",
@@ -98,19 +72,6 @@ func TestResolveDriveListCommentsInput(t *testing.T) {
 			wantErr:   "unsupported",
 			wantParam: "--url",
 		},
-		{
-			name:      "unsupported miaoda url path",
-			urlInput:  "https://bytedance.feishu.cn/app/appsResource",
-			wantErr:   "Miaoda /page/<token>",
-			wantParam: "--url",
-		},
-		{
-			name:      "invalid bare token type",
-			rawInput:  "appsResource",
-			docType:   "folder",
-			wantErr:   "invalid --type",
-			wantParam: "--type",
-		},
 	}
 
 	for _, tt := range tests {
@@ -135,50 +96,6 @@ func TestResolveDriveListCommentsInput(t *testing.T) {
 	}
 }
 
-func TestParseDriveListCommentsAppsURL(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name      string
-		rawURL    string
-		wantToken string
-		wantOK    bool
-	}{
-		{
-			name:      "page url",
-			rawURL:    "https://bytedance.feishu.cn/page/appsResource?from=home",
-			wantToken: "appsResource",
-			wantOK:    true,
-		},
-		{
-			name:   "bare token is not url",
-			rawURL: "appsResource",
-		},
-		{
-			name:   "non page path",
-			rawURL: "https://bytedance.feishu.cn/app/appsResource",
-		},
-		{
-			name:   "empty page token",
-			rawURL: "https://bytedance.feishu.cn/page/%20",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-
-			gotToken, gotOK := parseDriveListCommentsAppsURL(tt.rawURL)
-			if gotOK != tt.wantOK {
-				t.Fatalf("ok = %v, want %v", gotOK, tt.wantOK)
-			}
-			if gotToken != tt.wantToken {
-				t.Fatalf("token = %q, want %q", gotToken, tt.wantToken)
-			}
-		})
-	}
-}
-
 func TestValidateDriveListCommentsSpec(t *testing.T) {
 	t.Parallel()
 
@@ -311,14 +228,6 @@ func TestBuildDriveListCommentsParams(t *testing.T) {
 	if _, ok := sheetParams["need_relation"]; ok {
 		t.Fatalf("need_relation should be ignored for non-docx: %#v", sheetParams)
 	}
-
-	appsParams := buildDriveListCommentsParams(allPartialSpec, "apps")
-	if got := appsParams["file_type"]; got != "apps" {
-		t.Fatalf("apps file_type = %#v, want apps", got)
-	}
-	if _, ok := appsParams["need_relation"]; ok {
-		t.Fatalf("need_relation should be ignored for apps: %#v", appsParams)
-	}
 }
 
 func TestDriveListCommentsExecuteDocx(t *testing.T) {
@@ -444,84 +353,3 @@ func TestDriveListCommentsExecuteWikiResolvesToDocx(t *testing.T) {
 		t.Fatalf("file_type = %q, want docx", got)
 	}
 }
-
-func TestDriveListCommentsExecuteWikiRejectsUnsupportedResolvedType(t *testing.T) {
-	f, stdout, _, reg := cmdutil.TestFactory(t, driveTestConfig())
-	reg.Register(&httpmock.Stub{
-		Method: "GET",
-		URL:    "/open-apis/wiki/v2/spaces/get_node",
-		Body: map[string]interface{}{
-			"code": 0,
-			"msg":  "success",
-			"data": map[string]interface{}{
-				"node": map[string]interface{}{
-					"obj_type":  "folder",
-					"obj_token": "folderResource",
-				},
-			},
-		},
-	})
-
-	err := mountAndRunDrive(t, DriveListComments, []string{
-		"+list-comments",
-		"--token", "wikiResource",
-		"--type", "wiki",
-		"--as", "user",
-	}, f, stdout)
-	if err == nil || !strings.Contains(err.Error(), "supports doc, docx, sheet, file, slides, bitable, and apps") {
-		t.Fatalf("expected unsupported resolved type error, got %v", err)
-	}
-	assertDriveListCommentsValidationError(t, err, "--token")
-}
-
-func TestDriveListCommentsExecuteAppsPageURL(t *testing.T) {
-	f, stdout, _, reg := cmdutil.TestFactory(t, driveTestConfig())
-	reg.Register(&httpmock.Stub{
-		Method: "GET",
-		URL:    "/open-apis/drive/v1/files/appsResource/comments",
-		OnMatch: func(req *http.Request) {
-			query := req.URL.Query()
-			if got := query.Get("file_type"); got != "apps" {
-				t.Errorf("file_type = %q, want apps", got)
-			}
-			if got := query.Get("is_solved"); got != "false" {
-				t.Errorf("is_solved = %q, want false", got)
-			}
-			if got := query.Get("need_relation"); got != "" {
-				t.Errorf("need_relation = %q, want omitted for apps", got)
-			}
-		},
-		Body: map[string]interface{}{
-			"code": 0,
-			"msg":  "success",
-			"data": map[string]interface{}{
-				"items": []map[string]interface{}{
-					{"comment_id": "comment_apps_1", "is_solved": false},
-				},
-				"has_more": false,
-			},
-		},
-	})
-
-	err := mountAndRunDrive(t, DriveListComments, []string{
-		"+list-comments",
-		"--url", "https://bytedance.feishu.cn/page/appsResource/",
-		"--need-relation",
-		"--as", "user",
-	}, f, stdout)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	out := decodeJSONMap(t, stdout.String())
-	data := mustMapValue(t, out["data"], "data")
-	if got := mustStringField(t, data, "file_token", "data.file_token"); got != "appsResource" {
-		t.Fatalf("file_token = %q, want appsResource", got)
-	}
-	if got := mustStringField(t, data, "file_type", "data.file_type"); got != "apps" {
-		t.Fatalf("file_type = %q, want apps", got)
-	}
-	if got := data["count"]; got != float64(1) {
-		t.Fatalf("count = %#v, want 1", got)
-	}
-}

shortcuts/drive/drive_move_common.go

@@ -61,7 +61,7 @@ func validateDriveMoveSpec(spec driveMoveSpec) error {
 }
 
 // driveTaskCheckStatus represents the status payload returned by
-// /drive/v1/files/task_check for async Drive move/delete operations.
+// /drive/v1/files/task_check for async folder move/delete operations.
 type driveTaskCheckStatus struct {
 	TaskID string
 	Status string
@@ -74,7 +74,7 @@ func (s driveTaskCheckStatus) Ready() bool {
 func (s driveTaskCheckStatus) Failed() bool {
 	status := strings.TrimSpace(s.Status)
 	// The shared task_check endpoint is reused by multiple async flows. Some
-	// backends return "failed", while delete can return the shorter
+	// backends return "failed", while folder delete can return the shorter
 	// terminal state "fail".
 	return strings.EqualFold(status, "failed") || strings.EqualFold(status, "fail")
 }
@@ -106,7 +106,7 @@ func driveTaskCheckParams(taskID string) map[string]interface{} {
 }
 
 // getDriveTaskCheckStatus fetches and validates the current state of an async
-// Drive move or delete task.
+// folder move or delete task.
 func getDriveTaskCheckStatus(runtime *common.RuntimeContext, taskID string) (driveTaskCheckStatus, error) {
 	if err := validate.ResourceName(taskID, "--task-id"); err != nil {
 		return driveTaskCheckStatus{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "%s", err).WithParam("--task-id")
@@ -159,11 +159,11 @@ func pollDriveTaskCheck(runtime *common.RuntimeContext, taskID string) (driveTas
 		// Success and failure are terminal backend states. Any other value is kept
 		// as pending so the caller can decide whether to continue or resume later.
 		if status.Ready() {
-			fmt.Fprintf(runtime.IO().ErrOut, "Drive task completed successfully.\n")
+			fmt.Fprintf(runtime.IO().ErrOut, "Folder task completed successfully.\n")
 			return status, true, nil
 		}
 		if status.Failed() {
-			return status, false, errs.NewAPIError(errs.SubtypeServerError, "drive task failed")
+			return status, false, errs.NewAPIError(errs.SubtypeServerError, "folder task failed")
 		}
 	}
 

shortcuts/drive/drive_task_result.go

@@ -15,20 +15,12 @@ import (
 	"github.com/larksuite/cli/shortcuts/common"
 )
 
-const (
-	// These are fixed backend wire values for the Wiki-to-Drive task. Keep
-	// them unchanged even though the CLI scenario uses wiki_move_to_drive.
-	wikiMoveToDriveTaskType  = "move_wiki_to_docs"
-	wikiMoveToDriveResultKey = "move_wiki_to_docs_result"
-)
-
 // DriveTaskResult exposes a unified read path for the async task types produced
-// by Drive import, export, file/folder move/delete, wiki move, wiki move-to-drive,
-// and wiki delete flows.
+// by Drive import, export, folder move/delete, wiki move, and wiki delete-space flows.
 var DriveTaskResult = common.Shortcut{
 	Service:     "drive",
 	Command:     "+task_result",
-	Description: "Poll async task result for import, export, drive move/delete, wiki move, wiki move-to-drive, or wiki delete operations",
+	Description: "Poll async task result for import, export, drive move/delete, wiki move, wiki delete-space, or wiki delete-node operations",
 	Risk:        "read",
 	// This shortcut multiplexes multiple backend APIs with different scope
 	// requirements, so scenario-specific prechecks are handled in Validate.
@@ -36,23 +28,22 @@ var DriveTaskResult = common.Shortcut{
 	AuthTypes: []string{"user", "bot"},
 	Flags: []common.Flag{
 		{Name: "ticket", Desc: "async task ticket (for import/export tasks)", Required: false},
-		{Name: "task-id", Desc: "async task ID (for drive task_check and all wiki task scenarios)", Required: false},
-		{Name: "scenario", Desc: "task scenario: import, export, task_check, wiki_move, wiki_move_to_drive, wiki_delete_space, or wiki_delete_node", Required: true},
+		{Name: "task-id", Desc: "async task ID (for drive task_check, wiki_move, wiki_delete_space, or wiki_delete_node tasks)", Required: false},
+		{Name: "scenario", Desc: "task scenario: import, export, task_check, wiki_move, wiki_delete_space, or wiki_delete_node", Required: true},
 		{Name: "file-token", Desc: "source document token used for export task status lookup", Required: false},
 	},
 	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
 		scenario := strings.ToLower(runtime.Str("scenario"))
 		validScenarios := map[string]bool{
-			"import":             true,
-			"export":             true,
-			"task_check":         true,
-			"wiki_move":          true,
-			"wiki_move_to_drive": true,
-			"wiki_delete_space":  true,
-			"wiki_delete_node":   true,
+			"import":            true,
+			"export":            true,
+			"task_check":        true,
+			"wiki_move":         true,
+			"wiki_delete_space": true,
+			"wiki_delete_node":  true,
 		}
 		if !validScenarios[scenario] {
-			return errs.NewValidationError(errs.SubtypeInvalidArgument, "unsupported scenario: %s. Supported scenarios: import, export, task_check, wiki_move, wiki_move_to_drive, wiki_delete_space, wiki_delete_node", scenario).WithParam("--scenario")
+			return errs.NewValidationError(errs.SubtypeInvalidArgument, "unsupported scenario: %s. Supported scenarios: import, export, task_check, wiki_move, wiki_delete_space, wiki_delete_node", scenario).WithParam("--scenario")
 		}
 
 		// Validate required params based on scenario
@@ -64,7 +55,7 @@ var DriveTaskResult = common.Shortcut{
 			if err := validate.ResourceName(runtime.Str("ticket"), "--ticket"); err != nil {
 				return errs.NewValidationError(errs.SubtypeInvalidArgument, "%s", err).WithParam("--ticket")
 			}
-		case "task_check", "wiki_move", "wiki_move_to_drive", "wiki_delete_space", "wiki_delete_node":
+		case "task_check", "wiki_move", "wiki_delete_space", "wiki_delete_node":
 			if runtime.Str("task-id") == "" {
 				return errs.NewValidationError(errs.SubtypeInvalidArgument, "--task-id is required for %s scenario", scenario).WithParam("--task-id")
 			}
@@ -106,18 +97,13 @@ var DriveTaskResult = common.Shortcut{
 				Params(map[string]interface{}{"token": fileToken})
 		case "task_check":
 			dry.GET("/open-apis/drive/v1/files/task_check").
-				Desc("[1] Query Drive file/folder move/delete task status").
+				Desc("[1] Query move/delete folder task status").
 				Params(driveTaskCheckParams(taskID))
 		case "wiki_move":
 			dry.GET("/open-apis/wiki/v2/tasks/:task_id").
 				Desc("[1] Query wiki move task result").
 				Set("task_id", taskID).
 				Params(map[string]interface{}{"task_type": "move"})
-		case "wiki_move_to_drive":
-			dry.GET("/open-apis/wiki/v2/tasks/:task_id").
-				Desc("[1] Query wiki move-to-drive task result").
-				Set("task_id", taskID).
-				Params(map[string]interface{}{"task_type": wikiMoveToDriveTaskType})
 		case "wiki_delete_space":
 			dry.GET("/open-apis/wiki/v2/tasks/:task_id").
 				Desc("[1] Query wiki delete-space task result").
@@ -154,8 +140,6 @@ var DriveTaskResult = common.Shortcut{
 			result, err = queryTaskCheck(runtime, taskID)
 		case "wiki_move":
 			result, err = queryWikiMoveTask(runtime, taskID)
-		case "wiki_move_to_drive":
-			result, err = queryWikiMoveToDriveTask(runtime, taskID)
 		case "wiki_delete_space":
 			result, err = queryWikiDeleteSpaceTask(runtime, taskID)
 		case "wiki_delete_node":
@@ -225,7 +209,7 @@ func queryExportTask(runtime *common.RuntimeContext, ticket, fileToken string) (
 	}, nil
 }
 
-// queryTaskCheck returns the normalized status of a Drive file/folder move/delete task.
+// queryTaskCheck returns the normalized status of a folder move/delete task.
 func queryTaskCheck(runtime *common.RuntimeContext, taskID string) (map[string]interface{}, error) {
 	status, err := getDriveTaskCheckStatus(runtime, taskID)
 	if err != nil {
@@ -260,7 +244,7 @@ func validateDriveTaskResultScopes(ctx context.Context, runtime *common.RuntimeC
 	switch scenario {
 	case "import", "export", "task_check":
 		required = []string{"drive:drive.metadata:readonly"}
-	case "wiki_move", "wiki_move_to_drive", "wiki_delete_space", "wiki_delete_node":
+	case "wiki_move", "wiki_delete_space", "wiki_delete_node":
 		required = []string{"wiki:space:read"}
 	}
 
@@ -502,75 +486,6 @@ func appendWikiMoveNodeFields(out, node map[string]interface{}) {
 	out["has_child"] = common.GetBool(node, "has_child")
 }
 
-// queryWikiMoveToDriveTask returns the normalized status and final Drive
-// resource fields for wiki +move-to-drive. The task endpoint uses a dedicated
-// result object with numeric status codes: 0 success, 1 processing, -1 failure.
-func queryWikiMoveToDriveTask(runtime *common.RuntimeContext, taskID string) (map[string]interface{}, error) {
-	if err := validate.ResourceName(taskID, "--task-id"); err != nil {
-		return nil, errs.NewValidationError(errs.SubtypeInvalidArgument, "%s", err).WithParam("--task-id").WithCause(err)
-	}
-
-	data, err := runtime.CallAPITyped(
-		"GET",
-		fmt.Sprintf("/open-apis/wiki/v2/tasks/%s", validate.EncodePathSegment(taskID)),
-		map[string]interface{}{"task_type": wikiMoveToDriveTaskType},
-		nil,
-	)
-	if err != nil {
-		return nil, err
-	}
-
-	task := common.GetMap(data, "task")
-	if task == nil {
-		return nil, errs.NewInternalError(errs.SubtypeInvalidResponse, "wiki task response missing task")
-	}
-	result := common.GetMap(task, wikiMoveToDriveResultKey)
-	if result == nil {
-		return nil, errs.NewInternalError(errs.SubtypeInvalidResponse, "wiki task response missing %s", wikiMoveToDriveResultKey)
-	}
-	statusCode, ok := common.GetFloatOK(result, "status")
-	if !ok {
-		return nil, errs.NewInternalError(errs.SubtypeInvalidResponse, "wiki task response has missing or non-numeric %s.status", wikiMoveToDriveResultKey)
-	}
-	if statusCode != -1 && statusCode != 0 && statusCode != 1 {
-		return nil, errs.NewInternalError(
-			errs.SubtypeInvalidResponse,
-			"wiki task response has unsupported %s.status: %v",
-			wikiMoveToDriveResultKey,
-			statusCode,
-		)
-	}
-
-	resolvedTaskID := common.GetString(task, "task_id")
-	if resolvedTaskID == "" {
-		resolvedTaskID = taskID
-	}
-	status := int(statusCode)
-	statusMsg := strings.TrimSpace(common.GetString(result, "status_msg"))
-	if statusMsg == "" {
-		switch {
-		case status == 0:
-			statusMsg = "success"
-		case status < 0:
-			statusMsg = "failure"
-		default:
-			statusMsg = "processing"
-		}
-	}
-
-	return map[string]interface{}{
-		"scenario":   "wiki_move_to_drive",
-		"task_id":    resolvedTaskID,
-		"ready":      status == 0,
-		"failed":     status < 0,
-		"status":     status,
-		"status_msg": statusMsg,
-		"obj_token":  common.GetString(result, "obj_token"),
-		"obj_type":   common.GetString(result, "obj_type"),
-		"url":        common.GetString(result, "url"),
-	}, nil
-}
-
 // queryWikiDeleteSpaceTask returns the normalized status of an async wiki
 // delete-space task. The backend reports a single delete_space_result object
 // rather than the per-node array used by wiki move.

shortcuts/drive/drive_task_result_test.go

@@ -66,13 +66,6 @@ func TestDriveTaskResultValidateErrorsByScenario(t *testing.T) {
 			},
 			wantErr: "--task-id is required",
 		},
-		{
-			name: "wiki move to Drive missing task id",
-			flags: map[string]string{
-				"scenario": "wiki_move_to_drive",
-			},
-			wantErr: "--task-id is required",
-		},
 	}
 
 	for _, tt := range tests {
@@ -433,174 +426,13 @@ func TestDriveTaskResultWikiMoveIncludesFlattenedNodeFields(t *testing.T) {
 	}
 }
 
-func TestDriveTaskResultDryRunWikiMoveToDriveIncludesTaskTypeParam(t *testing.T) {
-	t.Parallel()
-
-	cmd := &cobra.Command{Use: "drive +task_result"}
-	cmd.Flags().String("scenario", "", "")
-	cmd.Flags().String("ticket", "", "")
-	cmd.Flags().String("task-id", "", "")
-	cmd.Flags().String("file-token", "", "")
-	if err := cmd.Flags().Set("scenario", "wiki_move_to_drive"); err != nil {
-		t.Fatalf("set --scenario: %v", err)
-	}
-	if err := cmd.Flags().Set("task-id", "raw-task-signature"); err != nil {
-		t.Fatalf("set --task-id: %v", err)
-	}
-
-	runtime := common.TestNewRuntimeContext(cmd, nil)
-	dry := DriveTaskResult.DryRun(context.Background(), runtime)
-	if dry == nil {
-		t.Fatal("DryRun returned nil")
-	}
-
-	data, err := json.Marshal(dry)
-	if err != nil {
-		t.Fatalf("marshal dry run: %v", err)
-	}
-	var got struct {
-		API []struct {
-			Params map[string]interface{} `json:"params"`
-		} `json:"api"`
-	}
-	if err := json.Unmarshal(data, &got); err != nil {
-		t.Fatalf("unmarshal dry run json: %v", err)
-	}
-	if len(got.API) != 1 || got.API[0].Params["task_type"] != "move_wiki_to_docs" {
-		t.Fatalf("wiki move-to-drive dry run = %#v", got.API)
-	}
-}
-
-func TestDriveTaskResultWikiMoveToDriveStatuses(t *testing.T) {
-	tests := []struct {
-		name       string
-		status     int
-		statusMsg  string
-		wantReady  bool
-		wantFailed bool
-	}{
-		{name: "success", status: 0, statusMsg: "success", wantReady: true},
-		{name: "processing fallback label", status: 1, wantReady: false},
-		{name: "failure", status: -1, statusMsg: "failure", wantFailed: true},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			factory, stdout, _, registry := cmdutil.TestFactory(t, driveTestConfig())
-			registry.Register(&httpmock.Stub{
-				Method: "GET",
-				URL:    "/open-apis/wiki/v2/tasks/raw-task-signature",
-				Body: map[string]interface{}{
-					"code": 0,
-					"data": map[string]interface{}{
-						"task": map[string]interface{}{
-							// The external handler may omit task.task_id, so the
-							// result must retain the signed request ID.
-							"move_wiki_to_docs_result": map[string]interface{}{
-								"status":     tt.status,
-								"status_msg": tt.statusMsg,
-								"obj_token":  "docxABC",
-								"obj_type":   "docx",
-								"url":        "https://example.feishu.cn/docx/docxABC",
-							},
-						},
-					},
-				},
-			})
-
-			err := mountAndRunDrive(t, DriveTaskResult, []string{
-				"+task_result",
-				"--scenario", "wiki_move_to_drive",
-				"--task-id", "raw-task-signature",
-				"--as", "user",
-			}, factory, stdout)
-			if err != nil {
-				t.Fatalf("mountAndRunDrive() error = %v", err)
-			}
-
-			data := decodeDriveEnvelope(t, stdout)
-			if data["scenario"] != "wiki_move_to_drive" || data["task_id"] != "raw-task-signature" {
-				t.Fatalf("unexpected envelope = %#v", data)
-			}
-			if data["ready"] != tt.wantReady || data["failed"] != tt.wantFailed {
-				t.Fatalf("readiness fields = %#v", data)
-			}
-			if tt.statusMsg == "" && data["status_msg"] != "processing" {
-				t.Fatalf("status_msg = %#v, want processing fallback", data["status_msg"])
-			}
-			if data["obj_token"] != "docxABC" || data["obj_type"] != "docx" || data["url"] == "" {
-				t.Fatalf("result fields = %#v", data)
-			}
-		})
-	}
-}
-
-func TestDriveTaskResultWikiMoveToDriveRejectsMissingResult(t *testing.T) {
-	factory, stdout, _, registry := cmdutil.TestFactory(t, driveTestConfig())
-	registry.Register(&httpmock.Stub{
-		Method: "GET",
-		URL:    "/open-apis/wiki/v2/tasks/raw-task-signature",
-		Body: map[string]interface{}{
-			"code": 0,
-			"data": map[string]interface{}{"task": map[string]interface{}{}},
-		},
-	})
-
-	err := mountAndRunDrive(t, DriveTaskResult, []string{
-		"+task_result",
-		"--scenario", "wiki_move_to_drive",
-		"--task-id", "raw-task-signature",
-		"--as", "user",
-	}, factory, stdout)
-	problem, ok := errs.ProblemOf(err)
-	if !ok || problem.Category != errs.CategoryInternal || problem.Subtype != errs.SubtypeInvalidResponse {
-		t.Fatalf("error = %T %v, want internal/invalid_response", err, err)
-	}
-}
-
-func TestDriveTaskResultWikiMoveToDriveRejectsMalformedStatus(t *testing.T) {
-	for name, rawStatus := range map[string]interface{}{
-		"null":          nil,
-		"string":        "processing",
-		"fractional":    0.5,
-		"unknown value": 2,
-	} {
-		t.Run(name, func(t *testing.T) {
-			factory, stdout, _, registry := cmdutil.TestFactory(t, driveTestConfig())
-			registry.Register(&httpmock.Stub{
-				Method: "GET",
-				URL:    "/open-apis/wiki/v2/tasks/raw-task-signature",
-				Body: map[string]interface{}{
-					"code": 0,
-					"data": map[string]interface{}{
-						"task": map[string]interface{}{
-							"move_wiki_to_docs_result": map[string]interface{}{"status": rawStatus},
-						},
-					},
-				},
-			})
-
-			err := mountAndRunDrive(t, DriveTaskResult, []string{
-				"+task_result",
-				"--scenario", "wiki_move_to_drive",
-				"--task-id", "raw-task-signature",
-				"--as", "user",
-			}, factory, stdout)
-			problem, ok := errs.ProblemOf(err)
-			if !ok || problem.Category != errs.CategoryInternal || problem.Subtype != errs.SubtypeInvalidResponse {
-				t.Fatalf("error = %T %v, want internal/invalid_response", err, err)
-			}
-		})
-	}
-}
-
 func TestValidateDriveTaskResultScopesWikiScenariosRequireWikiScope(t *testing.T) {
 	t.Parallel()
 
-	// Every Wiki scenario reads Wiki task status, so all must require
-	// wiki:space:read. A single table keeps this invariant explicit without
-	// duplicating near-identical test functions.
-	for _, scenario := range []string{"wiki_move", "wiki_move_to_drive", "wiki_delete_space", "wiki_delete_node"} {
+	// wiki_move, wiki_delete_space and wiki_delete_node all read wiki task
+	// status, so all must require wiki:space:read. A single table keeps this
+	// invariant explicit without duplicating near-identical test functions.
+	for _, scenario := range []string{"wiki_move", "wiki_delete_space", "wiki_delete_node"} {
 		t.Run(scenario+"/rejects missing scope", func(t *testing.T) {
 			t.Parallel()
 			runtime := newDriveTaskResultRuntimeWithScopes(t, core.AsUser, "drive:drive.metadata:readonly")

shortcuts/mail/flag_suggest.go

@@ -1,286 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package mail
-
-import (
-	"fmt"
-	"sort"
-	"strings"
-
-	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
-
-	"github.com/larksuite/cli/errs"
-)
-
-// flagName is a package-private snapshot of a pflag.Flag's identity.
-type flagName struct {
-	long, short string
-	hidden      bool
-}
-
-// Candidate is a single suggested flag returned to the user when an
-// unknown flag is detected.
-type Candidate struct {
-	// Flag is the long-form spelling of the suggested flag, e.g. "--to".
-	Flag string `json:"flag"`
-	// Shorthand is the single-character shorthand (without the leading
-	// dash) when the suggested flag has one; empty otherwise.
-	Shorthand string `json:"shorthand,omitempty"`
-	// Distance is the Levenshtein edit distance to the unknown token.
-	// Zero indicates a bidirectional prefix hit (Reason == "prefix").
-	Distance int `json:"distance"`
-	// Reason explains how the candidate was matched: "prefix" for
-	// bidirectional prefix hits, "edit_distance" for fuzzy matches.
-	Reason string `json:"reason"`
-}
-
-// maxCandidates caps the number of suggestions returned per error so
-// the JSON envelope stays compact and the user-visible hint remains
-// scannable.
-const maxCandidates = 5
-
-// InstallOnMail attaches the unknown-flag fuzzy-match hook on the mail
-// service cobra parent command. It is invoked exactly once from
-// shortcuts/register.go inside the `service == "mail"` branch.
-//
-// Cobra's FlagErrorFunc walks up the parent chain looking for the nearest
-// non-nil hook, so every mail subcommand inherits this behaviour without
-// any per-shortcut wiring.
-func InstallOnMail(svc *cobra.Command) {
-	if svc == nil {
-		return
-	}
-	svc.SetFlagErrorFunc(flagSuggestErrorFunc)
-}
-
-// flagSuggestErrorFunc converts pflag's unknown-flag errors into a typed
-// validation error carrying candidate suggestions. Any other error is passed
-// through unchanged so cobra's existing handling kicks in.
-func flagSuggestErrorFunc(c *cobra.Command, err error) error {
-	if err == nil {
-		return nil
-	}
-	token, isShorthand, ok := parseUnknownToken(err.Error())
-	if !ok {
-		// Non unknown-flag errors (e.g. "required flag(s) ... not set")
-		// pass through to cmd/root.go::handleRootError's fallback path.
-		return err
-	}
-	names := collectFlags(c)
-	var matches []Candidate
-	if isShorthand {
-		matches = suggestShorthand(token, names)
-	} else {
-		matches = suggest(token, names)
-	}
-	// Normalise to a non-nil slice so the JSON envelope always emits
-	// `candidates: []` instead of `null`, keeping the wire shape stable
-	// for downstream parsers regardless of command-state.
-	if matches == nil {
-		matches = []Candidate{}
-	}
-	hint := buildHint(c, matches)
-	params := []errs.InvalidParam{{
-		Name:   rawUnknownToken(token, isShorthand),
-		Reason: "unknown flag",
-	}}
-	for _, match := range matches {
-		reason := fmt.Sprintf("candidate (%s, distance=%d)", match.Reason, match.Distance)
-		if match.Shorthand != "" {
-			reason += fmt.Sprintf(", shorthand=-%s", match.Shorthand)
-		}
-		params = append(params, errs.InvalidParam{Name: match.Flag, Reason: reason})
-	}
-	return errs.NewValidationError(errs.SubtypeInvalidArgument, err.Error()).
-		WithHint("%s", hint).
-		WithParam(rawUnknownToken(token, isShorthand)).
-		WithParams(params...)
-}
-
-// parseUnknownToken extracts the offending flag name from a pflag error
-// string. Recognised forms:
-//
-//   - "unknown flag: --tos"
-//   - "unknown flag: --bogus=val"
-//   - "unknown shorthand flag: 'X' in -Xyz"
-//
-// Anything else returns (_, _, false) so the caller can pass the error
-// through unchanged.
-func parseUnknownToken(errMsg string) (token string, isShorthand bool, ok bool) {
-	const longPrefix = "unknown flag: --"
-	const shortPrefix = "unknown shorthand flag: '"
-	switch {
-	case strings.HasPrefix(errMsg, longPrefix):
-		rest := errMsg[len(longPrefix):]
-		if eq := strings.IndexAny(rest, "= \t"); eq >= 0 {
-			rest = rest[:eq]
-		}
-		return rest, false, rest != ""
-	case strings.HasPrefix(errMsg, shortPrefix):
-		rest := errMsg[len(shortPrefix):]
-		end := strings.IndexByte(rest, '\'')
-		if end <= 0 {
-			return "", false, false
-		}
-		return rest[:end], true, true
-	}
-	return "", false, false
-}
-
-// rawUnknownToken re-attaches the leading dash(es) to a bare token so the
-// JSON envelope echoes the user-visible spelling.
-func rawUnknownToken(token string, isShorthand bool) string {
-	if isShorthand {
-		return "-" + token
-	}
-	return "--" + token
-}
-
-// collectFlags snapshots the merged local + persistent + inherited flag
-// set of cmd. The hidden bit is preserved on each entry; the suggest
-// helpers apply the actual filter so the slice stays reusable.
-func collectFlags(cmd *cobra.Command) []flagName {
-	if cmd == nil {
-		return nil
-	}
-	var out []flagName
-	cmd.Flags().VisitAll(func(f *pflag.Flag) {
-		out = append(out, flagName{long: f.Name, short: f.Shorthand, hidden: f.Hidden})
-	})
-	return out
-}
-
-// suggest produces top-N long-flag candidates for an unknown token, using
-// bidirectional prefix matching first and Levenshtein distance for the
-// remainder. Hidden flags and empty long names are skipped. Results are
-// stably sorted by (Distance asc, Flag asc) and capped at maxCandidates.
-func suggest(unknown string, names []flagName) []Candidate {
-	if unknown == "" || len(names) == 0 {
-		return nil
-	}
-	threshold := levThreshold(unknown)
-	out := make([]Candidate, 0, len(names))
-	seen := make(map[string]struct{}, len(names))
-
-	// Priority 1: bidirectional prefix match.
-	for _, n := range names {
-		if n.hidden || n.long == "" {
-			continue
-		}
-		if strings.HasPrefix(n.long, unknown) || strings.HasPrefix(unknown, n.long) {
-			out = append(out, Candidate{Flag: "--" + n.long, Shorthand: n.short, Distance: 0, Reason: "prefix"})
-			seen[n.long] = struct{}{}
-		}
-	}
-	// Priority 2: Levenshtein distance, skipping already-matched names.
-	for _, n := range names {
-		if n.hidden || n.long == "" {
-			continue
-		}
-		if _, ok := seen[n.long]; ok {
-			continue
-		}
-		if d := levenshtein(unknown, n.long); d <= threshold {
-			out = append(out, Candidate{Flag: "--" + n.long, Shorthand: n.short, Distance: d, Reason: "edit_distance"})
-		}
-	}
-	sort.SliceStable(out, func(i, j int) bool {
-		if out[i].Distance != out[j].Distance {
-			return out[i].Distance < out[j].Distance
-		}
-		return out[i].Flag < out[j].Flag
-	})
-	if len(out) > maxCandidates {
-		out = out[:maxCandidates]
-	}
-	return out
-}
-
-// suggestShorthand produces candidates for an unknown single-character
-// shorthand. It first looks for exact f.Shorthand matches; if there are
-// none, it falls back to long names that begin with the same character.
-// Levenshtein is deliberately not used here since single-char edit
-// distance would match almost every flag.
-func suggestShorthand(c string, names []flagName) []Candidate {
-	if c == "" || len(names) == 0 {
-		return nil
-	}
-	out := make([]Candidate, 0)
-	for _, n := range names {
-		if n.hidden {
-			continue
-		}
-		if n.short == c {
-			out = append(out, Candidate{Flag: "--" + n.long, Shorthand: n.short, Distance: 0, Reason: "prefix"})
-		}
-	}
-	if len(out) == 0 {
-		for _, n := range names {
-			if n.hidden || n.long == "" {
-				continue
-			}
-			if strings.HasPrefix(n.long, c) {
-				out = append(out, Candidate{Flag: "--" + n.long, Shorthand: n.short, Distance: 0, Reason: "prefix"})
-			}
-		}
-	}
-	sort.SliceStable(out, func(i, j int) bool { return out[i].Flag < out[j].Flag })
-	if len(out) > maxCandidates {
-		out = out[:maxCandidates]
-	}
-	return out
-}
-
-// buildHint returns a one-line hint suitable for a typed error's Hint field.
-// When at least one candidate exists, the top hit is named; otherwise
-// the user is directed to --help.
-func buildHint(c *cobra.Command, matches []Candidate) string {
-	if len(matches) == 0 {
-		return fmt.Sprintf("Run `%s --help` to view available flags", c.CommandPath())
-	}
-	return fmt.Sprintf("Did you mean: %s ?", matches[0].Flag)
-}
-
-// levThreshold returns the maximum acceptable Levenshtein distance for a
-// token of the given length, clamped to [1, 4].
-func levThreshold(s string) int {
-	t := len(s)/3 + 1
-	if t < 1 {
-		return 1
-	}
-	if t > 4 {
-		return 4
-	}
-	return t
-}
-
-// levenshtein computes the standard Levenshtein edit distance between
-// two ASCII strings using a 2-row dynamic-programming table.
-func levenshtein(a, b string) int {
-	la, lb := len(a), len(b)
-	if la == 0 {
-		return lb
-	}
-	if lb == 0 {
-		return la
-	}
-	prev := make([]int, lb+1)
-	curr := make([]int, lb+1)
-	for j := 0; j <= lb; j++ {
-		prev[j] = j
-	}
-	for i := 1; i <= la; i++ {
-		curr[0] = i
-		for j := 1; j <= lb; j++ {
-			cost := 1
-			if a[i-1] == b[j-1] {
-				cost = 0
-			}
-			curr[j] = min(curr[j-1]+1, prev[j]+1, prev[j-1]+cost)
-		}
-		prev, curr = curr, prev
-	}
-	return prev[lb]
-}

shortcuts/mail/flag_suggest_test.go

@@ -1,353 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package mail
-
-import (
-	"errors"
-	"testing"
-
-	"github.com/spf13/cobra"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"github.com/larksuite/cli/errs"
-)
-
-// --- suggest (long-flag) ---
-
-func TestSuggest_Prefix(t *testing.T) {
-	names := []flagName{
-		{long: "to", short: "t"},
-		{long: "cc"},
-		{long: "subject", short: "s"},
-	}
-	got := suggest("tos", names)
-	require.NotEmpty(t, got)
-	// "tos" has --to as a prefix → bidirectional prefix hit, Distance=0.
-	assert.Equal(t, "--to", got[0].Flag)
-	assert.Equal(t, 0, got[0].Distance)
-	assert.Equal(t, "prefix", got[0].Reason)
-}
-
-func TestSuggest_Levenshtein(t *testing.T) {
-	names := []flagName{
-		{long: "subject"},
-		{long: "body"},
-		{long: "to"},
-	}
-	// Distance 1 from "subject".
-	got := suggest("subjec", names)
-	require.NotEmpty(t, got)
-	// "subjec" is prefix of "subject" → bidirectional prefix.
-	assert.Equal(t, "--subject", got[0].Flag)
-	assert.Equal(t, "prefix", got[0].Reason)
-
-	// True edit-distance: "subjeect" is not a prefix either way of "subject".
-	got = suggest("subjeect", names)
-	require.NotEmpty(t, got)
-	assert.Equal(t, "--subject", got[0].Flag)
-	assert.Equal(t, "edit_distance", got[0].Reason)
-	assert.GreaterOrEqual(t, got[0].Distance, 1)
-}
-
-func TestSuggest_HiddenSkipped(t *testing.T) {
-	names := []flagName{
-		{long: "internal-debug", hidden: true},
-		{long: "interactive"},
-	}
-	got := suggest("internal", names)
-	for _, c := range got {
-		assert.NotEqual(t, "--internal-debug", c.Flag, "hidden flag must not appear in suggestions")
-	}
-}
-
-func TestSuggest_TopNAndStableSort(t *testing.T) {
-	// 6 names all within threshold and at the same distance (1) from the
-	// unknown token so that the lexicographic tiebreak and maxCandidates
-	// cap are both exercised. (Earlier the names were 3-distance from
-	// "zzz" which is above the threshold of 2 — suggest returned empty
-	// and the assertions trivially passed.)
-	names := []flagName{
-		{long: "aaab"},
-		{long: "aaac"},
-		{long: "aaad"},
-		{long: "aaae"},
-		{long: "aaaf"},
-		{long: "aaag"},
-	}
-	got := suggest("aaaa", names)
-	require.Len(t, got, maxCandidates, "must cap at maxCandidates")
-	// All distances equal → lex ordering by Flag asc, top 5 alphabetically.
-	wantFlags := []string{"--aaab", "--aaac", "--aaad", "--aaae", "--aaaf"}
-	gotFlags := []string{got[0].Flag, got[1].Flag, got[2].Flag, got[3].Flag, got[4].Flag}
-	assert.Equal(t, wantFlags, gotFlags, "tiebreak must order by Flag asc")
-}
-
-// --- suggestShorthand ---
-
-func TestSuggestShorthand_Exact(t *testing.T) {
-	names := []flagName{
-		{long: "to", short: "t"},
-		{long: "cc", short: "c"},
-		{long: "subject", short: "s"},
-	}
-	got := suggestShorthand("t", names)
-	require.NotEmpty(t, got)
-	assert.Equal(t, "--to", got[0].Flag)
-	assert.Equal(t, "t", got[0].Shorthand)
-	assert.Equal(t, "prefix", got[0].Reason)
-}
-
-func TestSuggestShorthand_PrefixFallback(t *testing.T) {
-	// No short matches "x"; fall back to long names starting with "x".
-	names := []flagName{
-		{long: "xargs"},
-		{long: "xterm"},
-		{long: "yargs"},
-	}
-	got := suggestShorthand("x", names)
-	require.NotEmpty(t, got)
-	flags := make([]string, 0, len(got))
-	for _, c := range got {
-		flags = append(flags, c.Flag)
-	}
-	assert.Contains(t, flags, "--xargs")
-	assert.Contains(t, flags, "--xterm")
-	assert.NotContains(t, flags, "--yargs")
-}
-
-// --- parseUnknownToken ---
-
-func TestParseUnknownToken_Long(t *testing.T) {
-	tok, isShort, ok := parseUnknownToken("unknown flag: --tos")
-	assert.True(t, ok)
-	assert.False(t, isShort)
-	assert.Equal(t, "tos", tok)
-
-	tok, isShort, ok = parseUnknownToken("unknown flag: --bogus=val")
-	assert.True(t, ok)
-	assert.False(t, isShort)
-	assert.Equal(t, "bogus", tok, "must strip =value tail")
-
-	tok, _, ok = parseUnknownToken("unknown flag: --bogus value")
-	assert.True(t, ok)
-	assert.Equal(t, "bogus", tok, "must strip whitespace tail")
-}
-
-func TestParseUnknownToken_Shorthand(t *testing.T) {
-	tok, isShort, ok := parseUnknownToken("unknown shorthand flag: 'X' in -X")
-	assert.True(t, ok)
-	assert.True(t, isShort)
-	assert.Equal(t, "X", tok)
-
-	tok, isShort, ok = parseUnknownToken("unknown shorthand flag: 'q' in -qrs")
-	assert.True(t, ok)
-	assert.True(t, isShort)
-	assert.Equal(t, "q", tok)
-}
-
-func TestParseUnknownToken_NotMatch(t *testing.T) {
-	cases := []string{
-		`required flag(s) "to" not set`,
-		"some unrelated error",
-		"",
-		"unknown command \"foo\" for \"mail\"",
-	}
-	for _, in := range cases {
-		tok, isShort, ok := parseUnknownToken(in)
-		assert.False(t, ok, "input %q must not match", in)
-		assert.False(t, isShort)
-		assert.Equal(t, "", tok)
-	}
-}
-
-// --- flagSuggestErrorFunc ---
-
-// newFakeMailCmd builds a cobra command tree resembling the mail parent
-// with a handful of flags exercised by the hook tests.
-func newFakeMailCmd() *cobra.Command {
-	c := &cobra.Command{Use: "mail"}
-	c.Flags().String("to", "", "recipients")
-	c.Flags().String("cc", "", "cc recipients")
-	c.Flags().String("subject", "", "subject")
-	c.Flags().StringP("body", "b", "", "body")
-	return c
-}
-
-func requireFlagSuggestValidation(t *testing.T, got error) *errs.ValidationError {
-	t.Helper()
-	var validationErr *errs.ValidationError
-	require.True(t, errors.As(got, &validationErr), "expected *errs.ValidationError, got %T", got)
-	p, ok := errs.ProblemOf(got)
-	require.True(t, ok, "expected typed Problem")
-	assert.Equal(t, errs.CategoryValidation, p.Category)
-	assert.Equal(t, errs.SubtypeInvalidArgument, p.Subtype)
-	return validationErr
-}
-
-func paramReason(params []errs.InvalidParam, name string) (string, bool) {
-	for _, p := range params {
-		if p.Name == name {
-			return p.Reason, true
-		}
-	}
-	return "", false
-}
-
-func TestFlagSuggestErrorFunc_LongUnknown_ReturnsTypedValidation(t *testing.T) {
-	cmd := newFakeMailCmd()
-	got := flagSuggestErrorFunc(cmd, errors.New("unknown flag: --tos"))
-
-	validationErr := requireFlagSuggestValidation(t, got)
-	assert.Equal(t, "unknown flag: --tos", validationErr.Message)
-	assert.Equal(t, "--tos", validationErr.Param)
-	assert.Contains(t, validationErr.Hint, "--to")
-
-	reason, ok := paramReason(validationErr.Params, "--tos")
-	require.True(t, ok, "unknown flag should be included in params")
-	assert.Equal(t, "unknown flag", reason)
-	reason, ok = paramReason(validationErr.Params, "--to")
-	require.True(t, ok, "expected --to in candidate params")
-	assert.Contains(t, reason, "candidate (prefix")
-}
-
-func TestFlagSuggestErrorFunc_NotUnknownFlag_PassesThrough(t *testing.T) {
-	cmd := newFakeMailCmd()
-	in := errors.New(`required flag(s) "to" not set`)
-	got := flagSuggestErrorFunc(cmd, in)
-	// Identity passthrough: same error pointer.
-	assert.Same(t, in, got, "non-unknown-flag errors must be returned unchanged")
-}
-
-func TestFlagSuggestErrorFunc_TypedCategoryAndSubtype(t *testing.T) {
-	cmd := newFakeMailCmd()
-	got := flagSuggestErrorFunc(cmd, errors.New("unknown flag: --tos"))
-	p, ok := errs.ProblemOf(got)
-	require.True(t, ok)
-	assert.Equal(t, errs.CategoryValidation, p.Category)
-	assert.Equal(t, errs.SubtypeInvalidArgument, p.Subtype)
-}
-
-// --- edge-case coverage ---
-
-func TestInstallOnMail_NilIsNoop(t *testing.T) {
-	// Must not panic; the nil-guard is the contract.
-	InstallOnMail(nil)
-}
-
-func TestInstallOnMail_InstallsHook(t *testing.T) {
-	c := newFakeMailCmd()
-	InstallOnMail(c)
-	require.NotNil(t, c.FlagErrorFunc())
-	got := c.FlagErrorFunc()(c, errors.New("unknown flag: --tos"))
-	validationErr := requireFlagSuggestValidation(t, got)
-	assert.Equal(t, "--tos", validationErr.Param)
-}
-
-func TestFlagSuggestErrorFunc_NilError(t *testing.T) {
-	cmd := newFakeMailCmd()
-	assert.NoError(t, flagSuggestErrorFunc(cmd, nil))
-}
-
-func TestFlagSuggestErrorFunc_LongUnknown_StripsValueTail(t *testing.T) {
-	cmd := newFakeMailCmd()
-	got := flagSuggestErrorFunc(cmd, errors.New("unknown flag: --tos=alice@example.com"))
-	validationErr := requireFlagSuggestValidation(t, got)
-	assert.Equal(t, "--tos", validationErr.Param, "value tail must be stripped before echoing")
-	reason, ok := paramReason(validationErr.Params, "--tos")
-	require.True(t, ok)
-	assert.Equal(t, "unknown flag", reason)
-}
-
-func TestFlagSuggestErrorFunc_ShorthandUnknown(t *testing.T) {
-	cmd := newFakeMailCmd()
-	got := flagSuggestErrorFunc(cmd, errors.New("unknown shorthand flag: 'b' in -bXY"))
-	validationErr := requireFlagSuggestValidation(t, got)
-	assert.Equal(t, "-b", validationErr.Param)
-	reason, ok := paramReason(validationErr.Params, "-b")
-	require.True(t, ok)
-	assert.Equal(t, "unknown flag", reason)
-	// newFakeMailCmd has --body/-b; exact shorthand hit expected.
-	reason, ok = paramReason(validationErr.Params, "--body")
-	require.True(t, ok)
-	assert.Contains(t, reason, "candidate (prefix")
-	assert.Contains(t, reason, "shorthand=-b")
-}
-
-func TestFlagSuggestErrorFunc_ParamsAlwaysPresent(t *testing.T) {
-	// A cobra command with no flags forces collectFlags → empty names →
-	// suggest → nil. The typed validation error must still expose the unknown
-	// flag in Params so downstream parsers have a stable structured field.
-	bare := &cobra.Command{Use: "mail"}
-	got := flagSuggestErrorFunc(bare, errors.New("unknown flag: --bogus"))
-	validationErr := requireFlagSuggestValidation(t, got)
-	assert.NotNil(t, validationErr.Params)
-	require.Len(t, validationErr.Params, 1)
-	assert.Equal(t, "--bogus", validationErr.Params[0].Name)
-	assert.Equal(t, "unknown flag", validationErr.Params[0].Reason)
-}
-
-func TestFlagSuggestErrorFunc_NoCandidatesUsesHelpHint(t *testing.T) {
-	cmd := newFakeMailCmd()
-	// Token with no plausible neighbor in {to, cc, subject, body}.
-	got := flagSuggestErrorFunc(cmd, errors.New("unknown flag: --zzzzzzz"))
-	validationErr := requireFlagSuggestValidation(t, got)
-	assert.Contains(t, validationErr.Hint, "--help")
-}
-
-func TestParseUnknownToken_EmptyAndMalformed(t *testing.T) {
-	// Long form with empty token after the prefix.
-	_, _, ok := parseUnknownToken("unknown flag: --")
-	assert.False(t, ok, "empty long token must not match")
-
-	// Shorthand with no closing quote.
-	_, _, ok = parseUnknownToken("unknown shorthand flag: 'q")
-	assert.False(t, ok, "shorthand without closing quote must not match")
-
-	// Shorthand with empty char between quotes.
-	_, _, ok = parseUnknownToken("unknown shorthand flag: '' in -")
-	assert.False(t, ok, "empty shorthand token must not match")
-}
-
-func TestSuggest_EmptyInputs(t *testing.T) {
-	assert.Nil(t, suggest("", []flagName{{long: "to"}}))
-	assert.Nil(t, suggest("foo", nil))
-}
-
-func TestSuggestShorthand_EmptyInputs(t *testing.T) {
-	assert.Nil(t, suggestShorthand("", []flagName{{long: "to", short: "t"}}))
-	assert.Nil(t, suggestShorthand("x", nil))
-}
-
-func TestSuggestShorthand_HiddenSkipped(t *testing.T) {
-	names := []flagName{
-		{long: "secret", short: "s", hidden: true},
-		{long: "subject", short: "s"},
-	}
-	got := suggestShorthand("s", names)
-	for _, c := range got {
-		assert.NotEqual(t, "--secret", c.Flag, "hidden shorthand must not be suggested")
-	}
-}
-
-func TestCollectFlags_NilSafe(t *testing.T) {
-	assert.Nil(t, collectFlags(nil))
-}
-
-func TestLevThreshold_Clamp(t *testing.T) {
-	// len 0 → 0/3+1 = 1
-	assert.Equal(t, 1, levThreshold(""))
-	// len 3 → 2
-	assert.Equal(t, 2, levThreshold("abc"))
-	// Long token caps at 4.
-	assert.Equal(t, 4, levThreshold("aaaaaaaaaaaaaaaaaaaa"))
-}
-
-func TestLevenshtein_EmptyAndIdentical(t *testing.T) {
-	assert.Equal(t, 0, levenshtein("", ""))
-	assert.Equal(t, 3, levenshtein("", "abc"))
-	assert.Equal(t, 3, levenshtein("abc", ""))
-	assert.Equal(t, 0, levenshtein("abc", "abc"))
-	assert.Equal(t, 1, levenshtein("abc", "abd"))
-}

shortcuts/mail/mail_json_shorthand_test.go

@@ -103,8 +103,8 @@ func TestMailTriageEnumRejectsUnknownFormat(t *testing.T) {
 	if ve.Param != "--format" {
 		t.Fatalf("param = %q, want --format", ve.Param)
 	}
-	if !strings.Contains(problem.Message, `invalid value "bogus" for --format`) {
-		t.Fatalf("message = %q, want enum validation message", problem.Message)
+	if !strings.Contains(problem.Message, `unsupported output format "bogus"`) {
+		t.Fatalf("message = %q, want unsupported format message", problem.Message)
 	}
 	if !strings.Contains(problem.Message, "table, json, data") {
 		t.Fatalf("message = %q, want allowed values list", problem.Message)

shortcuts/minutes/minutes_apply_permission.go

@@ -1,74 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package minutes
-
-import (
-	"context"
-	"fmt"
-	"net/http"
-	"strings"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/internal/validate"
-	"github.com/larksuite/cli/shortcuts/common"
-)
-
-// MinutesApplyPermission applies for view or edit permission on a minute.
-var MinutesApplyPermission = common.Shortcut{
-	Service:     "minutes",
-	Command:     "+apply-permission",
-	Description: "Apply for view or edit permission on a minute",
-	Risk:        "write",
-	Scopes:      []string{"minutes:permission:apply"},
-	AuthTypes:   []string{"user"},
-	Flags: []common.Flag{
-		{Name: "minute-token", Desc: "minute token", Required: true},
-		{Name: "perm", Desc: "permission to apply for", Required: true, Enum: []string{"view", "edit"}},
-	},
-	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		minuteToken := strings.TrimSpace(runtime.Str("minute-token"))
-		if minuteToken == "" {
-			return errs.NewValidationError(errs.SubtypeInvalidArgument, "--minute-token is required").WithParam("--minute-token")
-		}
-		if err := validate.ResourceName(minuteToken, "--minute-token"); err != nil {
-			return errs.NewValidationError(errs.SubtypeInvalidArgument, "%s", err).WithParam("--minute-token")
-		}
-		perm := strings.TrimSpace(runtime.Str("perm"))
-		if perm == "" {
-			return errs.NewValidationError(errs.SubtypeInvalidArgument, "--perm is required").WithParam("--perm")
-		}
-		return nil
-	},
-	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
-		minuteToken := strings.TrimSpace(runtime.Str("minute-token"))
-		return common.NewDryRunAPI().
-			POST(minutesApplyPermissionPath(minuteToken)).
-			Body(minutesApplyPermissionBody(runtime))
-	},
-	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		minuteToken := strings.TrimSpace(runtime.Str("minute-token"))
-		perm := strings.TrimSpace(runtime.Str("perm"))
-
-		_, err := runtime.CallAPITyped(http.MethodPost, minutesApplyPermissionPath(minuteToken), nil, map[string]interface{}{"perm": perm})
-		if err != nil {
-			return err
-		}
-
-		runtime.OutFormat(map[string]interface{}{
-			"minute_token": minuteToken,
-			"perm":         perm,
-		}, nil, nil)
-		return nil
-	},
-}
-
-func minutesApplyPermissionPath(minuteToken string) string {
-	return fmt.Sprintf("/open-apis/minutes/v1/minutes/%s/permissions/apply", validate.EncodePathSegment(minuteToken))
-}
-
-func minutesApplyPermissionBody(runtime *common.RuntimeContext) map[string]interface{} {
-	return map[string]interface{}{
-		"perm": strings.TrimSpace(runtime.Str("perm")),
-	}
-}

shortcuts/minutes/minutes_apply_permission_test.go

@@ -1,192 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package minutes
-
-import (
-	"encoding/json"
-	"errors"
-	"net/http"
-	"strings"
-	"testing"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/internal/cmdutil"
-	"github.com/larksuite/cli/internal/httpmock"
-	"github.com/spf13/cobra"
-)
-
-const minutesApplyPermissionTestToken = "obcnexampleminute"
-
-func TestMinutesApplyPermission_Validate(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	f, _, _, _ := cmdutil.TestFactory(t, defaultConfig())
-	tests := []struct {
-		name    string
-		args    []string
-		wantErr string
-	}{
-		{
-			name:    "missing minute token",
-			args:    []string{"+apply-permission", "--perm", "view", "--as", "user"},
-			wantErr: "required flag(s) \"minute-token\" not set",
-		},
-		{
-			name:    "missing perm",
-			args:    []string{"+apply-permission", "--minute-token", minutesApplyPermissionTestToken, "--as", "user"},
-			wantErr: "required flag(s) \"perm\" not set",
-		},
-		{
-			name:    "invalid perm",
-			args:    []string{"+apply-permission", "--minute-token", minutesApplyPermissionTestToken, "--perm", "full_access", "--as", "user"},
-			wantErr: "allowed: view, edit",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			parent := &cobra.Command{Use: "minutes"}
-			MinutesApplyPermission.Mount(parent, f)
-			parent.SetArgs(tt.args)
-			parent.SilenceErrors = true
-			parent.SilenceUsage = true
-			err := parent.Execute()
-			if err == nil {
-				t.Fatalf("expected error, got nil")
-			}
-			if !strings.Contains(err.Error(), tt.wantErr) {
-				t.Errorf("error should contain %q, got: %s", tt.wantErr, err.Error())
-			}
-		})
-	}
-}
-
-func TestMinutesApplyPermission_ValidateTypedMinuteToken(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	f, _, _, _ := cmdutil.TestFactory(t, defaultConfig())
-
-	parent := &cobra.Command{Use: "minutes"}
-	MinutesApplyPermission.Mount(parent, f)
-	parent.SetArgs([]string{"+apply-permission", "--minute-token", "..", "--perm", "view", "--as", "user"})
-	parent.SilenceErrors = true
-	parent.SilenceUsage = true
-	err := parent.Execute()
-	if err == nil {
-		t.Fatalf("expected error, got nil")
-	}
-	var ve *errs.ValidationError
-	if !errors.As(err, &ve) {
-		t.Fatalf("want *errs.ValidationError, got %T", err)
-	}
-	if ve.Subtype != errs.SubtypeInvalidArgument {
-		t.Errorf("subtype=%q", ve.Subtype)
-	}
-	if ve.Param != "--minute-token" {
-		t.Errorf("param=%q", ve.Param)
-	}
-}
-
-func TestMinutesApplyPermission_ValidateTypedPerm(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	f, _, _, _ := cmdutil.TestFactory(t, defaultConfig())
-
-	parent := &cobra.Command{Use: "minutes"}
-	MinutesApplyPermission.Mount(parent, f)
-	parent.SetArgs([]string{"+apply-permission", "--minute-token", minutesApplyPermissionTestToken, "--perm", "full_access", "--as", "user"})
-	parent.SilenceErrors = true
-	parent.SilenceUsage = true
-	err := parent.Execute()
-	if err == nil {
-		t.Fatalf("expected error, got nil")
-	}
-	var ve *errs.ValidationError
-	if !errors.As(err, &ve) {
-		t.Fatalf("want *errs.ValidationError, got %T", err)
-	}
-	if ve.Subtype != errs.SubtypeInvalidArgument {
-		t.Errorf("subtype=%q", ve.Subtype)
-	}
-	if ve.Param != "--perm" {
-		t.Errorf("param=%q", ve.Param)
-	}
-}
-
-func TestMinutesApplyPermission_DryRun(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	f, stdout, _, _ := cmdutil.TestFactory(t, defaultConfig())
-	warmTokenCache(t)
-
-	err := mountAndRun(t, MinutesApplyPermission, []string{
-		"+apply-permission",
-		"--minute-token", minutesApplyPermissionTestToken,
-		"--perm", "view",
-		"--dry-run", "--as", "user",
-	}, f, stdout)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	out := stdout.String()
-	if !strings.Contains(out, "POST") {
-		t.Errorf("expected POST method, got:\n%s", out)
-	}
-	if !strings.Contains(out, "/open-apis/minutes/v1/minutes/"+minutesApplyPermissionTestToken+"/permissions/apply") {
-		t.Errorf("expected apply-permission endpoint, got:\n%s", out)
-	}
-	if !strings.Contains(out, `"perm": "view"`) && !strings.Contains(out, `"perm":"view"`) {
-		t.Errorf("expected perm body, got:\n%s", out)
-	}
-}
-
-func TestMinutesApplyPermission_Execute(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	f, stdout, _, reg := cmdutil.TestFactory(t, defaultConfig())
-	warmTokenCache(t)
-
-	stub := &httpmock.Stub{
-		Method: http.MethodPost,
-		URL:    "/open-apis/minutes/v1/minutes/" + minutesApplyPermissionTestToken + "/permissions/apply",
-		Body: map[string]interface{}{
-			"code": 0,
-			"msg":  "ok",
-			"data": map[string]interface{}{},
-		},
-	}
-	reg.Register(stub)
-
-	err := mountAndRun(t, MinutesApplyPermission, []string{
-		"+apply-permission",
-		"--minute-token", minutesApplyPermissionTestToken,
-		"--perm", "edit",
-		"--format", "json", "--as", "user",
-	}, f, stdout)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	var requestBody struct {
-		Perm string `json:"perm"`
-	}
-	if err := json.Unmarshal(stub.CapturedBody, &requestBody); err != nil {
-		t.Fatalf("unmarshal request body: %v", err)
-	}
-	if requestBody.Perm != "edit" {
-		t.Errorf("request perm = %q, want edit", requestBody.Perm)
-	}
-
-	var envelope struct {
-		Data struct {
-			MinuteToken string `json:"minute_token"`
-			Perm        string `json:"perm"`
-		} `json:"data"`
-	}
-	if err := json.Unmarshal(stdout.Bytes(), &envelope); err != nil {
-		t.Fatalf("unmarshal stdout: %v", err)
-	}
-	if envelope.Data.MinuteToken != minutesApplyPermissionTestToken {
-		t.Errorf("data.minute_token = %q, want %q", envelope.Data.MinuteToken, minutesApplyPermissionTestToken)
-	}
-	if envelope.Data.Perm != "edit" {
-		t.Errorf("data.perm = %q, want edit", envelope.Data.Perm)
-	}
-}

shortcuts/minutes/minutes_detail.go

@@ -70,7 +70,7 @@ func fetchMinuteDetail(ctx context.Context, runtime *common.RuntimeContext, minu
 		if isMinutesDetailProcessingError(err) {
 			markMinutesDetailProcessing(result, minuteToken, artifactFlags, "minute metadata is still being generated")
 		} else if p, ok := errs.ProblemOf(err); ok && p.Code == minutesDetailNoReadPermissionCode {
-			result.Error = fmt.Sprintf("No read permission for minute %s. Ask the user before running: minutes +apply-permission --minute-token %s --perm view", minuteToken, minuteToken)
+			result.Error = fmt.Sprintf("No read permission for minute %s. Ask the minute owner for minute file read permission", minuteToken)
 		} else {
 			result.Error = fmt.Sprintf("failed to query minute: %v", err)
 		}

shortcuts/minutes/minutes_speaker_replace.go

@@ -135,7 +135,7 @@ func minutesSpeakerReplaceError(err error, minuteToken, sourceSpeaker string) er
 	switch p.Code {
 	case minutesSpeakerReplaceNoEditPermission:
 		p.Message = fmt.Sprintf("No edit permission for minute %q: cannot replace the transcript speaker.", minuteToken)
-		p.Hint = fmt.Sprintf("Ask the user before running: minutes +apply-permission --minute-token %s --perm edit", minuteToken)
+		p.Hint = "Ask the minute owner for minute edit permission"
 	case minutesSpeakerReplaceSpeakerNotFoundCode:
 		p.Subtype = errs.SubtypeNotFound
 		p.Message = fmt.Sprintf("Speaker not found in minute %q: source speaker %q does not match an existing speaker in the transcript.", minuteToken, sourceSpeaker)

shortcuts/minutes/minutes_speaker_replace_test.go

@@ -361,7 +361,7 @@ func TestMinutesSpeakerReplace_NoEditPermission(t *testing.T) {
 	if !strings.Contains(p.Message, minutesSpeakerReplaceTestToken) {
 		t.Errorf("message should include minute token, got: %s", p.Message)
 	}
-	if !strings.Contains(p.Hint, "+apply-permission") {
-		t.Errorf("hint should mention apply-permission, got: %s", p.Hint)
+	if !strings.Contains(p.Hint, "edit permission") {
+		t.Errorf("hint should mention edit permission, got: %s", p.Hint)
 	}
 }

shortcuts/minutes/minutes_summary_todo_test.go

@@ -400,8 +400,8 @@ func TestMinutesTodo_NoEditPermission(t *testing.T) {
 	if !strings.Contains(p.Message, minutesSummaryTodoTestToken) {
 		t.Errorf("message should include minute token, got: %s", p.Message)
 	}
-	if !strings.Contains(p.Hint, "+apply-permission") {
-		t.Errorf("hint should mention apply-permission, got: %s", p.Hint)
+	if !strings.Contains(p.Hint, "edit permission") {
+		t.Errorf("hint should mention edit permission, got: %s", p.Hint)
 	}
 }
 

shortcuts/minutes/minutes_todo.go

@@ -288,6 +288,6 @@ func minutesTodoError(err error, minuteToken string) error {
 	}
 	p.Subtype = errs.SubtypePermissionDenied
 	p.Message = fmt.Sprintf("No edit permission for minute %q: cannot update todos.", minuteToken)
-	p.Hint = fmt.Sprintf("Ask the user before running: minutes +apply-permission --minute-token %s --perm edit", minuteToken)
+	p.Hint = "Ask the minute owner for minute edit permission"
 	return err
 }

shortcuts/minutes/minutes_update.go

@@ -79,6 +79,6 @@ func minutesUpdateError(err error, minuteToken string) error {
 		return err
 	}
 	p.Message = fmt.Sprintf("No edit permission for minute %q: cannot update the title.", minuteToken)
-	p.Hint = fmt.Sprintf("Ask the user before running: minutes +apply-permission --minute-token %s --perm edit", minuteToken)
+	p.Hint = "Ask the minute owner for minute edit permission"
 	return err
 }

shortcuts/minutes/minutes_update_test.go

@@ -171,7 +171,7 @@ func TestMinutesUpdate_NoEditPermission(t *testing.T) {
 	if !strings.Contains(p.Message, minutesUpdateTestToken) {
 		t.Errorf("message should include minute token, got: %s", p.Message)
 	}
-	if !strings.Contains(p.Hint, "+apply-permission") {
-		t.Errorf("hint should mention apply-permission, got: %s", p.Hint)
+	if !strings.Contains(p.Hint, "edit permission") {
+		t.Errorf("hint should mention edit permission, got: %s", p.Hint)
 	}
 }

shortcuts/minutes/minutes_word_replace.go

@@ -139,7 +139,7 @@ func minutesWordReplaceError(err error, minuteToken string) error {
 	case minutesWordReplaceNoEditPermission:
 		p.Subtype = errs.SubtypePermissionDenied
 		p.Message = fmt.Sprintf("No edit permission for minute %q: cannot replace transcript words.", minuteToken)
-		p.Hint = fmt.Sprintf("Ask the user before running: minutes +apply-permission --minute-token %s --perm edit", minuteToken)
+		p.Hint = "Ask the minute owner for minute edit permission"
 	case minutesWordReplaceOthersEditing:
 		p.Subtype = errs.SubtypeConflict
 		p.Message = fmt.Sprintf("Minute %q transcript is being edited by someone else.", minuteToken)

shortcuts/minutes/shortcuts.go

@@ -12,7 +12,6 @@ func Shortcuts() []common.Shortcut {
 		MinutesDownload,
 		MinutesUpload,
 		MinutesUpdate,
-		MinutesApplyPermission,
 		MinutesSummary,
 		MinutesTodo,
 		MinutesSpeakerReplace,

shortcuts/register.go

@@ -157,9 +157,6 @@ func RegisterShortcutsWithContext(ctx context.Context, program *cobra.Command, f
 		if service == "apps" {
 			apps.InstallOnApps(svc, f)
 		}
-		if service == "mail" {
-			mail.InstallOnMail(svc)
-		}
 		if service == "sheets" {
 			applySheetsCompatGroups(svc)
 		}

shortcuts/register_test.go

@@ -7,14 +7,12 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"os"
 	"path/filepath"
 	"strings"
 	"testing"
 
-	"github.com/larksuite/cli/errs"
 	"github.com/larksuite/cli/internal/cmdmeta"
 	"github.com/larksuite/cli/internal/cmdutil"
 	"github.com/larksuite/cli/internal/core"
@@ -400,68 +398,6 @@ func TestRegisterShortcutsReusesExistingServiceCommand(t *testing.T) {
 	}
 }
 
-// TestRegisterShortcutsInstallsMailFlagSuggestHook is the end-to-end
-// wiring guard for the mail unknown-flag fuzzy-match feature: it ensures
-// the `if service == "mail" { mail.InstallOnMail(svc) }` branch in
-// RegisterShortcutsWithContext is actually exercised, so a future refactor
-// that drops the branch (or breaks the import) will fail this test rather
-// than silently regressing the structured-error contract.
-func TestRegisterShortcutsInstallsMailFlagSuggestHook(t *testing.T) {
-	program := &cobra.Command{Use: "root"}
-	RegisterShortcuts(program, newRegisterTestFactory(t))
-
-	mailCmd, _, err := program.Find([]string{"mail"})
-	if err != nil {
-		t.Fatalf("find mail command: %v", err)
-	}
-	if mailCmd == nil || mailCmd.Name() != "mail" {
-		t.Fatalf("mail command not mounted: %#v", mailCmd)
-	}
-
-	// The FlagErrorFunc lookup walks up to the nearest non-nil hook, so
-	// invoking it on the mail parent (or any of its children) must yield
-	// a typed validation problem for the unknown flag.
-	got := mailCmd.FlagErrorFunc()(mailCmd, errors.New("unknown flag: --bogus"))
-	var validationErr *errs.ValidationError
-	if !errors.As(got, &validationErr) {
-		t.Fatalf("expected *errs.ValidationError, got %T (%v)", got, got)
-	}
-	if validationErr.Param != "--bogus" {
-		t.Fatalf("expected Param=--bogus, got %q", validationErr.Param)
-	}
-	problem, ok := errs.ProblemOf(got)
-	if !ok {
-		t.Fatalf("expected typed problem, got %T (%v)", got, got)
-	}
-	if problem.Category != errs.CategoryValidation || problem.Subtype != errs.SubtypeInvalidArgument {
-		t.Fatalf("expected validation/invalid_argument, got %s/%s", problem.Category, problem.Subtype)
-	}
-}
-
-// TestRegisterShortcutsLeavesNonMailFlagErrorUntouched confirms the
-// install is scoped: a non-mail service must keep the default cobra
-// pass-through behaviour, otherwise an accidental fall-through in
-// register.go would silently change every domain's error envelope.
-func TestRegisterShortcutsLeavesNonMailFlagErrorUntouched(t *testing.T) {
-	program := &cobra.Command{Use: "root"}
-	RegisterShortcuts(program, newRegisterTestFactory(t))
-
-	baseCmd, _, err := program.Find([]string{"base"})
-	if err != nil {
-		t.Fatalf("find base command: %v", err)
-	}
-	in := errors.New("unknown flag: --bogus")
-	got := baseCmd.FlagErrorFunc()(baseCmd, in)
-	// Default cobra hook is identity — anything else means the mail hook
-	// (which wraps into a typed *errs.ValidationError) leaked across domains.
-	if errs.IsTyped(got) {
-		t.Fatalf("base service unexpectedly produced a typed error: %#v", got)
-	}
-	if got != in {
-		t.Fatalf("base service should pass through original error pointer, got %T (%v)", got, got)
-	}
-}
-
 func TestGenerateShortcutsJSON(t *testing.T) {
 	output := os.Getenv("SHORTCUTS_OUTPUT")
 	if output == "" {

shortcuts/sheets/flag_ergonomics.go

@@ -4,16 +4,12 @@
 package sheets
 
 import (
-	"fmt"
 	"slices"
-	"sort"
 	"strings"
 
-	"github.com/larksuite/cli/errs"
 	"github.com/larksuite/cli/internal/suggest"
 	"github.com/larksuite/cli/shortcuts/common"
 	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
 )
 
 // ─── sheets flag ergonomics ─────────────────────────────────────────────
@@ -28,106 +24,17 @@ import (
 // needs no change at all and no other domain's behavior shifts.
 
 // withFlagErgonomics wraps an optional PostMount so that, after it runs,
-// the command gets the sheets-specific unknown-flag error (valid flags
-// inlined) and enum-value normalization (canonical vocabulary auto-applied,
-// typos suggested).
+// the command gets enum-value normalization. Unknown-flag handling is owned by
+// cmd/root.go's single FlagErrorFunc, which retains the sheets inline flag list.
 func withFlagErgonomics(prev func(cmd *cobra.Command)) func(cmd *cobra.Command) {
 	return func(cmd *cobra.Command) {
 		if prev != nil {
 			prev(cmd)
 		}
-		cmd.SetFlagErrorFunc(sheetsFlagErrorFunc)
 		chainEnumNormalization(cmd)
 	}
 }
 
-// sheetsFlagErrorFunc overrides the root FlagErrorFunc for sheets commands.
-// It keeps the root behavior (typed error, did-you-mean suggestions, the
-// offending flag on params) and additionally inlines the full valid-flag
-// set: hallucinated sheets flags are usually semantic guesses (--cols for
-// --range) that edit distance can't rank, and a --help round trip costs an
-// agent a full extra call. One line here lets it re-issue the command
-// immediately.
-func sheetsFlagErrorFunc(c *cobra.Command, ferr error) error {
-	name, isUnknown := unknownFlagFromParseError(ferr)
-	if !isUnknown {
-		return common.ValidationErrorf("%s", ferr.Error()).
-			WithHint("run `%s --help` for valid flags", c.CommandPath())
-	}
-	valid := visibleFlagNames(c)
-	suggestions := suggest.Closest(name, valid, 3)
-	for i := range suggestions {
-		suggestions[i] = "--" + suggestions[i]
-	}
-	hint := fmt.Sprintf("run `%s --help` to see valid flags", c.CommandPath())
-	if list := inlineFlagList(valid); list != "" {
-		hint = "valid flags: " + list
-		if len(suggestions) > 0 {
-			hint = fmt.Sprintf("did you mean %s? valid flags: %s",
-				strings.Join(suggestions, ", "), list)
-		}
-	}
-	return errs.NewValidationError(errs.SubtypeInvalidArgument,
-		"unknown flag %q for %q", "--"+name, c.CommandPath()).
-		WithParams(errs.InvalidParam{Name: "--" + name, Reason: "unknown flag", Suggestions: suggestions}).
-		WithHint("%s", hint)
-}
-
-// unknownFlagFromParseError extracts the offending long-flag name from
-// cobra's flag-parse error text ("unknown flag: --query" → "query").
-// Returns ok=false for anything else (missing argument, invalid value,
-// unknown shorthand) so those stay structured but generic. Mirrors the
-// root-level parser in cmd; the prefix contract is cobra's English wording.
-func unknownFlagFromParseError(err error) (string, bool) {
-	const p = "unknown flag: --"
-	msg := err.Error()
-	i := strings.Index(msg, p)
-	if i < 0 {
-		return "", false
-	}
-	rest := msg[i+len(p):]
-	if j := strings.IndexAny(rest, " \t"); j >= 0 {
-		rest = rest[:j]
-	}
-	return rest, true
-}
-
-// visibleFlagNames lists the non-hidden flag names registered on c, sorted.
-func visibleFlagNames(c *cobra.Command) []string {
-	var names []string
-	c.Flags().VisitAll(func(f *pflag.Flag) {
-		if !f.Hidden {
-			names = append(names, f.Name)
-		}
-	})
-	sort.Strings(names)
-	return names
-}
-
-// inlineFlagListLimit caps how many flag names ride inline on an
-// unknown-flag hint. Sheets shortcuts stay well under it.
-const inlineFlagListLimit = 25
-
-// inlineFlagList renders valid flag names as one comma-separated line for
-// the unknown-flag hint, truncating past inlineFlagListLimit. Empty when
-// there is nothing to list.
-func inlineFlagList(names []string) string {
-	if len(names) == 0 {
-		return ""
-	}
-	shown := names
-	var suffix string
-	if len(names) > inlineFlagListLimit {
-		shown = names[:inlineFlagListLimit]
-		suffix = fmt.Sprintf(", … (%d more; see --help)", len(names)-inlineFlagListLimit)
-	}
-	parts := make([]string, len(shown))
-	for i, n := range shown {
-		parts[i] = "--" + n
-	}
-	return strings.Join(parts, ", ") + suffix
-}
-
 // ─── enum vocabulary normalization ──────────────────────────────────────
 
 // enumAliases maps habitual values agents import from CSS / Excel / Google

shortcuts/sheets/flag_ergonomics_test.go

@@ -5,7 +5,6 @@ package sheets
 
 import (
 	"errors"
-	"fmt"
 	"strings"
 	"testing"
 
@@ -14,122 +13,6 @@ import (
 	"github.com/spf13/cobra"
 )
 
-func TestUnknownFlagFromParseError(t *testing.T) {
-	t.Parallel()
-	cases := []struct {
-		in   string
-		name string
-		ok   bool
-	}{
-		{"unknown flag: --cols", "cols", true},
-		{"unknown flag: --with-styles", "with-styles", true},
-		{"unknown shorthand flag: 'z' in -z", "", false},
-		{"flag needs an argument: --find", "", false},
-		{`invalid argument "x" for "--count"`, "", false},
-	}
-	for _, c := range cases {
-		name, ok := unknownFlagFromParseError(errors.New(c.in))
-		if name != c.name || ok != c.ok {
-			t.Errorf("unknownFlagFromParseError(%q) = (%q,%v), want (%q,%v)", c.in, name, ok, c.name, c.ok)
-		}
-	}
-}
-
-// TestSheetsFlagErrorFunc_SemanticGuessListsValidFlags pins the sheets
-// override of the root unknown-flag error: --cols is a semantic guess for
-// --range that edit distance can't rank, so the hint must inline the full
-// valid-flag list instead of deferring to a --help round trip.
-func TestSheetsFlagErrorFunc_SemanticGuessListsValidFlags(t *testing.T) {
-	t.Parallel()
-	c := &cobra.Command{Use: "demo"}
-	c.Flags().String("range", "", "")
-	c.Flags().Int("width", 0, "")
-
-	err := sheetsFlagErrorFunc(c, errors.New("unknown flag: --cols"))
-	var verr *errs.ValidationError
-	if !errors.As(err, &verr) {
-		t.Fatalf("expected *errs.ValidationError, got %T", err)
-	}
-	if verr.Subtype != errs.SubtypeInvalidArgument {
-		t.Errorf("subtype = %q, want invalid_argument", verr.Subtype)
-	}
-	if len(verr.Params) != 1 || verr.Params[0].Name != "--cols" {
-		t.Errorf("Params = %v, want one entry named --cols", verr.Params)
-	}
-	if strings.Contains(verr.Hint, "--help") {
-		t.Errorf("hint should not defer to --help when flags fit inline, got %q", verr.Hint)
-	}
-	for _, want := range []string{"--range", "--width"} {
-		if !strings.Contains(verr.Hint, want) {
-			t.Errorf("hint should inline valid flag %s, got %q", want, verr.Hint)
-		}
-	}
-}
-
-// TestSheetsFlagErrorFunc_TypoKeepsSuggestion pins that the root behavior
-// (did-you-mean suggestion, machine-readable Suggestions) is preserved by
-// the sheets override, with the valid-flag list appended.
-func TestSheetsFlagErrorFunc_TypoKeepsSuggestion(t *testing.T) {
-	t.Parallel()
-	c := &cobra.Command{Use: "demo"}
-	c.Flags().String("range", "", "")
-	c.Flags().Bool("dry-run", false, "")
-
-	err := sheetsFlagErrorFunc(c, errors.New("unknown flag: --rang"))
-	var verr *errs.ValidationError
-	if !errors.As(err, &verr) {
-		t.Fatalf("expected *errs.ValidationError, got %T", err)
-	}
-	found := false
-	for _, s := range verr.Params[0].Suggestions {
-		if s == "--range" {
-			found = true
-		}
-	}
-	if !found {
-		t.Errorf("Suggestions should include --range, got %v", verr.Params[0].Suggestions)
-	}
-	for _, want := range []string{"did you mean", "--range", "--dry-run"} {
-		if !strings.Contains(verr.Hint, want) {
-			t.Errorf("hint should contain %q, got %q", want, verr.Hint)
-		}
-	}
-}
-
-func TestSheetsFlagErrorFunc_OtherErrorStaysGeneric(t *testing.T) {
-	t.Parallel()
-	c := &cobra.Command{Use: "demo"}
-	err := sheetsFlagErrorFunc(c, errors.New("flag needs an argument: --find"))
-	var verr *errs.ValidationError
-	if !errors.As(err, &verr) {
-		t.Fatalf("expected *errs.ValidationError, got %T", err)
-	}
-	if verr.Param != "" || len(verr.Params) != 0 {
-		t.Errorf("Param=%q Params=%v, want both empty for generic flag error", verr.Param, verr.Params)
-	}
-	if strings.Contains(verr.Hint, "did you mean") {
-		t.Errorf("generic flag error must not produce a did-you-mean hint, got %q", verr.Hint)
-	}
-}
-
-func TestInlineFlagList_TruncatesPastLimit(t *testing.T) {
-	t.Parallel()
-	if got := inlineFlagList(nil); got != "" {
-		t.Errorf("inlineFlagList(nil) = %q, want empty", got)
-	}
-	names := make([]string, inlineFlagListLimit+5)
-	for i := range names {
-		names[i] = fmt.Sprintf("flag-%02d", i)
-	}
-	got := inlineFlagList(names)
-	if !strings.Contains(got, "5 more") || !strings.Contains(got, "--help") {
-		t.Errorf("truncated list should count the overflow and defer to --help, got %q", got)
-	}
-	if strings.Contains(got, names[inlineFlagListLimit]) {
-		t.Errorf("list should stop at the limit, got %q", got)
-	}
-}
-
 func TestCanonicalEnumValue(t *testing.T) {
 	t.Parallel()
 	cases := []struct {
@@ -278,19 +161,4 @@ func TestShortcuts_FlagErgonomicsMounted(t *testing.T) {
 		}
 	})
 
-	t.Run("unknown flag inlines valid flags", func(t *testing.T) {
-		t.Parallel()
-		sc := shortcutFromRegistry(t, "+cols-resize")
-		_, _, err := runShortcutCapturingErr(t, sc, []string{
-			"--url", testURL,
-			"--sheet-name", "s",
-			"--cols", "A:D",
-		})
-		ve := requireValidation(t, err, `unknown flag "--cols"`)
-		for _, want := range []string{"valid flags:", "--range", "--width", "--widths"} {
-			if !strings.Contains(ve.Hint, want) {
-				t.Errorf("hint should contain %q, got %q", want, ve.Hint)
-			}
-		}
-	})
 }

shortcuts/slides/slides_screenshot.go

@@ -22,10 +22,7 @@ import (
 	"github.com/larksuite/cli/shortcuts/common"
 )
 
-const (
-	defaultSlidesScreenshotDir = ".lark-slides/screenshots"
-	maxSlidesPerScreenshot     = 10
-)
+const defaultSlidesScreenshotDir = ".lark-slides/screenshots"
 
 var unsafeScreenshotFileCharRegex = regexp.MustCompile(`[^A-Za-z0-9._-]+`)
 
@@ -35,7 +32,7 @@ var unsafeScreenshotFileCharRegex = regexp.MustCompile(`[^A-Za-z0-9._-]+`)
 var SlidesScreenshot = common.Shortcut{
 	Service:     "slides",
 	Command:     "+screenshot",
-	Description: "Save up to 10 slide screenshots to local files without printing Base64 image data",
+	Description: "Save slide screenshots to local files without printing Base64 image data",
 	Risk:        "read",
 	Scopes:      []string{},
 	// The screenshot API is allowlist-gated for only a few apps, so do not
@@ -45,8 +42,8 @@ var SlidesScreenshot = common.Shortcut{
 	AuthTypes:         []string{"user", "bot"},
 	Flags: []common.Flag{
 		{Name: "presentation", Desc: "xml_presentation_id, slides URL, or wiki URL that resolves to slides; list mode only"},
-		{Name: "slide-id", Type: "string_array", Desc: "slide page identifier (repeat for multiple slides; max 10 pages per request)"},
-		{Name: "slide-number", Type: "int_array", Desc: "slide page number (repeat for multiple slides; max 10 pages per request)"},
+		{Name: "slide-id", Type: "string_array", Desc: "slide page identifier (repeat for multiple slides)"},
+		{Name: "slide-number", Type: "int_array", Desc: "slide page number (repeat for multiple slides)"},
 		{Name: "content", Desc: "slide XML content to render directly instead of fetching existing slides", Input: []string{common.File, common.Stdin}},
 		{Name: "output-dir", Default: defaultSlidesScreenshotDir, Desc: "relative directory for saved screenshots"},
 		{Name: "output-name", Desc: "file name stem for --content render output"},
@@ -73,17 +70,12 @@ var SlidesScreenshot = common.Shortcut{
 					return err
 				}
 			}
-			slideIDs := normalizeSlideIDs(runtime.StrArray("slide-id"))
-			slideNumbers, err := normalizeSlideNumbers(runtime.IntArray("slide-number"))
-			if err != nil {
+			if _, err := normalizeSlideNumbers(runtime.IntArray("slide-number")); err != nil {
 				return err
 			}
-			if len(slideIDs) == 0 && len(slideNumbers) == 0 {
+			if !hasSlideScreenshotSelector(runtime) {
 				return slidesScreenshotFlagErrorf("--slide-id or --slide-number is required")
 			}
-			if err := validateSlidesScreenshotSelectorLimit(len(slideIDs) + len(slideNumbers)); err != nil {
-				return err
-			}
 		}
 		if _, err := validateScreenshotOutputDir(runtime, runtime.Str("output-dir")); err != nil {
 			return err
@@ -106,9 +98,6 @@ var SlidesScreenshot = common.Shortcut{
 		if len(slideIDs) == 0 && len(slideNumbers) == 0 {
 			return common.NewDryRunAPI().Set("error", "--slide-id or --slide-number is required")
 		}
-		if err := validateSlidesScreenshotSelectorLimit(len(slideIDs) + len(slideNumbers)); err != nil {
-			return common.NewDryRunAPI().Set("error", err.Error())
-		}
 
 		presentationID := ref.Token
 		dry := common.NewDryRunAPI()
@@ -156,9 +145,6 @@ var SlidesScreenshot = common.Shortcut{
 		if len(slideIDs) == 0 && len(slideNumbers) == 0 {
 			return slidesScreenshotFlagErrorf("--slide-id or --slide-number is required")
 		}
-		if err := validateSlidesScreenshotSelectorLimit(len(slideIDs) + len(slideNumbers)); err != nil {
-			return err
-		}
 		outputDir := runtime.Str("output-dir")
 		safeOutputDir, err := ensureScreenshotOutputDir(runtime, outputDir)
 		if err != nil {
@@ -281,12 +267,8 @@ func normalizeSlideNumbers(values []int) ([]int, error) {
 	return out, nil
 }
 
-func validateSlidesScreenshotSelectorLimit(count int) error {
-	if count > maxSlidesPerScreenshot {
-		return errs.NewValidationError(errs.SubtypeInvalidArgument, "too many slide selectors: got %d, maximum is %d", count, maxSlidesPerScreenshot).
-			WithHint("request at most 10 pages at a time")
-	}
-	return nil
+func hasSlideScreenshotSelector(runtime *common.RuntimeContext) bool {
+	return len(normalizeSlideIDs(runtime.StrArray("slide-id"))) > 0 || len(runtime.IntArray("slide-number")) > 0
 }
 
 func slidesScreenshotFlagErrorf(format string, args ...interface{}) error {

shortcuts/slides/slides_screenshot_test.go

@@ -271,37 +271,6 @@ func TestSlidesScreenshotListRequiresSelector(t *testing.T) {
 	}
 }
 
-func TestSlidesScreenshotListRejectsMoreThanTenSelectors(t *testing.T) {
-	f, stdout, _, _ := cmdutil.TestFactory(t, slidesTestConfig(t, ""))
-
-	err := runSlidesShortcut(t, f, stdout, SlidesScreenshot, []string{
-		"+screenshot",
-		"--presentation", "pres_abc",
-		"--slide-number", "1",
-		"--slide-number", "2",
-		"--slide-number", "3",
-		"--slide-number", "4",
-		"--slide-number", "5",
-		"--slide-number", "6",
-		"--slide-number", "7",
-		"--slide-number", "8",
-		"--slide-number", "9",
-		"--slide-number", "10",
-		"--slide-number", "11",
-		"--as", "user",
-	})
-	if err == nil {
-		t.Fatal("expected error")
-	}
-	problem, ok := errs.ProblemOf(err)
-	if !ok {
-		t.Fatalf("error = %v, want typed validation error", err)
-	}
-	if problem.Hint != "request at most 10 pages at a time" {
-		t.Fatalf("hint = %q, want max 10 pages guidance", problem.Hint)
-	}
-}
-
 func TestSlidesScreenshotRenderContentWritesFile(t *testing.T) {
 	dir := t.TempDir()
 	withSlidesTestWorkingDir(t, dir)