chore: add PPE headers and pin miaoda-cli alpha for testing

AGENTS.md

@@ -105,20 +105,6 @@ Signatures that are easy to guess wrong:
 
 Program output (JSON envelopes) goes to stdout. Progress, warnings, hints go to stderr. Mixing them corrupts pipe chains.
 
-### Typed data over loose maps
-
-Parse `map[string]interface{}` into a typed struct at the boundary — one projection function per shape — and let everything downstream consume struct fields, not string keys. A typo'd map key compiles fine and fails at runtime, which an agent then debugs blind.
-
-Use distinct types when two values could be swapped silently: see `internal/meta.Token` — a bare string compiles on either side of a string/string signature, a distinct type does not.
-
-Legacy loose-map code exists in older paths. Match its call sites when touching it, but do not copy the pattern into new code.
-
-### Transcribe faithfully — no silent fallbacks
-
-When code echoes input onward (request previews, transformations, proxies), transcribe verbatim. A `default:` branch that coerces unrecognized input into a plausible value ("unknown HTTP verb → GET") makes the output lie, and an agent reasons from the lie.
-
-The same rule applies to flag combinations and internal wiring: if a requested option cannot be honored, return a typed validation error — never silently substitute another behavior and exit 0. Silent guesses (defaulting a missing identity, discarding writes on a nil writer) are bugs even when every current caller happens to avoid them.
-
 ### Use `vfs.*` instead of `os.*`
 
 All filesystem access goes through `internal/vfs`. This enables test mocking.
@@ -130,7 +116,6 @@ CLI arguments are untrusted (they come from AI agents). Call `validate.SafeInput
 ### Tests
 
 - Every behavior change needs a test alongside the change.
-- A contract test must fail if the implementation is reverted. If you can undo the code change and the suite stays green, the contract is not pinned — assert the new field/behavior directly, not a happy-path substring.
 - `cmdutil.TestFactory(t, config)` for test factories.
 - `t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())` to isolate config state.
 

CHANGELOG.md

@@ -2,37 +2,6 @@
 
 All notable changes to this project will be documented in this file.
 
-## [v1.0.69] - 2026-07-13
-
-### Features
-
-- support docs fetch selection anchors (#1815)
-- **apps**: support modern_html app type with TOS publish path and app type querying
-- **im**: show bot sender display names when reading messages (#1829)
-- add drive list comments shortcut (#1845)
-- support wiki sources in drive export (#1802)
-- add application domain with slash command management shortcuts (#1806)
-- validate IM idempotency key length (#1797)
-- surface reply context and mentions in im.message.receive_v1 (#1798)
-
-### Bug Fixes
-
-- route brand-sensitive endpoints through the resolver (#1836)
-
-### Documentation
-
-- document OKR block XML guidance (#1648)
-- refine doubao whiteboard workflow routing (#1841)
-- clarify Mindnote token handling (#1827)
-
-### Tests
-
-- isolate semantic waiver fixtures from wall clock
-
-### Misc
-
-- Merge lark sheets development branch (#1833)
-
 ## [v1.0.68] - 2026-07-09
 
 ### Features
@@ -1469,7 +1438,6 @@ Bundled AI agent skills for intelligent assistance:
 - Bilingual documentation (English & Chinese).
 - CI/CD pipelines: linting, testing, coverage reporting, and automated releases.
 
-[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
 [v1.0.66]: https://github.com/larksuite/cli/releases/tag/v1.0.66

cmd/api/api.go

@@ -130,13 +130,6 @@ func buildAPIRequest(opts *APIOptions) (client.RawApiRequest, *cmdutil.FileUploa
 	stdin := opts.Factory.IOStreams.In
 	fileIO := opts.Factory.ResolveFileIO(opts.Ctx)
 
-	if opts.Method == "" {
-		return client.RawApiRequest{}, nil, errs.NewValidationError(errs.SubtypeInvalidArgument,
-			"HTTP method must not be empty").
-			WithHint("pass the verb as the first argument, e.g. lark-cli api GET /open-apis/...").
-			WithParam("<method>")
-	}
-
 	// Validate --file mutual exclusions first.
 	if err := cmdutil.ValidateFileFlag(opts.File, opts.Params, opts.Data, opts.Output, opts.PageAll, opts.Method); err != nil {
 		return client.RawApiRequest{}, nil, err
@@ -250,9 +243,9 @@ func apiRun(opts *APIOptions) error {
 
 	if opts.DryRun {
 		if fileMeta != nil {
-			return cmdutil.PrintDryRunWithFile(request, config, dryRunOutputOptions(f, opts), *fileMeta)
+			return cmdutil.PrintDryRunWithFile(f.IOStreams.Out, request, config, opts.Format, fileMeta.FieldName, fileMeta.FilePath, fileMeta.FormFields)
 		}
-		return apiDryRun(f, request, config, opts)
+		return apiDryRun(f, request, config, opts.Format)
 	}
 	// Identity info is now included in the JSON envelope; skip stderr printing.
 	// cmdutil.PrintIdentity(f.IOStreams.ErrOut, opts.As, config, f.IdentityAutoDetected)
@@ -304,19 +297,8 @@ func apiRun(opts *APIOptions) error {
 	return nil
 }
 
-func apiDryRun(f *cmdutil.Factory, request client.RawApiRequest, config *core.CliConfig, opts *APIOptions) error {
-	return cmdutil.PrintDryRun(request, config, dryRunOutputOptions(f, opts))
-}
-
-func dryRunOutputOptions(f *cmdutil.Factory, opts *APIOptions) cmdutil.DryRunOutputOptions {
-	return cmdutil.DryRunOutputOptions{
-		Format:      opts.Format,
-		JqExpr:      opts.JqExpr,
-		CommandPath: opts.Cmd.CommandPath(),
-		Identity:    opts.As,
-		Out:         f.IOStreams.Out,
-		ErrOut:      f.IOStreams.ErrOut,
-	}
+func apiDryRun(f *cmdutil.Factory, request client.RawApiRequest, config *core.CliConfig, format string) error {
+	return cmdutil.PrintDryRun(f.IOStreams.Out, request, config, format)
 }
 
 func apiPaginate(ctx context.Context, ac *client.APIClient, request client.RawApiRequest, format output.Format, jqExpr string, out, errOut io.Writer, commandPath string, pagOpts client.PaginationOptions) error {

cmd/api/api_test.go

@@ -69,7 +69,7 @@ func TestApiCmd_FlagParsing(t *testing.T) {
 }
 
 func TestApiCmd_DryRun(t *testing.T) {
-	f, stdout, stderr, _ := cmdutil.TestFactory(t, &core.CliConfig{
+	f, stdout, _, _ := cmdutil.TestFactory(t, &core.CliConfig{
 		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
 	})
 
@@ -79,42 +79,12 @@ func TestApiCmd_DryRun(t *testing.T) {
 	if err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
-	var got map[string]interface{}
-	if err := json.Unmarshal(stdout.Bytes(), &got); err != nil {
-		t.Fatalf("dry-run stdout is not JSON: %v\nstdout:\n%s\nstderr:\n%s", err, stdout.String(), stderr.String())
+	output := stdout.String()
+	if !strings.Contains(output, "Dry Run") {
+		t.Error("expected dry run output")
 	}
-	if got["ok"] != true || got["identity"] != "bot" || got["dry_run"] != true {
-		t.Fatalf("unexpected dry-run envelope: %#v", got)
-	}
-	data, ok := got["data"].(map[string]interface{})
-	if !ok {
-		t.Fatalf("data = %#v, want object", got["data"])
-	}
-	api, ok := data["api"].([]interface{})
-	if !ok || len(api) != 1 {
-		t.Fatalf("api = %#v, want one call", data["api"])
-	}
-	call, ok := api[0].(map[string]interface{})
-	if !ok || call["url"] != "/open-apis/test" {
-		t.Fatalf("api[0] = %#v", api[0])
-	}
-	if strings.Contains(stdout.String(), "=== Dry Run ===") {
-		t.Fatalf("stdout should not contain dry-run banner: %s", stdout.String())
-	}
-}
-
-func TestApiCmd_DryRunWithJq(t *testing.T) {
-	f, stdout, _, _ := cmdutil.TestFactory(t, &core.CliConfig{
-		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
-	})
-
-	cmd := newTestApiCmd(f, nil)
-	cmd.SetArgs([]string{"GET", "/open-apis/test", "--as", "bot", "--dry-run", "--jq", ".data.api[0].url"})
-	if err := cmd.Execute(); err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if got := strings.TrimSpace(stdout.String()); got != "/open-apis/test" {
-		t.Fatalf("jq output = %q, want /open-apis/test", got)
+	if !strings.Contains(output, "/open-apis/test") {
+		t.Error("expected path in dry run output")
 	}
 }
 
@@ -182,22 +152,6 @@ func TestApiCmd_MissingArgs(t *testing.T) {
 	}
 }
 
-func TestApiCmd_EmptyMethodRejected(t *testing.T) {
-	f, _, _, _ := cmdutil.TestFactory(t, &core.CliConfig{
-		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
-	})
-
-	cmd := newTestApiCmd(f, nil)
-	cmd.SetArgs([]string{"", "/open-apis/test", "--as", "bot", "--dry-run"})
-	err := cmd.Execute()
-	if err == nil {
-		t.Fatal("expected validation error for empty HTTP method")
-	}
-	if !strings.Contains(err.Error(), "method") {
-		t.Fatalf("error should name the method argument, got: %v", err)
-	}
-}
-
 func TestApiCmd_InvalidParamsJSON(t *testing.T) {
 	f, _, _, _ := cmdutil.TestFactory(t, &core.CliConfig{
 		AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu,
@@ -1046,23 +1000,11 @@ func TestApiCmd_DryRunWithFile(t *testing.T) {
 		t.Fatalf("unexpected error: %v", err)
 	}
 	out := stdout.String()
-	var env map[string]interface{}
-	if err := json.Unmarshal(stdout.Bytes(), &env); err != nil {
-		t.Fatalf("dry-run stdout is not JSON: %v\n%s", err, out)
+	if !strings.Contains(out, "image") {
+		t.Errorf("expected dry-run output to mention file field, got: %s", out)
 	}
-	if env["dry_run"] != true {
-		t.Fatalf("dry_run = %#v, want true", env["dry_run"])
-	}
-	data := env["data"].(map[string]interface{})
-	api := data["api"].([]interface{})
-	call := api[0].(map[string]interface{})
-	body := call["body"].(map[string]interface{})
-	file := body["file"].(map[string]interface{})
-	if file["field"] != "image" || file["path"] != tmpFile {
-		t.Fatalf("unexpected file dry-run body: %#v", body)
-	}
-	if strings.Contains(out, "=== Dry Run ===") {
-		t.Fatalf("stdout should not contain dry-run banner: %s", out)
+	if !strings.Contains(out, "Dry Run") {
+		t.Errorf("expected dry-run header, got: %s", out)
 	}
 }
 

cmd/auth/login_messages.go

@@ -128,5 +128,5 @@ func getLoginMsg(lang i18n.Lang) *loginMsg {
 // (not backed by from_meta service specs). Descriptions are now centralized in
 // service_descriptions.json.
 func getShortcutOnlyDomainNames() []string {
-	return []string{"application", "base", "contact", "docs", "markdown", "apps", "note"}
+	return []string{"base", "contact", "docs", "markdown", "apps", "note"}
 }

cmd/dispatch_golden_test.go

@@ -1,70 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package cmd
-
-import (
-	"bytes"
-	"errors"
-	"fmt"
-	"testing"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/extension/envelope"
-	"github.com/larksuite/cli/internal/cmdutil"
-	"github.com/larksuite/cli/internal/output"
-)
-
-// TestDispatchErrorGoldenParity asserts the public envelope.DispatchError
-// triple is byte-identical to what the real root dispatcher
-// (handleRootError) writes to stderr, with the same exit code, for every
-// error class (spec G1-G6). Comparison happens at the dispatch boundary:
-// need_user_authorization hint folding runs before dispatch and is not part
-// of the public contract, so cases here must not depend on it.
-func TestDispatchErrorGoldenParity(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-
-	cases := []struct {
-		name string
-		err  error
-	}{
-		{"G1_typed_validation", errs.NewValidationError(errs.SubtypeInvalidArgument, "missing --id")},
-		{"G2_typed_extension_fields", &errs.PermissionError{
-			Problem: errs.Problem{
-				Category: errs.CategoryAuthorization,
-				Subtype:  errs.SubtypePermissionDenied,
-				Code:     99991679,
-				Message:  "missing required scopes",
-				Hint:     "re-auth with the listed scopes",
-			},
-			MissingScopes: []string{"im:message", "docs:doc"},
-			Identity:      "user",
-		}},
-		{"G3_confirmation_required", errs.NewConfirmationRequiredError(
-			"high-risk-write", "drive +delete", "drive +delete requires confirmation")},
-		{"G4_partial_failure", output.PartialFailure(1)},
-		{"G5_cobra_usage", fmt.Errorf(`required flag(s) "values" not set`)},
-		{"G6_leaked_untyped", errors.New("boom")},
-	}
-
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			f, _, _, _ := cmdutil.TestFactory(t, nil)
-			errOut := &bytes.Buffer{}
-			f.IOStreams.ErrOut = errOut
-
-			realExit := handleRootError(f, tc.err)
-			env, code, has := envelope.DispatchError(tc.err, string(f.ResolvedIdentity))
-
-			if code != realExit {
-				t.Errorf("exit code: public %d, real dispatcher %d", code, realExit)
-			}
-			if has != (errOut.Len() > 0) {
-				t.Errorf("hasEnvelope=%v but real stderr len=%d", has, errOut.Len())
-			}
-			if !bytes.Equal(env, errOut.Bytes()) {
-				t.Errorf("envelope bytes differ\npublic:  %s\nreal:    %s", env, errOut.Bytes())
-			}
-		})
-	}
-}

cmd/event/schema_test.go

@@ -96,40 +96,6 @@ func TestRunSchema_JSONOutput(t *testing.T) {
 	}
 }
 
-func TestRunSchema_ReceiveMessageAgentFieldsJSON(t *testing.T) {
-	f, stdout, _, _ := cmdutil.TestFactory(t, &core.CliConfig{AppID: "test"})
-
-	if err := runSchema(f, "im.message.receive_v1", true); err != nil {
-		t.Fatalf("runSchema json: %v", err)
-	}
-
-	var payload map[string]interface{}
-	if err := json.Unmarshal(stdout.Bytes(), &payload); err != nil {
-		t.Fatalf("output is not valid JSON: %v\n%s", err, stdout.String())
-	}
-	resolved := payload["resolved_output_schema"].(map[string]interface{})
-	props := resolved["properties"].(map[string]interface{})
-	for _, field := range []string{
-		"root_id",
-		"thread_id",
-		"reply_to",
-		"sender_type",
-		"mentions",
-	} {
-		if _, ok := props[field]; !ok {
-			t.Errorf("receive schema missing field %q", field)
-		}
-	}
-	msgDesc := props["message_id"].(map[string]interface{})["description"].(string)
-	if !strings.Contains(msgDesc, "Recommended idempotency key") {
-		t.Errorf("message_id description should guide deduplication, got %q", msgDesc)
-	}
-	eventDesc := props["event_id"].(map[string]interface{})["description"].(string)
-	if strings.Contains(eventDesc, "safe for deduplication") {
-		t.Errorf("event_id description should not recommend deduplication, got %q", eventDesc)
-	}
-}
-
 func TestRunSchema_TaskUpdateUserAccessJSON(t *testing.T) {
 	f, stdout, _, _ := cmdutil.TestFactory(t, &core.CliConfig{AppID: "test"})
 

cmd/root.go

@@ -5,6 +5,7 @@ package cmd
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"os"
 	"sort"
@@ -228,25 +229,109 @@ func configureFlagCompletions(args []string) {
 }
 
 // handleRootError dispatches a command error to the appropriate handler
-// and returns the process exit code. The classification itself (typed
-// envelope vs. PartialFailure/Bare signal vs. cobra-usage vs. leaked-untyped)
-// lives in output.DispatchError so the public extension/envelope facade
-// shares the exact same branches — see its doc comment for the dispatch
-// order.
+// and returns the process exit code.
+//
+// Dispatch order:
+//  1. Typed errors from errs/ (e.g. *errs.PermissionError, *errs.APIError,
+//     *errs.SecurityPolicyError, *errs.AuthenticationError, *errs.ConfigError):
+//     render via the typed envelope writer, which lifts extension fields
+//     (missing_scopes, console_url, challenge_url, ...) to the top level.
+//     Routed by errs.CategoryOf via ExitCodeOf. Auth and config errors are
+//     constructed typed at their origin (internal/auth, internal/core), so the
+//     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.
 func handleRootError(f *cmdutil.Factory, err error) int {
+	errOut := f.IOStreams.ErrOut
+
 	// When the typed error is a need_user_authorization signal, fold in the
-	// current command's declared scopes as a Hint. The hint depends on the
-	// Factory, so it stays in the cmd layer — it is applied before dispatch
-	// and is not part of the public DispatchError contract.
+	// current command's declared scopes as a Hint so the user/AI sees the
+	// concrete scope(s) to re-auth with. The hint is computed on the fly from
+	// local shortcut/service metadata — it never depends on server state.
 	if !errs.IsRaw(err) {
 		applyNeedAuthorizationHint(f, err)
 	}
-	env, code, has := output.DispatchError(err, string(f.ResolvedIdentity))
-	if has {
-		// Best-effort write: a torn stderr must not downgrade the typed exit.
-		_, _ = f.IOStreams.ErrOut.Write(env)
+
+	// Staged dispatch: capture the typed exit code BEFORE attempting the
+	// envelope write. WriteTypedErrorEnvelope is best-effort on the wire
+	// (partial-write still returns true) so the exit code we read here is
+	// preserved even if stderr is torn — torn stderr must not downgrade
+	// typed exits 3/4/6/10 to the plain "Error:" path with exit 1.
+	// WriteTypedErrorEnvelope still returns false when err carries no
+	// Problem; in that case we fall through to the signal / plain-text paths.
+	typedExit := output.ExitCodeOf(err)
+	if output.WriteTypedErrorEnvelope(errOut, err, string(f.ResolvedIdentity)) {
+		return typedExit
 	}
-	return code
+
+	// Partial-failure (batch / multi-status): the ok:false result envelope is
+	// already on stdout; set the exit code and write nothing to stderr.
+	var pfErr *output.PartialFailureError
+	if errors.As(err, &pfErr) {
+		return pfErr.Code
+	}
+
+	// Silent-exit signal (e.g. `auth check` predicate, or `update --json`):
+	// stdout already carries the result; honor the requested exit code and
+	// write nothing to stderr.
+	var bareErr *output.BareError
+	if errors.As(err, &bareErr) {
+		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)
+	}
+	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

cmd/service/service.go

@@ -403,9 +403,9 @@ func serviceMethodRun(opts *ServiceMethodOptions) error {
 
 	if opts.DryRun {
 		if fileMeta != nil {
-			return cmdutil.PrintDryRunWithFile(request, config, serviceDryRunOutputOptions(f, opts), *fileMeta)
+			return cmdutil.PrintDryRunWithFile(f.IOStreams.Out, request, config, opts.Format, fileMeta.FieldName, fileMeta.FilePath, fileMeta.FormFields)
 		}
-		return serviceDryRun(f, request, config, opts)
+		return serviceDryRun(f, request, config, opts.Format)
 	}
 
 	if opts.Method.Risk == cmdutil.RiskHighRiskWrite {
@@ -667,19 +667,8 @@ func buildServiceRequest(opts *ServiceMethodOptions) (client.RawApiRequest, *cmd
 	return request, nil, nil
 }
 
-func serviceDryRun(f *cmdutil.Factory, request client.RawApiRequest, config *core.CliConfig, opts *ServiceMethodOptions) error {
-	return cmdutil.PrintDryRun(request, config, serviceDryRunOutputOptions(f, opts))
-}
-
-func serviceDryRunOutputOptions(f *cmdutil.Factory, opts *ServiceMethodOptions) cmdutil.DryRunOutputOptions {
-	return cmdutil.DryRunOutputOptions{
-		Format:      opts.Format,
-		JqExpr:      opts.JqExpr,
-		CommandPath: opts.Cmd.CommandPath(),
-		Identity:    opts.As,
-		Out:         f.IOStreams.Out,
-		ErrOut:      f.IOStreams.ErrOut,
-	}
+func serviceDryRun(f *cmdutil.Factory, request client.RawApiRequest, config *core.CliConfig, format string) error {
+	return cmdutil.PrintDryRun(f.IOStreams.Out, request, config, format)
 }
 
 func servicePaginate(ctx context.Context, ac *client.APIClient, request client.RawApiRequest, format output.Format, jqExpr string, out, errOut io.Writer, commandPath string, pagOpts client.PaginationOptions, checkErr func(interface{}, core.Identity) error) error {

cmd/service/service_test.go

@@ -224,39 +224,13 @@ func TestServiceMethod_DryRun_PathParam(t *testing.T) {
 			if err := cmd.Execute(); err != nil {
 				t.Fatalf("unexpected error: %v", err)
 			}
-			var got map[string]interface{}
-			if err := json.Unmarshal(stdout.Bytes(), &got); err != nil {
-				t.Fatalf("dry-run stdout is not JSON: %v\n%s", err, stdout.String())
-			}
-			if got["ok"] != true || got["dry_run"] != true {
-				t.Fatalf("unexpected dry-run envelope: %#v", got)
-			}
-			data := got["data"].(map[string]interface{})
-			api := data["api"].([]interface{})
-			call := api[0].(map[string]interface{})
-			if call["url"] != tt.wantInURL {
-				t.Errorf("url = %q, want %q\nstdout:\n%s", call["url"], tt.wantInURL, stdout.String())
+			if !strings.Contains(stdout.String(), tt.wantInURL) {
+				t.Errorf("expected URL containing %q, got:\n%s", tt.wantInURL, stdout.String())
 			}
 		})
 	}
 }
 
-func TestServiceMethod_DryRunWithJq(t *testing.T) {
-	f, stdout, _, _ := cmdutil.TestFactory(t, testConfig)
-	cmd := NewCmdServiceMethod(f, driveSpec(), driveMethod("GET", nil), "get", "files", nil)
-	cmd.SetArgs([]string{
-		"--params", `{"file_token":"boxcn123abc"}`,
-		"--dry-run",
-		"--jq", ".data.api[0].url",
-	})
-	if err := cmd.Execute(); err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if got, want := strings.TrimSpace(stdout.String()), "/open-apis/drive/v1/files/boxcn123abc/copy"; got != want {
-		t.Fatalf("jq output = %q, want %q", got, want)
-	}
-}
-
 func TestServiceMethod_PathParamRejectsTraversal(t *testing.T) {
 	tests := []struct {
 		name      string
@@ -344,12 +318,8 @@ func TestServiceMethod_PaginationParamSkippedWithPageAll(t *testing.T) {
 	if err != nil {
 		t.Fatalf("expected no error with --page-all skipping page_size, got: %v", err)
 	}
-	var got map[string]interface{}
-	if err := json.Unmarshal(stdout.Bytes(), &got); err != nil {
-		t.Fatalf("dry-run stdout is not JSON: %v\n%s", err, stdout.String())
-	}
-	if got["dry_run"] != true {
-		t.Fatalf("dry_run = %#v, want true", got["dry_run"])
+	if !strings.Contains(stdout.String(), "Dry Run") {
+		t.Error("expected dry-run output")
 	}
 }
 
@@ -1111,23 +1081,11 @@ func TestServiceMethod_FileUpload_DryRun(t *testing.T) {
 		t.Fatalf("unexpected error: %v", err)
 	}
 	out := stdout.String()
-	var env map[string]interface{}
-	if err := json.Unmarshal(stdout.Bytes(), &env); err != nil {
-		t.Fatalf("dry-run stdout is not JSON: %v\n%s", err, out)
+	if !strings.Contains(out, "image") {
+		t.Errorf("expected dry-run output to mention file field, got: %s", out)
 	}
-	if env["dry_run"] != true {
-		t.Fatalf("dry_run = %#v, want true", env["dry_run"])
-	}
-	data := env["data"].(map[string]interface{})
-	api := data["api"].([]interface{})
-	call := api[0].(map[string]interface{})
-	body := call["body"].(map[string]interface{})
-	file := body["file"].(map[string]interface{})
-	if file["field"] != "image" || file["path"] != tmpFile {
-		t.Fatalf("unexpected file dry-run body: %#v", body)
-	}
-	if strings.Contains(out, "=== Dry Run ===") {
-		t.Fatalf("stdout should not contain dry-run banner: %s", out)
+	if !strings.Contains(out, "Dry Run") {
+		t.Errorf("expected dry-run header, got: %s", out)
 	}
 }
 

events/im/message_receive.go

@@ -13,29 +13,17 @@ import (
 
 // ImMessageReceiveOutput is the flattened shape for im.message.receive_v1; `desc` tags drive the reflected schema.
 type ImMessageReceiveOutput struct {
-	Type        string          `json:"type"                   desc:"Event type; always im.message.receive_v1"`
-	EventID     string          `json:"event_id,omitempty"     desc:"Event delivery ID. Do not use as the message deduplication key; use message_id instead."`
-	Timestamp   string          `json:"timestamp,omitempty"    desc:"Event delivery time (ms timestamp string); prefers header.create_time"                                                                                                              kind:"timestamp_ms"`
-	ID          string          `json:"id,omitempty"           desc:"Message ID (legacy alias of message_id, kept for compatibility)"                                                                                                                     kind:"message_id"`
-	MessageID   string          `json:"message_id,omitempty"   desc:"Message ID; prefixed with om_. Recommended idempotency key for im.message.receive_v1 consumers."                                                                                     kind:"message_id"`
-	CreateTime  string          `json:"create_time,omitempty"  desc:"Message creation time (ms timestamp string)"                                                                                                                                         kind:"timestamp_ms"`
-	UpdateTime  string          `json:"update_time,omitempty"  desc:"Message update time (ms timestamp string); emitted only when different from create_time"                                                                                              kind:"timestamp_ms"`
-	ChatID      string          `json:"chat_id,omitempty"      desc:"Chat/conversation ID; prefixed with oc_"                                                                                                                                             kind:"chat_id"`
-	ChatType    string          `json:"chat_type,omitempty"    desc:"Conversation type"                                                                                                                                                                   enum:"p2p,group"`
-	MessageType string          `json:"message_type,omitempty" desc:"Message type"`
-	SenderID    string          `json:"sender_id,omitempty"    desc:"Sender open_id; prefixed with ou_"                                                                                                                                                   kind:"open_id"`
-	SenderType  string          `json:"sender_type,omitempty"  desc:"Sender type"                                                                                                                                                                         enum:"user,bot"`
-	RootID      string          `json:"root_id,omitempty"      desc:"Root message ID of the reply/thread context, when present"                                                                                                                           kind:"message_id"`
-	ThreadID    string          `json:"thread_id,omitempty"    desc:"Thread ID, when present"`
-	ReplyTo     string          `json:"reply_to,omitempty"     desc:"Parent message ID of the direct reply context, when present"                                                                                                                         kind:"message_id"`
-	Content     string          `json:"content,omitempty"      desc:"Message content. For most types (text/post/image/file/audio, etc.) this is pre-rendered human-readable text."`
-	Mentions    []MentionOutput `json:"mentions,omitempty" desc:"Compact mentions aligned with im +messages-mget"`
-}
-
-type MentionOutput struct {
-	Key  string `json:"key,omitempty"  desc:"Mention placeholder key, for example @_user_1"`
-	ID   string `json:"id,omitempty"   desc:"Mentioned user open_id; prefixed with ou_"        kind:"open_id"`
-	Name string `json:"name,omitempty" desc:"Mentioned display name"`
+	Type        string `json:"type"                   desc:"Event type; always im.message.receive_v1"`
+	EventID     string `json:"event_id,omitempty"     desc:"Globally unique event ID; safe for deduplication"`
+	Timestamp   string `json:"timestamp,omitempty"    desc:"Event delivery time (ms timestamp string); prefers header.create_time"                                                                                                              kind:"timestamp_ms"`
+	ID          string `json:"id,omitempty"           desc:"Message ID (legacy alias of message_id, kept for compatibility)"                                                                                                                     kind:"message_id"`
+	MessageID   string `json:"message_id,omitempty"   desc:"Message ID; prefixed with om_"                                                                                                                                                       kind:"message_id"`
+	CreateTime  string `json:"create_time,omitempty"  desc:"Message creation time (ms timestamp string)"                                                                                                                                         kind:"timestamp_ms"`
+	ChatID      string `json:"chat_id,omitempty"      desc:"Chat/conversation ID; prefixed with oc_"                                                                                                                                             kind:"chat_id"`
+	ChatType    string `json:"chat_type,omitempty"    desc:"Conversation type"                                                                                                                                                                   enum:"p2p,group"`
+	MessageType string `json:"message_type,omitempty" desc:"Message type"`
+	SenderID    string `json:"sender_id,omitempty"    desc:"Sender open_id; prefixed with ou_"                                                                                                                                                   kind:"open_id"`
+	Content     string `json:"content,omitempty"      desc:"Message content. For most types (text/post/image/file/audio, etc.) this is pre-rendered human-readable text."`
 }
 
 func processImMessageReceive(_ context.Context, _ event.APIClient, raw *event.RawEvent, _ map[string]string) (json.RawMessage, error) {
@@ -48,20 +36,15 @@ func processImMessageReceive(_ context.Context, _ event.APIClient, raw *event.Ra
 		Event struct {
 			Message struct {
 				MessageID   string        `json:"message_id"`
-				RootID      string        `json:"root_id"`
-				ParentID    string        `json:"parent_id"`
-				ThreadID    string        `json:"thread_id"`
 				ChatID      string        `json:"chat_id"`
 				ChatType    string        `json:"chat_type"`
 				MessageType string        `json:"message_type"`
 				Content     string        `json:"content"`
 				CreateTime  string        `json:"create_time"`
-				UpdateTime  string        `json:"update_time"`
 				Mentions    []interface{} `json:"mentions"`
 			} `json:"message"`
 			Sender struct {
-				SenderType string `json:"sender_type"`
-				SenderID   struct {
+				SenderID struct {
 					OpenID string `json:"open_id"`
 				} `json:"sender_id"`
 			} `json:"sender"`
@@ -98,54 +81,7 @@ func processImMessageReceive(_ context.Context, _ event.APIClient, raw *event.Ra
 		ChatType:    msg.ChatType,
 		MessageType: msg.MessageType,
 		SenderID:    envelope.Event.Sender.SenderID.OpenID,
-		SenderType:  envelope.Event.Sender.SenderType,
-		RootID:      msg.RootID,
-		ThreadID:    msg.ThreadID,
-		ReplyTo:     msg.ParentID,
 		Content:     content,
-		Mentions:    compactMentions(msg.Mentions),
-	}
-	if msg.UpdateTime != "" && msg.UpdateTime != msg.CreateTime {
-		out.UpdateTime = msg.UpdateTime
 	}
 	return json.Marshal(out)
 }
-
-func compactMentions(mentions []interface{}) []MentionOutput {
-	if len(mentions) == 0 {
-		return nil
-	}
-	out := make([]MentionOutput, 0, len(mentions))
-	for _, raw := range mentions {
-		item, _ := raw.(map[string]interface{})
-		mention := MentionOutput{
-			Key:  stringField(item, "key"),
-			ID:   mentionOpenID(item["id"]),
-			Name: stringField(item, "name"),
-		}
-		if mention.Key != "" || mention.ID != "" || mention.Name != "" {
-			out = append(out, mention)
-		}
-	}
-	if len(out) == 0 {
-		return nil
-	}
-	return out
-}
-
-func stringField(m map[string]interface{}, key string) string {
-	v, _ := m[key].(string)
-	return v
-}
-
-func mentionOpenID(raw interface{}) string {
-	switch v := raw.(type) {
-	case map[string]interface{}:
-		openID, _ := v["open_id"].(string)
-		return openID
-	case string:
-		return v
-	default:
-		return ""
-	}
-}

events/im/message_receive_test.go

@@ -84,32 +84,19 @@ func TestProcessImMessageReceive_Text(t *testing.T) {
 		},
 		"event": {
 			"sender": {
-				"sender_type": "user",
 				"sender_id": {"open_id": "ou_sender"}
 			},
 			"message": {
 				"message_id":   "om_text_001",
-				"root_id":      "om_root_001",
-				"parent_id":    "om_parent_001",
-				"thread_id":    "omt_thread_001",
 				"chat_id":      "oc_chat",
 				"chat_type":    "p2p",
 				"message_type": "text",
 				"create_time":  "1776409468987",
-				"update_time":  "1776409469999",
-				"content":      "{\"text\":\"hello @_user_1\"}",
-				"mentions": [
-					{
-						"key": "@_user_1",
-						"id": {"open_id": "ou_mentioned"},
-						"name": "Alice"
-					}
-				]
+				"content":      "{\"text\":\"hello there\"}"
 			}
 		}
 	}`
 	out := runReceive(t, payload)
-	outMap := runReceiveMap(t, payload)
 
 	if out.Type != "im.message.receive_v1" {
 		t.Errorf("Type = %q", out.Type)
@@ -123,69 +110,12 @@ func TestProcessImMessageReceive_Text(t *testing.T) {
 	if out.SenderID != "ou_sender" {
 		t.Errorf("SenderID = %q", out.SenderID)
 	}
-	if out.Content != "hello @Alice" {
-		t.Errorf("Content = %q, want \"hello @Alice\"", out.Content)
+	if out.Content != "hello there" {
+		t.Errorf("Content = %q, want \"hello there\"", out.Content)
 	}
 	if out.Timestamp != "1776409469273" {
 		t.Errorf("Timestamp = %q", out.Timestamp)
 	}
-	for field, want := range map[string]string{
-		"sender_type": "user",
-		"root_id":     "om_root_001",
-		"thread_id":   "omt_thread_001",
-		"reply_to":    "om_parent_001",
-		"update_time": "1776409469999",
-	} {
-		if got, _ := outMap[field].(string); got != want {
-			t.Errorf("%s = %q, want %q", field, got, want)
-		}
-	}
-	mentions, _ := outMap["mentions"].([]interface{})
-	if len(mentions) != 1 {
-		t.Fatalf("mentions length = %d, want 1: %#v", len(mentions), outMap["mentions"])
-	}
-	mention, _ := mentions[0].(map[string]interface{})
-	for field, want := range map[string]string{
-		"key":  "@_user_1",
-		"id":   "ou_mentioned",
-		"name": "Alice",
-	} {
-		if got, _ := mention[field].(string); got != want {
-			t.Errorf("mentions[0].%s = %q, want %q", field, got, want)
-		}
-	}
-}
-
-func TestProcessImMessageReceive_OmitsUnchangedUpdateTime(t *testing.T) {
-	payload := `{
-		"schema": "2.0",
-		"header": {
-			"event_id": "ev_test_text",
-			"event_type": "im.message.receive_v1",
-			"create_time": "1776409469273",
-			"app_id": "cli_test"
-		},
-		"event": {
-			"sender": {
-				"sender_type": "user",
-				"sender_id": {"open_id": "ou_sender"}
-			},
-			"message": {
-				"message_id":   "om_text_001",
-				"chat_id":      "oc_chat",
-				"chat_type":    "p2p",
-				"message_type": "text",
-				"create_time":  "1776409468987",
-				"update_time":  "1776409468987",
-				"content":      "{\"text\":\"hello there\"}"
-			}
-		}
-	}`
-	outMap := runReceiveMap(t, payload)
-
-	if _, ok := outMap["update_time"]; ok {
-		t.Errorf("update_time should be omitted when it equals create_time: %#v", outMap)
-	}
 }
 
 func TestProcessImMessageReceive_Interactive(t *testing.T) {
@@ -258,22 +188,3 @@ func runReceive(t *testing.T, payload string) ImMessageReceiveOutput {
 	}
 	return out
 }
-
-func runReceiveMap(t *testing.T, payload string) map[string]interface{} {
-	t.Helper()
-	raw := &event.RawEvent{
-		EventID:   "ev_test",
-		EventType: "im.message.receive_v1",
-		Payload:   json.RawMessage(payload),
-		Timestamp: time.Now(),
-	}
-	got, err := processImMessageReceive(context.Background(), nil, raw, nil)
-	if err != nil {
-		t.Fatalf("Process error: %v", err)
-	}
-	var out map[string]interface{}
-	if err := json.Unmarshal(got, &out); err != nil {
-		t.Fatalf("Process output is not valid JSON: %v\nraw=%s", err, string(got))
-	}
-	return out
-}

extension/apimeta/apimeta.go

@@ -1,42 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-// Package apimeta lets Go module integrators install embedded API metadata
-// for this process, equivalent to the meta_data.json that official lark-cli
-// builds compile in via go:embed.
-//
-// Binaries built from the bare Go module embed only an empty metadata stub,
-// so schema resolution and generated service commands have nothing to work
-// with offline. Integrators that ship their own metadata (typically embedded
-// into their binary with their own go:embed directive) call SetEmbedded at
-// process start to make the CLI treat those bytes as the compiled-in
-// metadata, with no behavioral difference from an official build.
-package apimeta
-
-import "github.com/larksuite/cli/internal/registry"
-
-// ErrAlreadyLoaded reports that SetEmbedded was called after the embedded
-// metadata had already been parsed, so the injection was rejected. Use
-// errors.Is(err, ErrAlreadyLoaded) to detect it.
-var ErrAlreadyLoaded = registry.ErrMetaAlreadyLoaded
-
-// SetEmbedded installs data as this process's embedded API metadata.
-//
-// It must be called before any registry consumption — cmd.Build, cmd.Execute,
-// schema resolution, or scope discovery — typically at the top of main() or
-// from an init() function — early enough provided no other init in the process
-// has already triggered registry consumption. Calling it after the metadata has
-// been parsed returns ErrAlreadyLoaded.
-//
-// data must parse as lark-cli API metadata and declare at least one service;
-// otherwise an error is returned and the existing state (the empty stub, or
-// the compiled-in metadata of an official build) is left unchanged.
-//
-// data is copied on success; the caller may reuse or modify the buffer afterwards.
-//
-// Calling SetEmbedded multiple times before the first parse is allowed: the last
-// successful call wins, mirroring ordinary Go process-init trust — whoever
-// links code into the binary controls its metadata.
-func SetEmbedded(data []byte) error {
-	return registry.SetEmbeddedMeta(data)
-}

extension/apimeta/apimeta_test.go

@@ -1,30 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package apimeta_test
-
-import (
-	"errors"
-	"testing"
-
-	"github.com/larksuite/cli/extension/apimeta"
-	"github.com/larksuite/cli/internal/registry"
-)
-
-// A1: 非法数据经门脸返回错误，且不是 ErrAlreadyLoaded
-func TestSetEmbedded_InvalidDataRejected(t *testing.T) {
-	err := apimeta.SetEmbedded([]byte(`{"broken`))
-	if err == nil {
-		t.Fatalf("SetEmbedded(invalid) = nil, want error")
-	}
-	if errors.Is(err, apimeta.ErrAlreadyLoaded) {
-		t.Fatalf("SetEmbedded(invalid) = ErrAlreadyLoaded, want parse error")
-	}
-}
-
-// A2: sentinel 与 internal/registry 同值，errors.Is 语义成立
-func TestErrAlreadyLoaded_AliasesRegistrySentinel(t *testing.T) {
-	if !errors.Is(apimeta.ErrAlreadyLoaded, registry.ErrMetaAlreadyLoaded) {
-		t.Fatalf("apimeta.ErrAlreadyLoaded is not registry.ErrMetaAlreadyLoaded")
-	}
-}

extension/credential/env/env.go

@@ -89,11 +89,6 @@ func (p *Provider) ResolveAccount(ctx context.Context) (*credential.Account, err
 		}
 	}
 
-	if openID := os.Getenv(envvars.CliUserOpenID); openID != "" && hasUAT {
-		acct.OpenID = openID
-		acct.OpenIDVerified = true
-	}
-
 	return acct, nil
 }
 

extension/credential/env/env_test.go

@@ -280,47 +280,3 @@ func TestResolveAccount_InvalidDefaultAsRejected(t *testing.T) {
 		t.Fatalf("error = %v, want mention of %s", err, envvars.CliDefaultAs)
 	}
 }
-
-func TestResolveAccountOpenIDAssertedWithUAT(t *testing.T) {
-	t.Setenv(envvars.CliAppID, "cli_test")
-	t.Setenv(envvars.CliUserAccessToken, "u-token")
-	t.Setenv(envvars.CliUserOpenID, "ou_injected")
-
-	acct, err := (&Provider{}).ResolveAccount(context.Background())
-	if err != nil {
-		t.Fatalf("ResolveAccount: %v", err)
-	}
-	if acct.OpenID != "ou_injected" {
-		t.Errorf("OpenID = %q, want %q", acct.OpenID, "ou_injected")
-	}
-	if !acct.OpenIDVerified {
-		t.Error("OpenIDVerified = false, want true")
-	}
-}
-
-func TestResolveAccountOpenIDIgnoredWithoutUAT(t *testing.T) {
-	t.Setenv(envvars.CliAppID, "cli_test")
-	t.Setenv(envvars.CliTenantAccessToken, "t-token") // 仅 TAT，无 UAT
-	t.Setenv(envvars.CliUserOpenID, "ou_injected")
-
-	acct, err := (&Provider{}).ResolveAccount(context.Background())
-	if err != nil {
-		t.Fatalf("ResolveAccount: %v", err)
-	}
-	if acct.OpenID != "" || acct.OpenIDVerified {
-		t.Errorf("OpenID/OpenIDVerified = %q/%v, want empty/false (no UAT)", acct.OpenID, acct.OpenIDVerified)
-	}
-}
-
-func TestResolveAccountNoOpenIDEnvUnchanged(t *testing.T) {
-	t.Setenv(envvars.CliAppID, "cli_test")
-	t.Setenv(envvars.CliUserAccessToken, "u-token")
-
-	acct, err := (&Provider{}).ResolveAccount(context.Background())
-	if err != nil {
-		t.Fatalf("ResolveAccount: %v", err)
-	}
-	if acct.OpenID != "" || acct.OpenIDVerified {
-		t.Errorf("OpenID/OpenIDVerified = %q/%v, want empty/false (env not set)", acct.OpenID, acct.OpenIDVerified)
-	}
-}

extension/credential/types.go

@@ -46,28 +46,13 @@ func (s IdentitySupport) BotOnly() bool { return s == SupportsBot }
 
 // Account holds resolved app credentials and configuration.
 type Account struct {
-	AppID       string
-	AppSecret   string   // real app secret; empty or NoAppSecret means unavailable
-	Brand       Brand    // BrandLark or BrandFeishu
-	DefaultAs   Identity // IdentityUser / IdentityBot / IdentityAuto; empty = not set
-	ProfileName string
-	// OpenID is the optional user open_id hint. If a UAT is available, the
-	// user_info API result takes precedence unless OpenIDVerified is set.
-	OpenID              string
+	AppID               string
+	AppSecret           string   // real app secret; empty or NoAppSecret means unavailable
+	Brand               Brand    // BrandLark or BrandFeishu
+	DefaultAs           Identity // IdentityUser / IdentityBot / IdentityAuto; empty = not set
+	ProfileName         string
+	OpenID              string          // optional; if UAT is available, API result takes precedence
 	SupportedIdentities IdentitySupport // zero = provider did not declare; treat as no restriction
-	// OpenIDVerified marks OpenID as an identity assertion the provider has
-	// already verified. When true and OpenID is non-empty, the CLI skips the
-	// startup user_info verification call and uses OpenID as-is wherever the
-	// resolved user identity is consumed (identity selection, whoami display,
-	// stored-token lookup). The CLI does NOT re-verify the asserted value:
-	// a mismatched assertion is the responsibility of the integrator that
-	// manages the token supply, and whoami will display the injected,
-	// unverified value on this path. Setting OpenIDVerified with an empty
-	// OpenID is treated as unasserted and falls back to normal verification.
-	//
-	// Appended at the end of the struct so adding it does not shift the
-	// positions of existing fields for unkeyed struct literals.
-	OpenIDVerified bool
 }
 
 // Token holds a resolved access token and optional metadata.

extension/envelope/envelope.go

@@ -1,35 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-// Package envelope exposes lark-cli's error-dispatch decision to embedders.
-//
-// Integrators that call cmd.Build and drive Execute themselves must render
-// errors like the official binary so agents can parse stderr uniformly.
-// DispatchError is the same function the official root dispatcher consumes,
-// so error classification, exit codes, and envelope bytes match for every
-// error the dispatcher receives.
-//
-// One narrow exception: the official root dispatcher enriches a
-// need_user_authorization error with the current command's declared scopes
-// (via a cmdutil.Factory it holds) before calling DispatchError. That
-// enrichment depends on command context an embedder does not have, so a
-// direct DispatchError call on a raw need_user_authorization error produces
-// an otherwise-identical envelope without the folded-in scope hint. All other
-// error categories are unaffected.
-package envelope
-
-import "github.com/larksuite/cli/internal/output"
-
-// DispatchError classifies err exactly like lark-cli's own root dispatcher
-// and returns the stderr envelope bytes (if any) together with the process
-// exit code. identity is the resolved identity string ("user", "bot", or ""
-// to omit the field). Typical embedder epilogue:
-//
-//	env, code, has := envelope.DispatchError(err, "user")
-//	if has {
-//		_, _ = os.Stderr.Write(env)
-//	}
-//	os.Exit(code)
-func DispatchError(err error, identity string) (envelope []byte, exitCode int, hasEnvelope bool) {
-	return output.DispatchError(err, identity)
-}

internal/cmdutil/dryrun.go

@@ -8,29 +8,15 @@ import (
 	"fmt"
 	"io"
 	"net/url"
-	"regexp"
 	"sort"
 	"strings"
 
-	"github.com/larksuite/cli/errs"
 	"github.com/larksuite/cli/internal/client"
 	"github.com/larksuite/cli/internal/core"
 	"github.com/larksuite/cli/internal/output"
 	"github.com/larksuite/cli/internal/util"
 )
 
-var dryRunURLPlaceholderRE = regexp.MustCompile(`:([A-Za-z_][A-Za-z0-9_]*)`)
-
-// DryRunOutputOptions controls dry-run stdout/stderr rendering.
-type DryRunOutputOptions struct {
-	Format      string
-	JqExpr      string
-	CommandPath string
-	Identity    core.Identity
-	Out         io.Writer
-	ErrOut      io.Writer
-}
-
 // DryRunAPICall describes a single API call in dry-run output.
 type DryRunAPICall struct {
 	Desc   string                 `json:"desc,omitempty"`
@@ -40,21 +26,12 @@ type DryRunAPICall struct {
 	Body   interface{}            `json:"body,omitempty"`
 }
 
-// DryRunContext is the execution context shared by every dry-run preview:
-// which app would make the call and, when known, as which user. The identity
-// itself lives at the envelope top level, not here.
-type DryRunContext struct {
-	AppID      string `json:"app_id,omitempty"`
-	UserOpenID string `json:"user_open_id,omitempty"`
-}
-
 // DryRunAPI is the builder and result type for dry-run output.
 // URL templates use :param placeholders; Set stores actual values; MarshalJSON and Format resolve them.
 type DryRunAPI struct {
-	desc    string
-	calls   []DryRunAPICall
-	context *DryRunContext
-	extra   map[string]interface{}
+	desc  string
+	calls []DryRunAPICall
+	extra map[string]interface{}
 }
 
 func NewDryRunAPI() *DryRunAPI {
@@ -63,22 +40,30 @@ func NewDryRunAPI() *DryRunAPI {
 
 // --- HTTP method builders (add a call, return self for chaining) ---
 
-// call appends a request with the method transcribed verbatim, so previews
-// never misreport what the real client would send.
-func (d *DryRunAPI) call(method, url string) *DryRunAPI {
-	d.calls = append(d.calls, DryRunAPICall{Method: method, URL: url})
+func (d *DryRunAPI) GET(url string) *DryRunAPI {
+	d.calls = append(d.calls, DryRunAPICall{Method: "GET", URL: url})
 	return d
 }
 
-func (d *DryRunAPI) GET(url string) *DryRunAPI { return d.call("GET", url) }
+func (d *DryRunAPI) POST(url string) *DryRunAPI {
+	d.calls = append(d.calls, DryRunAPICall{Method: "POST", URL: url})
+	return d
+}
 
-func (d *DryRunAPI) POST(url string) *DryRunAPI { return d.call("POST", url) }
+func (d *DryRunAPI) PUT(url string) *DryRunAPI {
+	d.calls = append(d.calls, DryRunAPICall{Method: "PUT", URL: url})
+	return d
+}
 
-func (d *DryRunAPI) PUT(url string) *DryRunAPI { return d.call("PUT", url) }
+func (d *DryRunAPI) DELETE(url string) *DryRunAPI {
+	d.calls = append(d.calls, DryRunAPICall{Method: "DELETE", URL: url})
+	return d
+}
 
-func (d *DryRunAPI) DELETE(url string) *DryRunAPI { return d.call("DELETE", url) }
-
-func (d *DryRunAPI) PATCH(url string) *DryRunAPI { return d.call("PATCH", url) }
+func (d *DryRunAPI) PATCH(url string) *DryRunAPI {
+	d.calls = append(d.calls, DryRunAPICall{Method: "PATCH", URL: url})
+	return d
+}
 
 // Body sets the request body on the last added call.
 func (d *DryRunAPI) Body(body interface{}) *DryRunAPI {
@@ -113,26 +98,12 @@ func (d *DryRunAPI) Set(key string, value interface{}) *DryRunAPI {
 	return d
 }
 
-// Context records the calling app/user under data.context; empty values are
-// omitted, and a fully empty context is not emitted at all.
-func (d *DryRunAPI) Context(appID, userOpenID string) *DryRunAPI {
-	if appID == "" && userOpenID == "" {
-		return d
-	}
-	d.context = &DryRunContext{AppID: appID, UserOpenID: userOpenID}
-	return d
-}
-
 // resolveURL replaces :key placeholders in url with path-escaped values from extra.
 func (d *DryRunAPI) resolveURL(rawURL string) string {
-	return dryRunURLPlaceholderRE.ReplaceAllStringFunc(rawURL, func(token string) string {
-		name := token[1:]
-		value, ok := d.extra[name]
-		if !ok {
-			return token
-		}
-		return url.PathEscape(fmt.Sprintf("%v", value))
-	})
+	for k, v := range d.extra {
+		rawURL = strings.ReplaceAll(rawURL, ":"+k, url.PathEscape(fmt.Sprintf("%v", v)))
+	}
+	return rawURL
 }
 
 // MarshalJSON serializes as {"description": "...", "api": [...calls with resolved URLs], ...extra}.
@@ -147,17 +118,13 @@ func (d *DryRunAPI) MarshalJSON() ([]byte, error) {
 			Body:   c.Body,
 		}
 	}
-	m := make(map[string]interface{}, len(d.extra)+3)
-	for k, v := range d.extra {
-		m[k] = v
-	}
-	// Typed fields win over same-named extra keys.
+	m := make(map[string]interface{}, len(d.extra)+2)
 	if d.desc != "" {
 		m["description"] = d.desc
 	}
 	m["api"] = resolved
-	if d.context != nil {
-		m["context"] = d.context
+	for k, v := range d.extra {
+		m[k] = v
 	}
 	return json.Marshal(m)
 }
@@ -187,7 +154,11 @@ func (d *DryRunAPI) Format() string {
 			u += "?" + encodeParams(c.Params)
 		}
 
-		b.WriteString(c.Method)
+		method := c.Method
+		if method == "" {
+			method = "GET"
+		}
+		b.WriteString(method)
 		b.WriteByte(' ')
 		b.WriteString(u)
 		b.WriteByte('\n')
@@ -244,74 +215,83 @@ func encodeParams(params map[string]interface{}) string {
 	return vals.Encode()
 }
 
-// buildDryRunPreview assembles the shared preview skeleton: HTTP method, URL,
-// query params, and the app/user context common to every dry-run.
-func buildDryRunPreview(request client.RawApiRequest, config *core.CliConfig) *DryRunAPI {
-	dr := NewDryRunAPI().call(request.Method, request.URL)
+// PrintDryRunWithFile outputs a dry-run summary for file upload requests.
+// Instead of serializing the Formdata body, it shows file metadata.
+func PrintDryRunWithFile(w io.Writer, request client.RawApiRequest, config *core.CliConfig, format, fileField, filePath string, formFields any) error {
+	dr := NewDryRunAPI()
+	switch request.Method {
+	case "POST":
+		dr.POST(request.URL)
+	case "PUT":
+		dr.PUT(request.URL)
+	case "PATCH":
+		dr.PATCH(request.URL)
+	case "DELETE":
+		dr.DELETE(request.URL)
+	default:
+		dr.GET(request.URL)
+	}
 	if len(request.Params) > 0 {
 		dr.Params(request.Params)
 	}
-	// Identity is reported at the envelope top level, not duplicated here.
-	dr.Context(config.AppID, config.UserOpenId)
-	return dr
-}
-
-// PrintDryRunWithFile outputs a dry-run summary for file upload requests.
-// Instead of serializing the Formdata body, it shows file metadata.
-func PrintDryRunWithFile(request client.RawApiRequest, config *core.CliConfig, opts DryRunOutputOptions, file FileUploadMeta) error {
-	dr := buildDryRunPreview(request, config)
-	filePathDisplay := file.FilePath
+	filePathDisplay := filePath
 	if filePathDisplay == "" {
 		filePathDisplay = "<stdin>"
 	}
 	fileInfo := map[string]any{
-		"file": map[string]string{"field": file.FieldName, "path": filePathDisplay},
+		"file": map[string]string{"field": fileField, "path": filePathDisplay},
 	}
-	if file.FormFields != nil {
-		fileInfo["form_fields"] = file.FormFields
+	if formFields != nil {
+		fileInfo["form_fields"] = formFields
 	}
 	fileInfo["options"] = []string{"WithFileUpload"}
 	dr.Body(fileInfo)
-	return WriteDryRun(dr, opts)
+	dr.Set("as", string(request.As))
+	dr.Set("appId", config.AppID)
+	if config.UserOpenId != "" {
+		dr.Set("userOpenId", config.UserOpenId)
+	}
+	fmt.Fprintln(w, "=== Dry Run ===")
+	if format == "pretty" {
+		fmt.Fprint(w, dr.Format())
+	} else {
+		output.PrintJson(w, dr)
+	}
+	return nil
 }
 
 // PrintDryRun outputs a standardised dry-run summary using DryRunAPI.
 // When format is "pretty", outputs human-readable text; otherwise JSON.
-func PrintDryRun(request client.RawApiRequest, config *core.CliConfig, opts DryRunOutputOptions) error {
-	dr := buildDryRunPreview(request, config)
+func PrintDryRun(w io.Writer, request client.RawApiRequest, config *core.CliConfig, format string) error {
+	dr := NewDryRunAPI()
+	switch request.Method {
+	case "POST":
+		dr.POST(request.URL)
+	case "PUT":
+		dr.PUT(request.URL)
+	case "PATCH":
+		dr.PATCH(request.URL)
+	case "DELETE":
+		dr.DELETE(request.URL)
+	default:
+		dr.GET(request.URL)
+	}
+	if len(request.Params) > 0 {
+		dr.Params(request.Params)
+	}
 	if !util.IsNil(request.Data) {
 		dr.Body(request.Data)
 	}
-	return WriteDryRun(dr, opts)
-}
-
-// WriteDryRun emits a DryRunAPI using the shared dry-run output contract.
-// Identity may be empty; the envelope omits it rather than guessing.
-func WriteDryRun(dr *DryRunAPI, opts DryRunOutputOptions) error {
-	if dr == nil {
-		return errs.NewInternalError(errs.SubtypeUnknown, "dry-run produced no request preview")
+	dr.Set("as", string(request.As))
+	dr.Set("appId", config.AppID)
+	if config.UserOpenId != "" {
+		dr.Set("userOpenId", config.UserOpenId)
 	}
-	// The JqExpr guard is defensive: every entry point already rejects --jq
-	// combined with --format pretty via output.ValidateJqFlags.
-	if opts.Format == "pretty" && opts.JqExpr == "" {
-		// A nil ErrOut only skips the banner decoration (mirroring
-		// WriteSuccessEnvelope's warning path); the payload write to Out
-		// must fail loudly rather than be silently discarded.
-		if opts.ErrOut != nil {
-			fmt.Fprintln(opts.ErrOut, "=== Dry Run ===")
-		}
-		// stdout carries its own marker so logs that drop stderr still show
-		// this was a preview, not an executed request.
-		fmt.Fprintln(opts.Out, "# dry-run: request not sent")
-		fmt.Fprint(opts.Out, dr.Format())
-		return nil
+	fmt.Fprintln(w, "=== Dry Run ===")
+	if format == "pretty" {
+		fmt.Fprint(w, dr.Format())
+	} else {
+		output.PrintJson(w, dr)
 	}
-	return output.WriteSuccessEnvelope(dr, output.SuccessEnvelopeOptions{
-		CommandPath: opts.CommandPath,
-		Identity:    string(opts.Identity),
-		DryRun:      true,
-		JqExpr:      opts.JqExpr,
-		Out:         opts.Out,
-		ErrOut:      opts.ErrOut,
-	})
+	return nil
 }

internal/cmdutil/dryrun_test.go

@@ -6,12 +6,9 @@ package cmdutil
 import (
 	"bytes"
 	"encoding/json"
-	"errors"
-	"io"
 	"strings"
 	"testing"
 
-	"github.com/larksuite/cli/errs"
 	"github.com/larksuite/cli/internal/client"
 	"github.com/larksuite/cli/internal/core"
 )
@@ -69,31 +66,11 @@ func TestDryRunAPI_ResolveURL(t *testing.T) {
 	}
 }
 
-func TestDryRunAPI_ResolveURLMatchesFullPlaceholderOnly(t *testing.T) {
-	dr := NewDryRunAPI().
-		GET("/open-apis/task/v2/tasks/:assignee_id").
-		Set("assignee", "ou_bot")
-
-	text := dr.Format()
-	if strings.Contains(text, "ou_bot_id") {
-		t.Fatalf("prefix placeholder key corrupted longer token: %s", text)
-	}
-	if !strings.Contains(text, ":assignee_id") {
-		t.Fatalf("missing unresolved placeholder, got: %s", text)
-	}
-
-	dr.Set("assignee_id", "ou_abc/123")
-	text = dr.Format()
-	if !strings.Contains(text, "/open-apis/task/v2/tasks/ou_abc%2F123") {
-		t.Fatalf("expected full placeholder replacement with path escaping, got: %s", text)
-	}
-}
-
 func TestDryRunAPI_MarshalJSON(t *testing.T) {
 	dr := NewDryRunAPI().
 		Desc("test api").
 		GET("/open-apis/test").
-		Set("note", "audit")
+		Set("as", "user")
 
 	data, err := json.Marshal(dr)
 	if err != nil {
@@ -106,8 +83,8 @@ func TestDryRunAPI_MarshalJSON(t *testing.T) {
 	if m["description"] != "test api" {
 		t.Errorf("expected description, got: %v", m["description"])
 	}
-	if m["note"] != "audit" {
-		t.Errorf("expected note=audit, got: %v", m["note"])
+	if m["as"] != "user" {
+		t.Errorf("expected as=user, got: %v", m["as"])
 	}
 	api, ok := m["api"].([]interface{})
 	if !ok || len(api) != 1 {
@@ -146,67 +123,31 @@ func TestDryRunAPI_ExtraFieldsOnly(t *testing.T) {
 
 func TestPrintDryRun_JSON(t *testing.T) {
 	var buf bytes.Buffer
-	var errBuf bytes.Buffer
-	err := PrintDryRun(client.RawApiRequest{
+	err := PrintDryRun(&buf, client.RawApiRequest{
 		Method: "GET",
 		URL:    "/open-apis/test",
 		As:     "user",
-	}, &core.CliConfig{AppID: "app123"}, DryRunOutputOptions{
-		Format:      "json",
-		CommandPath: "lark-cli api",
-		Identity:    core.AsUser,
-		Out:         &buf,
-		ErrOut:      &errBuf,
-	})
+	}, &core.CliConfig{AppID: "app123"}, "json")
 	if err != nil {
 		t.Fatalf("PrintDryRun failed: %v", err)
 	}
 	out := buf.String()
-	if strings.Contains(out, "=== Dry Run ===") {
-		t.Fatalf("JSON stdout must not contain banner, got: %s", out)
+	if !strings.Contains(out, "=== Dry Run ===") {
+		t.Errorf("expected header, got: %s", out)
 	}
-	var env map[string]interface{}
-	if err := json.Unmarshal(buf.Bytes(), &env); err != nil {
-		t.Fatalf("dry-run stdout is not JSON: %v\n%s", err, out)
-	}
-	if env["ok"] != true || env["identity"] != "user" || env["dry_run"] != true {
-		t.Fatalf("unexpected envelope: %#v", env)
-	}
-	data, ok := env["data"].(map[string]interface{})
-	if !ok {
-		t.Fatalf("unexpected data: %#v", env["data"])
-	}
-	dctx, ok := data["context"].(map[string]interface{})
-	if !ok || dctx["app_id"] != "app123" {
-		t.Fatalf("unexpected data.context: %#v", data["context"])
-	}
-	if _, exists := data["as"]; exists {
-		t.Fatalf("data.as must not appear; identity lives at the envelope top level: %#v", data)
-	}
-	api, ok := data["api"].([]interface{})
-	if !ok || len(api) != 1 {
-		t.Fatalf("api = %#v, want one call", data["api"])
-	}
-	call, ok := api[0].(map[string]interface{})
-	if !ok || call["url"] != "/open-apis/test" {
-		t.Fatalf("api[0] = %#v", api[0])
+	if !strings.Contains(out, "app123") {
+		t.Errorf("expected appId in output, got: %s", out)
 	}
 }
 
 func TestPrintDryRun_Pretty(t *testing.T) {
 	var buf bytes.Buffer
-	var errBuf bytes.Buffer
-	err := PrintDryRun(client.RawApiRequest{
+	err := PrintDryRun(&buf, client.RawApiRequest{
 		Method: "POST",
 		URL:    "/open-apis/test",
 		Data:   map[string]interface{}{"key": "val"},
 		As:     "bot",
-	}, &core.CliConfig{AppID: "app456"}, DryRunOutputOptions{
-		Format:   "pretty",
-		Identity: core.AsBot,
-		Out:      &buf,
-		ErrOut:   &errBuf,
-	})
+	}, &core.CliConfig{AppID: "app456"}, "pretty")
 	if err != nil {
 		t.Fatalf("PrintDryRun failed: %v", err)
 	}
@@ -214,136 +155,6 @@ func TestPrintDryRun_Pretty(t *testing.T) {
 	if !strings.Contains(out, "POST /open-apis/test") {
 		t.Errorf("expected POST line in pretty output, got: %s", out)
 	}
-	if !strings.HasPrefix(out, "# dry-run: request not sent\n") {
-		t.Fatalf("pretty stdout should start with the dry-run marker, got: %s", out)
-	}
-	if strings.Contains(out, "=== Dry Run ===") {
-		t.Fatalf("pretty stdout must not contain banner, got: %s", out)
-	}
-	if !strings.Contains(errBuf.String(), "=== Dry Run ===") {
-		t.Fatalf("pretty stderr should contain banner, got: %s", errBuf.String())
-	}
-}
-
-func TestPrintDryRun_WithJqUsesEnvelope(t *testing.T) {
-	var buf bytes.Buffer
-	err := PrintDryRun(client.RawApiRequest{
-		Method: "GET",
-		URL:    "/open-apis/test",
-		As:     "bot",
-	}, &core.CliConfig{AppID: "app123"}, DryRunOutputOptions{
-		Format:   "json",
-		JqExpr:   ".data.api[0].url",
-		Identity: core.AsBot,
-		Out:      &buf,
-		ErrOut:   io.Discard,
-	})
-	if err != nil {
-		t.Fatalf("PrintDryRun failed: %v", err)
-	}
-	if got := strings.TrimSpace(buf.String()); got != "/open-apis/test" {
-		t.Fatalf("jq output = %q, want /open-apis/test", got)
-	}
-}
-
-func TestPrintDryRunWithFile_JSONEnvelope(t *testing.T) {
-	var buf bytes.Buffer
-	err := PrintDryRunWithFile(client.RawApiRequest{
-		Method: "POST",
-		URL:    "/open-apis/drive/v1/files/upload_all",
-		As:     "bot",
-	}, &core.CliConfig{AppID: "app123", UserOpenId: "ou_tester"}, DryRunOutputOptions{
-		Format:   "json",
-		Identity: core.AsBot,
-		Out:      &buf,
-		ErrOut:   io.Discard,
-	}, FileUploadMeta{FieldName: "file", FilePath: "report.txt", FormFields: map[string]any{"parent": "fld"}})
-	if err != nil {
-		t.Fatalf("PrintDryRunWithFile failed: %v", err)
-	}
-	var env map[string]interface{}
-	if err := json.Unmarshal(buf.Bytes(), &env); err != nil {
-		t.Fatalf("dry-run stdout is not JSON: %v\n%s", err, buf.String())
-	}
-	if env["dry_run"] != true {
-		t.Fatalf("dry_run = %#v, want true", env["dry_run"])
-	}
-	data := env["data"].(map[string]interface{})
-	api := data["api"].([]interface{})
-	call := api[0].(map[string]interface{})
-	body := call["body"].(map[string]interface{})
-	file := body["file"].(map[string]interface{})
-	if file["path"] != "report.txt" {
-		t.Fatalf("file body = %#v", body)
-	}
-	dctx, ok := data["context"].(map[string]interface{})
-	if !ok || dctx["app_id"] != "app123" || dctx["user_open_id"] != "ou_tester" {
-		t.Fatalf("unexpected data.context: %#v", data["context"])
-	}
-	for _, legacy := range []string{"as", "appId", "userOpenId"} {
-		if _, exists := data[legacy]; exists {
-			t.Fatalf("legacy key %q must not appear in data: %#v", legacy, data)
-		}
-	}
-}
-
-func TestPrintDryRun_MethodTranscribedVerbatim(t *testing.T) {
-	var buf bytes.Buffer
-	err := PrintDryRun(client.RawApiRequest{
-		Method: "OPTIONS",
-		URL:    "/open-apis/test",
-		As:     "bot",
-	}, &core.CliConfig{AppID: "app123"}, DryRunOutputOptions{
-		Format:   "json",
-		Identity: core.AsBot,
-		Out:      &buf,
-		ErrOut:   io.Discard,
-	})
-	if err != nil {
-		t.Fatalf("PrintDryRun failed: %v", err)
-	}
-	var env map[string]interface{}
-	if err := json.Unmarshal(buf.Bytes(), &env); err != nil {
-		t.Fatalf("dry-run stdout is not JSON: %v\n%s", err, buf.String())
-	}
-	call := env["data"].(map[string]interface{})["api"].([]interface{})[0].(map[string]interface{})
-	if call["method"] != "OPTIONS" {
-		t.Fatalf("method = %#v, want OPTIONS transcribed verbatim (not coerced to GET)", call["method"])
-	}
-}
-
-func TestPrintDryRun_EmptyConfigOmitsContext(t *testing.T) {
-	var buf bytes.Buffer
-	err := PrintDryRun(client.RawApiRequest{
-		Method: "GET",
-		URL:    "/open-apis/test",
-	}, &core.CliConfig{}, DryRunOutputOptions{
-		Format: "json",
-		Out:    &buf,
-		ErrOut: io.Discard,
-	})
-	if err != nil {
-		t.Fatalf("PrintDryRun failed: %v", err)
-	}
-	var env map[string]interface{}
-	if err := json.Unmarshal(buf.Bytes(), &env); err != nil {
-		t.Fatalf("dry-run stdout is not JSON: %v\n%s", err, buf.String())
-	}
-	data := env["data"].(map[string]interface{})
-	if _, exists := data["context"]; exists {
-		t.Fatalf("empty app/user context must be omitted entirely, got: %#v", data["context"])
-	}
-}
-
-func TestWriteDryRun_NilPreviewIsInternalError(t *testing.T) {
-	err := WriteDryRun(nil, DryRunOutputOptions{Format: "json", Out: io.Discard})
-	if err == nil {
-		t.Fatal("WriteDryRun(nil) should fail instead of emitting an empty preview")
-	}
-	var internal *errs.InternalError
-	if !errors.As(err, &internal) {
-		t.Fatalf("expected *errs.InternalError, got %T: %v", err, err)
-	}
 }
 
 func TestDryRunFormatValue(t *testing.T) {

internal/credential/credential_provider.go

@@ -181,13 +181,7 @@ func (p *CredentialProvider) doResolveAccount(ctx context.Context) (*Account, er
 		if acct != nil {
 			internal := convertAccount(acct)
 			source := extensionTokenSource{provider: prov}
-			if acct.OpenIDVerified && acct.OpenID != "" {
-				// Provider asserted a verified identity (e.g. env provider's
-				// LARKSUITE_CLI_USER_OPEN_ID): skip the startup user_info
-				// verification. UserOpenId is already populated by
-				// convertAccount; the token's validity is still enforced by
-				// the first real API call.
-			} else if err := p.enrichUserInfo(ctx, internal, source); err != nil {
+			if err := p.enrichUserInfo(ctx, internal, source); err != nil {
 				if p.warnOut != nil {
 					_, _ = fmt.Fprintf(p.warnOut, "warning: unable to verify user identity from credential source %q: %v\n", source.Name(), err)
 				}

internal/credential/credential_provider_test.go

@@ -8,7 +8,6 @@ import (
 	"context"
 	"errors"
 	"net/http"
-	"net/http/httptest"
 	"strings"
 	"testing"
 
@@ -492,99 +491,3 @@ func TestActiveExtensionProviderName_SkipsNilProvider(t *testing.T) {
 		t.Errorf("got %q, want empty string", name)
 	}
 }
-
-func TestCredentialProvider_AssertedOpenIDSkipsUserInfo(t *testing.T) {
-	httpClientCalls := 0
-	cp := NewCredentialProvider(
-		[]extcred.Provider{&mockExtProvider{
-			name: "asserted",
-			account: &extcred.Account{
-				AppID: "cli_a", Brand: extcred.BrandFeishu,
-				OpenID: "ou_injected", OpenIDVerified: true,
-			},
-			token: &extcred.Token{Value: "u-token", Source: "test"},
-		}},
-		nil, nil,
-		func() (*http.Client, error) {
-			httpClientCalls++
-			return nil, errors.New("user_info must not be fetched on asserted path")
-		},
-	)
-	acct, err := cp.ResolveAccount(context.Background())
-	if err != nil {
-		t.Fatalf("ResolveAccount: %v", err)
-	}
-	if httpClientCalls != 0 {
-		t.Fatalf("httpClient() called %d times, want 0 (verification skipped)", httpClientCalls)
-	}
-	if acct.UserOpenId != "ou_injected" {
-		t.Errorf("UserOpenId = %q, want %q", acct.UserOpenId, "ou_injected")
-	}
-	if acct.UserName != "" {
-		t.Errorf("UserName = %q, want empty on asserted path", acct.UserName)
-	}
-}
-
-func TestCredentialProvider_VerifiedFlagWithoutOpenIDFallsBack(t *testing.T) {
-	// 非法组合：OpenIDVerified=true 但 OpenID 空 → 视为未断言，照常尝试验证。
-	httpClientCalls := 0
-	cp := NewCredentialProvider(
-		[]extcred.Provider{&mockExtProvider{
-			name: "misconfigured",
-			account: &extcred.Account{
-				AppID: "cli_a", Brand: extcred.BrandFeishu, OpenIDVerified: true,
-			},
-			token: &extcred.Token{Value: "u-token", Source: "test"},
-		}},
-		nil, nil,
-		func() (*http.Client, error) {
-			httpClientCalls++
-			return nil, errors.New("fail verification")
-		},
-	)
-	acct, err := cp.ResolveAccount(context.Background())
-	if err != nil {
-		t.Fatalf("ResolveAccount: %v", err)
-	}
-	if httpClientCalls == 0 {
-		t.Fatal("httpClient() not called, want verification attempt (invalid combination must fall back)")
-	}
-	// enrich 失败 → 现有防御逻辑清空未验证身份
-	if acct.UserOpenId != "" {
-		t.Errorf("UserOpenId = %q, want empty after failed verification", acct.UserOpenId)
-	}
-}
-
-func TestCredentialProvider_UnassertedOpenIDStillOverridden(t *testing.T) {
-	// 现有语义保持：OpenID 非空但未断言 → 有 UAT 时 API 结果覆盖。
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path != "/open-apis/authen/v1/user_info" {
-			http.NotFound(w, r)
-			return
-		}
-		_, _ = w.Write([]byte(`{"code":0,"msg":"ok","data":{"open_id":"ou_from_api","name":"API User"}}`))
-	}))
-	defer srv.Close()
-	// Endpoint injection mirrors tat_fetch_test.go's TestFetchTAT_ContextCanceled:
-	// there is no env-var endpoint override in this repo, so we rewrite the
-	// request host to the test server via a custom RoundTripper instead.
-	hc := &http.Client{Transport: &urlRewriteRT{base: srv.URL}}
-	cp := NewCredentialProvider(
-		[]extcred.Provider{&mockExtProvider{
-			name: "hint-only",
-			account: &extcred.Account{
-				AppID: "cli_a", Brand: extcred.BrandFeishu, OpenID: "ou_hint",
-			},
-			token: &extcred.Token{Value: "u-token", Source: "test"},
-		}},
-		nil, nil,
-		func() (*http.Client, error) { return hc, nil },
-	)
-	acct, err := cp.ResolveAccount(context.Background())
-	if err != nil {
-		t.Fatalf("ResolveAccount: %v", err)
-	}
-	if acct.UserOpenId != "ou_from_api" {
-		t.Errorf("UserOpenId = %q, want %q (API result takes precedence)", acct.UserOpenId, "ou_from_api")
-	}
-}

internal/envvars/envvars.go

@@ -11,7 +11,6 @@ const (
 	CliTenantAccessToken = "LARKSUITE_CLI_TENANT_ACCESS_TOKEN"
 	CliDefaultAs         = "LARKSUITE_CLI_DEFAULT_AS"
 	CliStrictMode        = "LARKSUITE_CLI_STRICT_MODE"
-	CliUserOpenID        = "LARKSUITE_CLI_USER_OPEN_ID"
 
 	// Sidecar proxy (auth proxy mode)
 	CliAuthProxy = "LARKSUITE_CLI_AUTH_PROXY" // sidecar HTTP address, e.g. "http://127.0.0.1:16384"

internal/output/dispatch.go

@@ -1,91 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package output
-
-import (
-	"errors"
-	"strings"
-
-	"github.com/larksuite/cli/errs"
-)
-
-// DispatchError classifies err exactly like the root command dispatcher and
-// returns the rendered stderr envelope (if any) together with the process
-// exit code. It is the single classification path shared by lark-cli's own
-// root dispatcher and the public extension/envelope facade, so embedders that
-// drive Execute themselves render errors byte-identically to the official
-// binary.
-//
-// Classification, in order:
-//
-//  1. nil → (nil, 0, false).
-//  2. Typed errs.* carrying a Problem → (envelope, ExitCodeOf(err), true).
-//     If envelope encoding fails the error falls through to branch 4 so
-//     stderr is never blank.
-//  3. *PartialFailureError / *BareError → (nil, signal code, false): the
-//     result envelope is already on stdout; write nothing to stderr.
-//  4. Remaining untyped errors: cobra usage text → invalid_argument envelope
-//     with exit 2; anything else leaked past the typed boundary → internal
-//     envelope with exit 5.
-func DispatchError(err error, identity string) (envelope []byte, exitCode int, hasEnvelope bool) {
-	if err == nil {
-		return nil, 0, false
-	}
-	typedExit := ExitCodeOf(err)
-	if env, ok := renderTypedEnvelope(err, identity); ok {
-		return env, typedExit, true
-	}
-
-	var pfErr *PartialFailureError
-	if errors.As(err, &pfErr) {
-		return nil, pfErr.Code, false
-	}
-	var bareErr *BareError
-	if errors.As(err, &bareErr) {
-		return nil, bareErr.Code, false
-	}
-
-	var fallback error
-	if isCobraUsageError(err) {
-		fallback = errs.NewValidationError(errs.SubtypeInvalidArgument, "%s", err.Error()).WithCause(err)
-	} else {
-		fallback = errs.NewInternalError(errs.SubtypeUnknown, "%s", err.Error()).WithCause(err)
-	}
-	env, ok := renderTypedEnvelope(fallback, identity)
-	if !ok {
-		return nil, ExitCodeOf(fallback), false
-	}
-	return env, ExitCodeOf(fallback), true
-}
-
-// 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
-}

internal/output/dispatch_test.go

@@ -1,83 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package output
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"testing"
-
-	"github.com/larksuite/cli/errs"
-)
-
-func TestDispatchErrorNil(t *testing.T) {
-	env, code, has := DispatchError(nil, "user")
-	if env != nil || code != 0 || has {
-		t.Fatalf("DispatchError(nil) = (%v, %d, %v), want (nil, 0, false)", env, code, has)
-	}
-}
-
-func TestDispatchErrorTyped(t *testing.T) {
-	err := errs.NewValidationError(errs.SubtypeInvalidArgument, "missing --id")
-	env, code, has := DispatchError(err, "user")
-	if !has || code != ExitCodeOf(err) {
-		t.Fatalf("has=%v code=%d, want true / %d", has, code, ExitCodeOf(err))
-	}
-	var parsed map[string]any
-	if jsonErr := json.Unmarshal(env, &parsed); jsonErr != nil {
-		t.Fatalf("envelope not valid JSON: %v", jsonErr)
-	}
-	if parsed["ok"] != false || parsed["identity"] != "user" {
-		t.Errorf("envelope ok/identity = %v/%v", parsed["ok"], parsed["identity"])
-	}
-}
-
-func TestDispatchErrorPartialFailure(t *testing.T) {
-	env, code, has := DispatchError(PartialFailure(1), "user")
-	if env != nil || code != 1 || has {
-		t.Fatalf("got (%v, %d, %v), want (nil, 1, false)", env, code, has)
-	}
-}
-
-func TestDispatchErrorBare(t *testing.T) {
-	env, code, has := DispatchError(ErrBare(3), "user")
-	if env != nil || code != 3 || has {
-		t.Fatalf("got (%v, %d, %v), want (nil, 3, false)", env, code, has)
-	}
-}
-
-func TestDispatchErrorCobraUsage(t *testing.T) {
-	env, code, has := DispatchError(fmt.Errorf(`required flag(s) "values" not set`), "user")
-	if !has || code != 2 {
-		t.Fatalf("has=%v code=%d, want true / 2", has, code)
-	}
-	var parsed map[string]any
-	_ = json.Unmarshal(env, &parsed)
-	errObj := parsed["error"].(map[string]any)
-	if errObj["subtype"] != "invalid_argument" {
-		t.Errorf("subtype = %v, want invalid_argument", errObj["subtype"])
-	}
-}
-
-func TestDispatchErrorLeakedUntyped(t *testing.T) {
-	env, code, has := DispatchError(errors.New("boom"), "bot")
-	if !has || code != 5 {
-		t.Fatalf("has=%v code=%d, want true / 5", has, code)
-	}
-	var parsed map[string]any
-	_ = json.Unmarshal(env, &parsed)
-	if parsed["identity"] != "bot" {
-		t.Errorf("identity = %v, want bot", parsed["identity"])
-	}
-}
-
-func TestDispatchErrorEmptyIdentityOmitted(t *testing.T) {
-	env, _, _ := DispatchError(errs.NewValidationError(errs.SubtypeInvalidArgument, "x"), "")
-	var parsed map[string]any
-	_ = json.Unmarshal(env, &parsed)
-	if _, present := parsed["identity"]; present {
-		t.Error("identity field present, want omitted for empty identity")
-	}
-}

internal/output/envelope.go

@@ -7,7 +7,6 @@ package output
 type Envelope struct {
 	OK                 bool                   `json:"ok"`
 	Identity           string                 `json:"identity,omitempty"`
-	DryRun             bool                   `json:"dry_run,omitempty"`
 	Data               interface{}            `json:"data,omitempty"`
 	Meta               *Meta                  `json:"meta,omitempty"`
 	ContentSafetyAlert interface{}            `json:"_content_safety_alert,omitempty"`

internal/output/envelope_success.go

@@ -9,7 +9,6 @@ import "io"
 type SuccessEnvelopeOptions struct {
 	CommandPath string
 	Identity    string
-	DryRun      bool
 	JqExpr      string
 	Out         io.Writer
 	ErrOut      io.Writer
@@ -42,7 +41,6 @@ func WriteSuccessEnvelope(data interface{}, opts SuccessEnvelopeOptions) error {
 	env := Envelope{
 		OK:       true,
 		Identity: opts.Identity,
-		DryRun:   opts.DryRun,
 		Data:     data,
 		Notice:   GetNotice(),
 	}

internal/output/envelope_success_test.go

@@ -104,47 +104,6 @@ func TestWriteSuccessEnvelope_JqUsesEnvelope(t *testing.T) {
 	}
 }
 
-func TestWriteSuccessEnvelope_DryRunMarker(t *testing.T) {
-	var out strings.Builder
-
-	err := WriteSuccessEnvelope(map[string]interface{}{"api": []interface{}{}}, SuccessEnvelopeOptions{
-		Identity: "bot",
-		DryRun:   true,
-		Out:      &out,
-	})
-	if err != nil {
-		t.Fatalf("WriteSuccessEnvelope() error = %v", err)
-	}
-
-	var env map[string]interface{}
-	if err := json.Unmarshal([]byte(out.String()), &env); err != nil {
-		t.Fatalf("invalid JSON output: %v\n%s", err, out.String())
-	}
-	if env["ok"] != true || env["identity"] != "bot" || env["dry_run"] != true {
-		t.Fatalf("unexpected dry-run envelope: %#v", env)
-	}
-	if _, ok := env["data"].(map[string]interface{}); !ok {
-		t.Fatalf("data = %#v, want object", env["data"])
-	}
-}
-
-func TestWriteSuccessEnvelope_DryRunJqUsesEnvelope(t *testing.T) {
-	var out strings.Builder
-
-	err := WriteSuccessEnvelope(map[string]interface{}{"api": []interface{}{}}, SuccessEnvelopeOptions{
-		Identity: "bot",
-		DryRun:   true,
-		JqExpr:   ".dry_run",
-		Out:      &out,
-	})
-	if err != nil {
-		t.Fatalf("WriteSuccessEnvelope() error = %v", err)
-	}
-	if strings.TrimSpace(out.String()) != "true" {
-		t.Fatalf("jq output = %q, want true", out.String())
-	}
-}
-
 func TestWriteSuccessEnvelope_JqWarnsWhenSafetyAlertFiltered(t *testing.T) {
 	t.Setenv("LARKSUITE_CLI_CONTENT_SAFETY_MODE", "warn")
 	extcs.Register(&mockProvider{

internal/output/errors.go

@@ -34,30 +34,6 @@ func PartialFailure(code int) *PartialFailureError {
 	return &PartialFailureError{Code: code}
 }
 
-// renderTypedEnvelope serializes the typed-error envelope for err. It returns
-// (nil, false) when err carries no Problem or when JSON encoding fails — the
-// dispatcher then falls through to its signal / usage-error branches.
-func renderTypedEnvelope(err error, identity string) ([]byte, bool) {
-	typed, ok := errs.UnwrapTypedError(err)
-	if !ok {
-		return nil, false
-	}
-	env := typedEnvelope{
-		OK:       false,
-		Identity: identity,
-		Error:    typed,
-		Notice:   GetNotice(),
-	}
-	var buf bytes.Buffer
-	enc := json.NewEncoder(&buf)
-	enc.SetEscapeHTML(false)
-	enc.SetIndent("", "  ")
-	if encErr := enc.Encode(env); encErr != nil {
-		return nil, false
-	}
-	return buf.Bytes(), true
-}
-
 // WriteTypedErrorEnvelope writes the JSON error envelope for a typed error.
 // Each typed error owns its wire shape via its own struct tags: Problem fields
 // are promoted to the top level through embedding, and extension fields
@@ -80,11 +56,30 @@ func renderTypedEnvelope(err error, identity string) ([]byte, bool) {
 // Returns false only when err carries no Problem (the dispatcher then handles
 // it via its signal / usage-error branches) or when JSON encoding itself failed.
 func WriteTypedErrorEnvelope(w io.Writer, err error, identity string) bool {
-	b, ok := renderTypedEnvelope(err, identity)
+	typed, ok := errs.UnwrapTypedError(err)
 	if !ok {
 		return false
 	}
-	_, _ = w.Write(b)
+	env := typedEnvelope{
+		OK:       false,
+		Identity: identity,
+		Error:    typed,
+		Notice:   GetNotice(),
+	}
+	var buf bytes.Buffer
+	enc := json.NewEncoder(&buf)
+	enc.SetEscapeHTML(false)
+	enc.SetIndent("", "  ")
+	if encErr := enc.Encode(env); encErr != nil {
+		// Encoding failed — emit nothing here; the dispatcher's fall-through
+		// branches still surface the error, so stderr is never blank.
+		return false
+	}
+	// Best-effort write. Partial-write does not downgrade the success status:
+	// the dispatcher has already captured ExitCodeOf(err) before calling us,
+	// and a torn stderr is preferable to falling through to the plain
+	// "Error:" path with exit 1.
+	_, _ = w.Write(buf.Bytes())
 	return true
 }
 

internal/qualitygate/rules/dryrun.go

@@ -878,23 +878,16 @@ func extractDryRunJSON(raw []byte) (facts.DryRunRequest, int, error) {
 	var firstErr error
 	for start >= 0 {
 		var preview struct {
-			API  []facts.DryRunRequest `json:"api"`
-			Data struct {
-				API []facts.DryRunRequest `json:"api"`
-			} `json:"data"`
+			API []facts.DryRunRequest `json:"api"`
 		}
 		dec := json.NewDecoder(bytes.NewReader(raw[start:]))
 		if err := dec.Decode(&preview); err == nil {
-			api := preview.API
-			if len(api) == 0 {
-				api = preview.Data.API
-			}
-			if len(api) == 0 {
+			if len(preview.API) == 0 {
 				if firstErr == nil {
 					firstErr = errNoDryRunAPI
 				}
 			} else {
-				return api[0], len(api), nil
+				return preview.API[0], len(preview.API), nil
 			}
 		} else if firstErr == nil {
 			firstErr = err

internal/qualitygate/rules/dryrun_test.go

@@ -33,17 +33,6 @@ func TestExtractDryRunJSONSkipsBanner(t *testing.T) {
 	}
 }
 
-func TestExtractDryRunJSONReadsSuccessEnvelope(t *testing.T) {
-	raw := `{"ok":true,"dry_run":true,"data":{"api":[{"method":"GET","url":"/open-apis/test"}]}}`
-	got, apiCallCount, err := extractDryRunJSON([]byte(raw))
-	if err != nil {
-		t.Fatalf("extractDryRunJSON() error = %v", err)
-	}
-	if got.Method != "GET" || got.URL != "/open-apis/test" || apiCallCount != 1 {
-		t.Fatalf("got request=%#v apiCallCount=%d, want enveloped GET and count 1", got, apiCallCount)
-	}
-}
-
 func TestExtractDryRunJSONSkipsBannerWithBraces(t *testing.T) {
 	raw := "banner {not json}\n{\"api\":[{\"method\":\"GET\",\"url\":\"/open-apis/test\"}]}\n"
 	got, apiCallCount, err := extractDryRunJSON([]byte(raw))

internal/registry/loader.go

@@ -4,11 +4,8 @@
 package registry
 
 import (
-	"bytes"
 	"embed"
 	"encoding/json"
-	"errors"
-	"fmt"
 	"math"
 	"path/filepath"
 	"runtime"
@@ -34,43 +31,6 @@ var (
 	embeddedParseOnce      sync.Once
 )
 
-// ErrMetaAlreadyLoaded is returned by SetEmbeddedMeta when the embedded
-// metadata has already been parsed; injection must happen before any
-// registry consumption. extension/apimeta re-exports it as ErrAlreadyLoaded.
-var ErrMetaAlreadyLoaded = errors.New("embedded api metadata already parsed")
-
-var (
-	// embeddedInjectMu serializes SetEmbeddedMeta against the first parse so
-	// check-then-write and mark-then-parse never interleave: an injection
-	// either fully lands before the parse or fails with ErrMetaAlreadyLoaded.
-	embeddedInjectMu sync.Mutex
-	embeddedParsed   bool // set inside parseEmbedded's Once body
-)
-
-// SetEmbeddedMeta validates data and installs it as this process's embedded
-// API metadata — the same variable go:embed fills in official builds, so every
-// downstream consumer (schema, command generation, scope discovery, cache
-// overlay version gating) behaves exactly as an official build would.
-//
-// It is the internal engine of extension/apimeta.SetEmbedded; see that
-// package for the public contract.
-func SetEmbeddedMeta(data []byte) error {
-	reg, err := meta.Parse(data) // validate before write; meta.Parse(nil/empty) returns a zero Registry with no error
-	if err != nil {
-		return fmt.Errorf("invalid api metadata: %w", err)
-	}
-	if len(reg.Services) == 0 {
-		return errors.New("api metadata contains no services")
-	}
-	embeddedInjectMu.Lock()
-	defer embeddedInjectMu.Unlock()
-	if embeddedParsed {
-		return ErrMetaAlreadyLoaded
-	}
-	embeddedMetaJSON = bytes.Clone(data)
-	return nil
-}
-
 // parseEmbedded decodes the embedded meta_data.json into the typed model exactly
 // once. It is the single parse of the embedded bytes: both the overlay-free
 // envelope path (EmbeddedServicesTyped) and the merged command/scope path
@@ -78,9 +38,6 @@ func SetEmbeddedMeta(data []byte) error {
 // twice and no map round-trip is needed downstream.
 func parseEmbedded() {
 	embeddedParseOnce.Do(func() {
-		embeddedInjectMu.Lock()
-		embeddedParsed = true
-		embeddedInjectMu.Unlock()
 		reg, _ := meta.Parse(embeddedMetaJSON)
 		embeddedVersion = reg.Version
 		embeddedServices = reg.Services

internal/registry/loader_inject_test.go

@@ -1,126 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package registry
-
-import (
-	"errors"
-	"strings"
-	"testing"
-
-	"github.com/larksuite/cli/internal/apicatalog"
-)
-
-const injectValidMetaJSON = `{"version":"9.9.9","services":[{"name":"testsvc","title":"Test Service","resources":{}}]}`
-
-// resetInjectState resets package state for injection tests and restores the
-// original embedded bytes afterwards (same save/restore pattern as
-// catalog_test.go). resetInit() itself clears embeddedParsed.
-func resetInjectState(t *testing.T) {
-	t.Helper()
-	orig := embeddedMetaJSON
-	resetInit()
-	embeddedServices = nil
-	embeddedServicesByName = nil
-	t.Cleanup(func() {
-		resetInit()
-		embeddedServices = nil
-		embeddedServicesByName = nil
-		embeddedMetaJSON = orig
-	})
-}
-
-// R1: parse 前注入合法 meta → 生效，version 基线更新
-func TestSetEmbeddedMeta_InjectBeforeParse(t *testing.T) {
-	resetInjectState(t)
-	if err := SetEmbeddedMeta([]byte(injectValidMetaJSON)); err != nil {
-		t.Fatalf("SetEmbeddedMeta() = %v, want nil", err)
-	}
-	svcs := EmbeddedServicesTyped()
-	if len(svcs) != 1 || svcs[0].Name != "testsvc" {
-		t.Fatalf("EmbeddedServicesTyped() = %+v, want single service testsvc", svcs)
-	}
-	if embeddedVersion != "9.9.9" { // R7: overlay 门禁的比较基线来源正确
-		t.Fatalf("embeddedVersion = %q, want %q", embeddedVersion, "9.9.9")
-	}
-}
-
-// R1b: parse 前多次注入 → 后写覆盖（注入者赢，spec §3.2 末行）
-func TestSetEmbeddedMeta_LastWriteWinsBeforeParse(t *testing.T) {
-	resetInjectState(t)
-	first := `{"version":"1.0.0","services":[{"name":"firstsvc","resources":{}}]}`
-	if err := SetEmbeddedMeta([]byte(first)); err != nil {
-		t.Fatalf("SetEmbeddedMeta(first) = %v, want nil", err)
-	}
-	if err := SetEmbeddedMeta([]byte(injectValidMetaJSON)); err != nil {
-		t.Fatalf("SetEmbeddedMeta(second) = %v, want nil", err)
-	}
-	svcs := EmbeddedServicesTyped()
-	if len(svcs) != 1 || svcs[0].Name != "testsvc" {
-		t.Fatalf("EmbeddedServicesTyped() = %+v, want last-injected testsvc", svcs)
-	}
-}
-
-// R2: 注入后 SchemaCatalog 走 embedded 快路径
-func TestSetEmbeddedMeta_SchemaCatalogUsesEmbedded(t *testing.T) {
-	resetInjectState(t)
-	if err := SetEmbeddedMeta([]byte(injectValidMetaJSON)); err != nil {
-		t.Fatalf("SetEmbeddedMeta() = %v, want nil", err)
-	}
-	cat := SchemaCatalog()
-	if cat.Source() != apicatalog.SourceEmbedded {
-		t.Fatalf("SchemaCatalog().Source() = %q, want %q", cat.Source(), apicatalog.SourceEmbedded)
-	}
-	if _, ok := cat.Service("testsvc"); !ok {
-		t.Fatalf("SchemaCatalog() missing injected service testsvc")
-	}
-}
-
-// R3: 非法 JSON 拒绝且状态不变
-func TestSetEmbeddedMeta_InvalidJSONRejected(t *testing.T) {
-	resetInjectState(t)
-	before := embeddedMetaJSON
-	err := SetEmbeddedMeta([]byte(`{"broken`))
-	if err == nil || !strings.Contains(err.Error(), "invalid api metadata") {
-		t.Fatalf("SetEmbeddedMeta(invalid) = %v, want invalid api metadata error", err)
-	}
-	if string(embeddedMetaJSON) != string(before) {
-		t.Fatalf("embeddedMetaJSON mutated on rejected input")
-	}
-}
-
-// R4: 合法 JSON 但 services 为空 → 拒绝且状态不变
-func TestSetEmbeddedMeta_EmptyServicesRejected(t *testing.T) {
-	resetInjectState(t)
-	before := embeddedMetaJSON
-	for _, in := range []string{`{}`, `{"version":"1.0.0","services":[]}`} {
-		err := SetEmbeddedMeta([]byte(in))
-		if err == nil || !strings.Contains(err.Error(), "api metadata contains no services") {
-			t.Fatalf("SetEmbeddedMeta(%q) = %v, want no-services error", in, err)
-		}
-	}
-	if string(embeddedMetaJSON) != string(before) {
-		t.Fatalf("embeddedMetaJSON mutated on rejected input")
-	}
-}
-
-// R5: 首次 parse 之后注入 → ErrMetaAlreadyLoaded
-func TestSetEmbeddedMeta_AfterParseRejected(t *testing.T) {
-	resetInjectState(t)
-	_ = EmbeddedServicesTyped() // 触发首次 parse
-	err := SetEmbeddedMeta([]byte(injectValidMetaJSON))
-	if !errors.Is(err, ErrMetaAlreadyLoaded) {
-		t.Fatalf("SetEmbeddedMeta(after parse) = %v, want ErrMetaAlreadyLoaded", err)
-	}
-}
-
-// R6: nil / 空字节 → 恒走 services 为空路径（meta.Parse 空输入返回零值无错误）
-func TestSetEmbeddedMeta_NilAndEmptyRejected(t *testing.T) {
-	resetInjectState(t)
-	for _, in := range [][]byte{nil, {}} {
-		err := SetEmbeddedMeta(in)
-		if err == nil || !strings.Contains(err.Error(), "api metadata contains no services") {
-			t.Fatalf("SetEmbeddedMeta(len=%d) = %v, want no-services error", len(in), err)
-		}
-	}
-}

internal/registry/registry_test.go

@@ -248,18 +248,10 @@ func TestLoadPlatformAutoApproveSet(t *testing.T) {
 
 func TestLoadOverrideAutoApproveAllow(t *testing.T) {
 	allowSet := LoadOverrideAutoApproveAllow()
-	// recommend.allow special-cases scopes absent from scope_priorities.json
-	// (application v7 is not in the platform catalog yet) so interactive
-	// login's "common scopes" tier still offers them. Only the read scope is
-	// admitted: write stays out of the recommended tier by design.
-	if !allowSet["application:app_slash_command:read"] {
-		t.Error("expected application:app_slash_command:read in override allow set")
-	}
-	if allowSet["application:app_slash_command:write"] {
-		t.Error("write scope must NOT be in the recommended tier")
-	}
-	if len(allowSet) != 1 {
-		t.Errorf("expected exactly 1 override allow entry, got %d", len(allowSet))
+	// recommend.allow in scope_overrides.json is intentionally empty:
+	// no scopes are special-cased into the auto-approve set anymore.
+	if len(allowSet) != 0 {
+		t.Errorf("expected empty override allow set, got %d entries", len(allowSet))
 	}
 }
 

internal/registry/remote_test.go

@@ -32,9 +32,6 @@ func resetInit() {
 	waitBackgroundRefresh()
 	initOnce = sync.Once{}
 	embeddedParseOnce = sync.Once{}
-	embeddedInjectMu.Lock()
-	embeddedParsed = false
-	embeddedInjectMu.Unlock()
 	servicesTypedOnce = sync.Once{}
 	servicesTyped = nil
 	mergedServices = make(map[string]meta.Service)

internal/registry/scope_overrides.json

@@ -12,9 +12,7 @@
     "vc:meeting.meetingevent:read": 75
   },
   "recommend": {
-    "allow": [
-      "application:app_slash_command:read"
-    ],
+    "allow": [],
     "deny": [
       "im:chat",
       "im:message.send_as_user"

internal/registry/service_descriptions.json

@@ -3,10 +3,6 @@
     "en": { "title": "Approval", "description": "Approval instance, and task management" },
     "zh": { "title": "审批", "description": "审批实例、审批任务管理" }
   },
-  "application": {
-    "en": { "title": "Application", "description": "Open Platform app self-management: slash commands for the currently bound app" },
-    "zh": { "title": "应用管理", "description": "开放平台应用自管理：当前绑定应用的斜杠指令管理" }
-  },
   "apps": {
     "en": { "title": "Apps", "description": "Develop, deploy HTML, web pages and applications" },
     "zh": { "title": "应用", "description": "开发、部署 HTML、Web 页面和应用" }

internal/vfs/localfileio/path.go

@@ -65,7 +65,7 @@ func safePath(raw, flagName string) (string, error) {
 	}
 
 	if isAbsolutePath(raw) {
-		return "", fmt.Errorf("%s must be a relative path within the current directory, got %q (hint: use a relative path like ./filename; flags that support stdin can read an out-of-tree file via '-' instead)", flagName, raw)
+		return "", fmt.Errorf("%s must be a relative path within the current directory, got %q (hint: cd to the target directory first, or use a relative path like ./filename)", flagName, raw)
 	}
 
 	path := filepath.Clean(raw)

package.json

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

shortcuts/application/shortcuts.go

@@ -1,18 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-// Package application provides shortcuts for Open Platform app
-// self-management (slash commands of the current bound app).
-package application
-
-import "github.com/larksuite/cli/shortcuts/common"
-
-// Shortcuts returns all shortcuts of the application domain.
-func Shortcuts() []common.Shortcut {
-	return []common.Shortcut{
-		SlashCommandList,
-		SlashCommandCreate,
-		SlashCommandUpdate,
-		SlashCommandDelete,
-	}
-}

shortcuts/application/slash_command_common.go

@@ -1,105 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package application
-
-import (
-	"strings"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/internal/validate"
-)
-
-// slashCommandBasePath is the raw v7 endpoint (not in meta_data.json / SDK).
-const slashCommandBasePath = "/open-apis/application/v7/app_slash_commands"
-
-// clientCacheHint is printed to stderr after every successful write.
-const clientCacheHint = "note: changes take ~5 minutes to appear in Feishu clients (client-side cache); the server state is already updated - list reflects it immediately."
-
-// parseDescriptionI18n parses repeated --description-i18n values ("<lang>=<text>",
-// split on the FIRST '='). Returns nil for empty input. Duplicate langs rejected.
-func parseDescriptionI18n(values []string) (map[string]string, error) {
-	if len(values) == 0 {
-		return nil, nil
-	}
-	m := make(map[string]string, len(values))
-	for _, v := range values {
-		idx := strings.Index(v, "=")
-		if idx <= 0 || idx == len(v)-1 {
-			return nil, errs.NewValidationError(errs.SubtypeInvalidArgument,
-				"invalid --description-i18n value %q: expected <lang>=<text> (e.g. zh_cn=你好)", v).
-				WithParam("--description-i18n")
-		}
-		lang := strings.TrimSpace(v[:idx])
-		text := v[idx+1:]
-		if lang == "" || strings.TrimSpace(text) == "" {
-			return nil, errs.NewValidationError(errs.SubtypeInvalidArgument,
-				"invalid --description-i18n value %q: language and text must be non-empty", v).
-				WithParam("--description-i18n")
-		}
-		if _, dup := m[lang]; dup {
-			return nil, errs.NewValidationError(errs.SubtypeInvalidArgument,
-				"duplicate language %q in --description-i18n", lang).
-				WithParam("--description-i18n")
-		}
-		m[lang] = text
-	}
-	return m, nil
-}
-
-// validateCommandName rejects empty and slash-prefixed command names.
-func validateCommandName(name, flagName string) error {
-	trimmed := strings.TrimSpace(name)
-	if trimmed == "" {
-		return errs.NewValidationError(errs.SubtypeInvalidArgument,
-			"%s must not be empty", flagName).WithParam(flagName)
-	}
-	if strings.HasPrefix(trimmed, "/") {
-		return errs.NewValidationError(errs.SubtypeInvalidArgument,
-			"%s must not start with \"/\" - the slash is implied (use %q)",
-			flagName, strings.TrimPrefix(trimmed, "/")).WithParam(flagName)
-	}
-	return nil
-}
-
-// encodeCommandIDPathSegment applies the same normalization and escaping to
-// command IDs in dry-run output and real requests.
-func encodeCommandIDPathSegment(id string) string {
-	return validate.EncodePathSegment(strings.TrimSpace(id))
-}
-
-// buildSlashCommandBody assembles a create/update request body. Only provided
-// fields are included: PATCH is field-level partial (absent top-level fields
-// are preserved server-side; a provided i18n map REPLACES the whole map).
-// icon sits at the top level, sibling of description (verified live; the
-// official create sample nesting icon inside description is a doc bug).
-func buildSlashCommandBody(command, description string, i18n map[string]string, iconKey string) map[string]interface{} {
-	body := map[string]interface{}{}
-	if command != "" {
-		body["command"] = command
-	}
-	if description != "" || len(i18n) > 0 {
-		desc := map[string]interface{}{}
-		if description != "" {
-			desc["default_value"] = description
-		}
-		if len(i18n) > 0 {
-			desc["i18n"] = i18n
-		}
-		body["description"] = desc
-	}
-	if iconKey != "" {
-		body["icon"] = map[string]interface{}{"icon_key": iconKey}
-	}
-	return body
-}
-
-// isCommandExists reports whether err is the server-side name-collision error
-// (code=40000000, message contains "command already exists"; verified live).
-func isCommandExists(err error) bool {
-	p, ok := errs.ProblemOf(err)
-	if !ok {
-		return false
-	}
-	return p.Code == 40000000 && strings.Contains(p.Message, "command already exists")
-}

shortcuts/application/slash_command_common_test.go

@@ -1,197 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package application
-
-import (
-	"errors"
-	"testing"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/shortcuts/common"
-)
-
-func TestParseDescriptionI18n_OK(t *testing.T) {
-	m, err := parseDescriptionI18n([]string{"zh_cn=你好", "en_us=Hello=World"})
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if m["zh_cn"] != "你好" {
-		t.Errorf("zh_cn = %q", m["zh_cn"])
-	}
-	// 只按首个 = 分割：值内可含 =
-	if m["en_us"] != "Hello=World" {
-		t.Errorf("en_us = %q", m["en_us"])
-	}
-}
-
-func TestParseDescriptionI18n_Empty(t *testing.T) {
-	m, err := parseDescriptionI18n(nil)
-	if err != nil || m != nil {
-		t.Fatalf("nil input: m=%v err=%v", m, err)
-	}
-}
-
-func TestParseDescriptionI18n_BadFormat(t *testing.T) {
-	for _, bad := range []string{"zh_cn", "=text", "zh_cn=", "  =x"} {
-		_, err := parseDescriptionI18n([]string{bad})
-		if err == nil {
-			t.Errorf("%q: expected error", bad)
-			continue
-		}
-		p, ok := errs.ProblemOf(err)
-		if !ok || p.Category != errs.CategoryValidation || p.Subtype != errs.SubtypeInvalidArgument {
-			t.Errorf("%q: expected validation problem, got %v", bad, err)
-		}
-	}
-}
-
-func TestParseDescriptionI18n_DuplicateLang(t *testing.T) {
-	_, err := parseDescriptionI18n([]string{"zh_cn=a", "zh_cn=b"})
-	if err == nil {
-		t.Fatal("expected duplicate language error")
-	}
-	p, ok := errs.ProblemOf(err)
-	if !ok || p.Category != errs.CategoryValidation || p.Subtype != errs.SubtypeInvalidArgument {
-		t.Fatalf("expected validation/invalid_argument, got %v", err)
-	}
-	var validationErr *errs.ValidationError
-	if !errors.As(err, &validationErr) || validationErr.Param != "--description-i18n" {
-		t.Fatalf("expected param --description-i18n, got %#v", validationErr)
-	}
-}
-
-func TestValidateCommandName(t *testing.T) {
-	if err := validateCommandName("greet", "--command"); err != nil {
-		t.Fatalf("greet: %v", err)
-	}
-	for _, bad := range []string{"", "  ", "/greet"} {
-		if err := validateCommandName(bad, "--command"); err == nil {
-			t.Errorf("%q: expected error", bad)
-		}
-	}
-}
-
-func TestBuildSlashCommandBody(t *testing.T) {
-	body := buildSlashCommandBody("greet", "hi", map[string]string{"zh_cn": "你好"}, "skill_outlined")
-	if body["command"] != "greet" {
-		t.Errorf("command = %v", body["command"])
-	}
-	desc := body["description"].(map[string]interface{})
-	if desc["default_value"] != "hi" {
-		t.Errorf("default_value = %v", desc["default_value"])
-	}
-	if desc["i18n"].(map[string]string)["zh_cn"] != "你好" {
-		t.Errorf("i18n = %v", desc["i18n"])
-	}
-	// icon 与 description 顶层平级（实测钉死，文档 create 示例是笔误）
-	if body["icon"].(map[string]interface{})["icon_key"] != "skill_outlined" {
-		t.Errorf("icon = %v", body["icon"])
-	}
-	// partial：不提供的字段不出现（PATCH 语义依赖）
-	partial := buildSlashCommandBody("", "", nil, "skill_outlined")
-	if _, has := partial["command"]; has {
-		t.Error("empty command must be omitted")
-	}
-	if _, has := partial["description"]; has {
-		t.Error("empty description must be omitted")
-	}
-}
-
-func TestIsCommandExists(t *testing.T) {
-	tests := []struct {
-		name string
-		err  error
-		want bool
-	}{
-		{
-			name: "matching code and message",
-			err: errs.NewAPIError(errs.SubtypeUnknown,
-				"Invalid Param 'command'. command already exists.").WithCode(40000000),
-			want: true,
-		},
-		{
-			name: "same message with different code",
-			err: errs.NewAPIError(errs.SubtypeUnknown,
-				"Invalid Param 'command'. command already exists.").WithCode(40000031),
-		},
-		{
-			name: "same code with different message",
-			err: errs.NewAPIError(errs.SubtypeUnknown,
-				"Invalid Param 'icon_key'. icon_key is invalid.").WithCode(40000000),
-		},
-		{name: "nil error"},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if got := isCommandExists(tt.err); got != tt.want {
-				t.Fatalf("isCommandExists() = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}
-
-// TestSlashCommandShortcuts_SharedScopesAcrossIdentities locks in the
-// reversal of the OAuth-isolation design: all four slash-command shortcuts
-// declare identical scopes for the bot and user identities (plain Scopes /
-// ConditionalScopes, no per-identity overrides), so a user-identity
-// pre-flight sees the same scope set a bot identity would.
-func TestSlashCommandShortcuts_SharedScopesAcrossIdentities(t *testing.T) {
-	cases := []struct {
-		name            string
-		shortcut        common.Shortcut
-		wantScope       string
-		wantConditional string
-		hasConditional  bool
-	}{
-		{
-			name:      "list",
-			shortcut:  SlashCommandList,
-			wantScope: "application:app_slash_command:read",
-		},
-		{
-			name:            "create",
-			shortcut:        SlashCommandCreate,
-			wantScope:       "application:app_slash_command:write",
-			wantConditional: "application:app_slash_command:read",
-			hasConditional:  true,
-		},
-		{
-			name:            "update",
-			shortcut:        SlashCommandUpdate,
-			wantScope:       "application:app_slash_command:write",
-			wantConditional: "application:app_slash_command:read",
-			hasConditional:  true,
-		},
-		{
-			name:            "delete",
-			shortcut:        SlashCommandDelete,
-			wantScope:       "application:app_slash_command:write",
-			wantConditional: "application:app_slash_command:read",
-			hasConditional:  true,
-		},
-	}
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			for _, identity := range []string{"user", "bot"} {
-				declared := tc.shortcut.DeclaredScopesForIdentity(identity)
-				if !containsStr(declared, tc.wantScope) {
-					t.Errorf("%s: DeclaredScopesForIdentity(%q) = %v, want to contain %q", tc.name, identity, declared, tc.wantScope)
-				}
-				if tc.hasConditional && !containsStr(declared, tc.wantConditional) {
-					t.Errorf("%s: DeclaredScopesForIdentity(%q) = %v, want to contain conditional %q", tc.name, identity, declared, tc.wantConditional)
-				}
-			}
-		})
-	}
-}
-
-func containsStr(list []string, want string) bool {
-	for _, v := range list {
-		if v == want {
-			return true
-		}
-	}
-	return false
-}

shortcuts/application/slash_command_create.go

@@ -1,118 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package application
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"strings"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/shortcuts/common"
-)
-
-// SlashCommandCreate registers a new slash command on the current bound app.
-var SlashCommandCreate = common.Shortcut{
-	Service:     "application",
-	Command:     "+slash-command-create",
-	Description: "Register a slash command (/ command) on the current bound Open Platform app; --force converts a name collision into an update (idempotent re-run)",
-	Risk:        "write",
-	Scopes:      []string{"application:app_slash_command:write"},
-	ConditionalScopes: []string{
-		"application:app_slash_command:read", // only the --force collision path lists to resolve the id
-	},
-	AuthTypes: []string{"bot", "user"},
-	Flags: []common.Flag{
-		{Name: "command", Desc: "command name WITHOUT the leading slash (server enforces uniqueness per app; max 100 commands)", Required: true},
-		{Name: "description", Desc: "default description shown in the client command panel (description.default_value)", Required: true},
-		{Name: "description-i18n", Type: "string_array", Desc: "localized description, repeatable, format <lang>=<text> (e.g. zh_cn=发送问候); language codes are passed through to the server"},
-		{Name: "icon-key", Desc: "icon key (server default: skill_outlined; invalid keys are rejected server-side with code 40000031)"},
-		{Name: "force", Type: "bool", Desc: "on name collision, resolve the existing command by name and update it in place"},
-	},
-	Tips: []string{
-		`lark-cli application +slash-command-create --command greet --description "say hi" --description-i18n zh_cn=问候 --as bot`,
-		"changes take ~5 minutes to appear in clients (client-side cache); the server updates immediately",
-		"user identity needs explicit authorization first: lark-cli auth login --scope application:app_slash_command:write",
-	},
-	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		if err := validateCommandName(runtime.Str("command"), "--command"); err != nil {
-			return err
-		}
-		if len(strings.TrimSpace(runtime.Str("description"))) == 0 {
-			return errs.NewValidationError(errs.SubtypeInvalidArgument,
-				"--description must not be blank").WithParam("--description")
-		}
-		if _, err := parseDescriptionI18n(runtime.StrArray("description-i18n")); err != nil {
-			return err
-		}
-		return nil
-	},
-	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
-		i18n, err := parseDescriptionI18n(runtime.StrArray("description-i18n"))
-		if err != nil {
-			// The CLI validates first; keep this guard for direct DryRun callers.
-			return common.NewDryRunAPI().Set("error", err.Error())
-		}
-		name := strings.TrimSpace(runtime.Str("command"))
-		body := buildSlashCommandBody(name, runtime.Str("description"), i18n, runtime.Str("icon-key"))
-		d := common.NewDryRunAPI().
-			Desc("Create a slash command on the current bound app").
-			POST(slashCommandBasePath).
-			Body(body)
-		if runtime.Bool("force") {
-			d.Desc("--force: on 'command already exists' (code 40000000), GET list to resolve command_id then PATCH the same body")
-		}
-		return d
-	},
-	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		name := strings.TrimSpace(runtime.Str("command"))
-		i18n, err := parseDescriptionI18n(runtime.StrArray("description-i18n"))
-		if err != nil {
-			return err
-		}
-		body := buildSlashCommandBody(name, runtime.Str("description"), i18n, runtime.Str("icon-key"))
-
-		data, err := runtime.CallAPITyped("POST", slashCommandBasePath, nil, body)
-		action := "created"
-		if err != nil {
-			if !isCommandExists(err) {
-				return err
-			}
-			if !runtime.Bool("force") {
-				p, _ := errs.ProblemOf(err)
-				rewrapped := errs.NewAPIError(errs.SubtypeAlreadyExists, "slash command %q already exists", name).
-					WithHint("rerun with --force to update it, or use `lark-cli application +slash-command-update --command %q`", name).
-					WithCause(err)
-				if p.Code != 0 {
-					rewrapped = rewrapped.WithCode(p.Code)
-				}
-				if p.LogID != "" {
-					rewrapped = rewrapped.WithLogID(p.LogID)
-				}
-				return rewrapped
-			}
-			// --force: name collision -> resolve id -> PATCH (idempotent re-run).
-			id, rerr := resolveCommandID(runtime, name)
-			if rerr != nil {
-				return rerr
-			}
-			patchBody := buildSlashCommandBody("", runtime.Str("description"), i18n, runtime.Str("icon-key"))
-			data, err = runtime.CallAPITyped("PATCH", slashCommandBasePath+"/"+encodeCommandIDPathSegment(id), nil, patchBody)
-			if err != nil {
-				return err
-			}
-			action = "updated"
-		}
-		if data == nil {
-			data = map[string]interface{}{}
-		}
-		data["action"] = action
-		fmt.Fprintln(runtime.IO().ErrOut, clientCacheHint)
-		runtime.OutFormat(data, nil, func(w io.Writer) {
-			fmt.Fprintf(w, "%s /%v (command_id: %v)\n", action, data["command"], data["command_id"])
-		})
-		return nil
-	},
-}

shortcuts/application/slash_command_create_test.go

@@ -1,229 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package application
-
-import (
-	"encoding/json"
-	"errors"
-	"strings"
-	"testing"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/internal/cmdutil"
-	"github.com/larksuite/cli/internal/httpmock"
-	"github.com/spf13/cobra"
-	"github.com/spf13/pflag"
-)
-
-func createOKStub() *httpmock.Stub {
-	return &httpmock.Stub{
-		Method: "POST",
-		URL:    "/open-apis/application/v7/app_slash_commands",
-		Body: map[string]interface{}{
-			"code": 0, "msg": "success",
-			"data": sampleItem("greet", "id-new"),
-		},
-	}
-}
-
-func createConflictStub() *httpmock.Stub {
-	return &httpmock.Stub{
-		Method: "POST",
-		URL:    "/open-apis/application/v7/app_slash_commands",
-		Body: map[string]interface{}{
-			"code": 40000000, "msg": "Invalid Param 'command'. command already exists.",
-		},
-	}
-}
-
-func patchOKStub(id string) *httpmock.Stub {
-	return &httpmock.Stub{
-		Method: "PATCH",
-		URL:    "/open-apis/application/v7/app_slash_commands/" + id,
-		Body: map[string]interface{}{
-			"code": 0, "msg": "success",
-			"data": sampleItem("greet", id),
-		},
-	}
-}
-
-func TestSlashCommandCreate_OK(t *testing.T) {
-	f, stdout, _, reg := cmdutil.TestFactory(t, appTestConfig())
-	reg.Register(createOKStub())
-
-	err := mountAndRun(t, SlashCommandCreate, []string{"+slash-command-create",
-		"--command", "greet", "--description", "hi",
-		"--description-i18n", "zh_cn=你好", "--description-i18n", "en_us=Hello",
-		"--icon-key", "skill_outlined", "--format", "json", "--as", "bot"}, f, stdout)
-	if err != nil {
-		t.Fatalf("execute: %v", err)
-	}
-	var got map[string]interface{}
-	if err := json.Unmarshal(stdout.Bytes(), &got); err != nil {
-		t.Fatalf("json: %v\n%s", err, stdout.String())
-	}
-	data := got["data"].(map[string]interface{})
-	if data["action"] != "created" {
-		t.Fatalf("action = %v", data["action"])
-	}
-	if data["command_id"] != "id-new" {
-		t.Fatalf("command_id = %v", data["command_id"])
-	}
-}
-
-func TestSlashCommandCreate_ValidateRejects(t *testing.T) {
-	f, stdout, _, _ := cmdutil.TestFactory(t, appTestConfig())
-	cases := [][]string{
-		{"+slash-command-create", "--command", "/greet", "--description", "hi", "--as", "bot"},
-		{"+slash-command-create", "--command", "greet", "--description", "hi", "--description-i18n", "bad", "--as", "bot"},
-		{"+slash-command-create", "--command", "greet", "--description", "hi", "--description-i18n", "zh_cn=a", "--description-i18n", "zh_cn=b", "--as", "bot"},
-		{"+slash-command-create", "--command", "greet", "--description", "  ", "--as", "bot"},
-	}
-	for i, args := range cases {
-		err := mountAndRun(t, SlashCommandCreate, args, f, stdout)
-		if err == nil {
-			t.Errorf("case %d: expected validation error", i)
-			continue
-		}
-		p, ok := errs.ProblemOf(err)
-		if !ok || p.Category != errs.CategoryValidation {
-			t.Errorf("case %d: expected validation problem, got %v", i, err)
-		}
-	}
-}
-
-func TestSlashCommandCreate_ConflictNoForce(t *testing.T) {
-	f, stdout, _, reg := cmdutil.TestFactory(t, appTestConfig())
-	reg.Register(createConflictStub())
-
-	err := mountAndRun(t, SlashCommandCreate, []string{"+slash-command-create",
-		"--command", "greet", "--description", "hi", "--as", "bot"}, f, stdout)
-	if err == nil {
-		t.Fatal("expected conflict error")
-	}
-	p, _ := errs.ProblemOf(err)
-	if p == nil || p.Category != errs.CategoryAPI || p.Subtype != errs.SubtypeAlreadyExists || p.Code != 40000000 {
-		t.Fatalf("expected api/already_exists code 40000000, got %#v", p)
-	}
-	if !strings.Contains(p.Hint, "--force") || !strings.Contains(p.Hint, "+slash-command-update") {
-		t.Fatalf("hint must offer --force and update, got %q", p.Hint)
-	}
-	var apiErr *errs.APIError
-	if !errors.As(err, &apiErr) {
-		t.Fatalf("rewrapped error must be *errs.APIError, got %T", err)
-	}
-	if errors.Unwrap(apiErr) == nil {
-		t.Fatal("rewrapped conflict error must preserve the original cause via WithCause")
-	}
-}
-
-func TestSlashCommandCreate_ForceConvertsToUpdate(t *testing.T) {
-	f, stdout, _, reg := cmdutil.TestFactory(t, appTestConfig())
-	reg.Register(createConflictStub())
-	reg.Register(listStub([]interface{}{sampleItem("greet", "id-exist")}))
-	reg.Register(patchOKStub("id-exist"))
-
-	err := mountAndRun(t, SlashCommandCreate, []string{"+slash-command-create",
-		"--command", "greet", "--description", "hi2", "--force", "--format", "json", "--as", "bot"}, f, stdout)
-	if err != nil {
-		t.Fatalf("execute: %v", err)
-	}
-	var got map[string]interface{}
-	if err := json.Unmarshal(stdout.Bytes(), &got); err != nil {
-		t.Fatalf("json: %v", err)
-	}
-	data := got["data"].(map[string]interface{})
-	if data["action"] != "updated" {
-		t.Fatalf("action = %v (force must convert to update)", data["action"])
-	}
-}
-
-func TestSlashCommandCreate_TrimsCommandBeforeCreateAndForceResolution(t *testing.T) {
-	f, stdout, _, reg := cmdutil.TestFactory(t, appTestConfig())
-	conflict := createConflictStub()
-	reg.Register(conflict)
-	reg.Register(listStub([]interface{}{sampleItem("greet", "id-exist")}))
-	reg.Register(patchOKStub("id-exist"))
-
-	err := mountAndRun(t, SlashCommandCreate, []string{"+slash-command-create",
-		"--command", " greet ", "--description", "hi", "--force", "--as", "bot"}, f, stdout)
-	if err != nil {
-		t.Fatalf("execute: %v", err)
-	}
-	var body map[string]interface{}
-	if err := json.Unmarshal(conflict.CapturedBody, &body); err != nil {
-		t.Fatalf("decode captured create body: %v", err)
-	}
-	if body["command"] != "greet" {
-		t.Fatalf("command = %q, want trimmed value %q", body["command"], "greet")
-	}
-}
-
-func createIconInvalidStub() *httpmock.Stub {
-	return &httpmock.Stub{
-		Method: "POST",
-		URL:    "/open-apis/application/v7/app_slash_commands",
-		Body: map[string]interface{}{
-			"code": 40000031, "msg": "Invalid Param 'icon_key'. icon_key is invalid.",
-		},
-	}
-}
-
-// TestSlashCommandCreate_ForceDoesNotConvertNonConflict guards against --force
-// blindly treating ANY POST failure as a name collision: only the
-// "command already exists" (40000000) shape may fall through to the
-// GET+PATCH idempotent-update path. No PATCH stub is registered here, so if
-// the code mistakenly attempted a PATCH, the httpmock registry would fail
-// the unexpected request and surface a different (registry) error instead
-// of the original icon_key failure asserted below.
-func TestSlashCommandCreate_ForceDoesNotConvertNonConflict(t *testing.T) {
-	f, stdout, _, reg := cmdutil.TestFactory(t, appTestConfig())
-	reg.Register(createIconInvalidStub())
-
-	err := mountAndRun(t, SlashCommandCreate, []string{"+slash-command-create",
-		"--command", "greet", "--description", "hi", "--icon-key", "bogus", "--force", "--as", "bot"}, f, stdout)
-	if err == nil {
-		t.Fatal("expected the original icon_key error, got nil")
-	}
-	p, ok := errs.ProblemOf(err)
-	if !ok || p.Category != errs.CategoryAPI || p.Subtype == errs.SubtypeAlreadyExists || p.Code != 40000031 {
-		t.Fatalf("expected original API error code 40000031 without collision reclassification, got %#v", p)
-	}
-}
-
-func TestSlashCommandCreate_DryRun(t *testing.T) {
-	f, stdout, _, _ := cmdutil.TestFactory(t, appTestConfig())
-	if err := mountAndRun(t, SlashCommandCreate, []string{"+slash-command-create",
-		"--command", "greet", "--description", "hi", "--icon-key", "skill_outlined", "--dry-run", "--as", "bot"}, f, stdout); err != nil {
-		t.Fatalf("execute: %v", err)
-	}
-	out := stdout.String()
-	if !strings.Contains(out, "POST") || !strings.Contains(out, slashCommandBasePath) {
-		t.Fatalf("dry-run must show POST path: %s", out)
-	}
-	// icon 顶层：dry-run body 里 icon 不嵌套在 description 内
-	if !strings.Contains(out, "icon_key") {
-		t.Fatalf("dry-run must include body: %s", out)
-	}
-}
-
-func TestSlashCommandCreate_ForceHelpHasNoMetavar(t *testing.T) {
-	parent := &cobra.Command{Use: "application"}
-	SlashCommandCreate.Mount(parent, &cmdutil.Factory{})
-	cmd := parent.Commands()[0]
-	forceFlag := cmd.Flags().Lookup("force")
-	if forceFlag == nil {
-		t.Fatal("missing --force flag")
-	}
-	placeholder, usage := pflag.UnquoteUsage(forceFlag)
-	if placeholder != "" {
-		t.Fatalf("boolean --force must not render a value placeholder, got %q", placeholder)
-	}
-	if !strings.Contains(usage, "update it in place") || strings.Contains(usage, "gh ") {
-		t.Fatalf("unexpected --force help: %q", usage)
-	}
-	if help := cmd.Flags().FlagUsages(); !strings.Contains(help, "--force") || !strings.Contains(help, "update it in place") {
-		t.Fatalf("rendered help missing --force description:\n%s", help)
-	}
-}

shortcuts/application/slash_command_delete.go

@@ -1,85 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package application
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"strings"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/shortcuts/common"
-)
-
-// SlashCommandDelete removes a slash command (irreversible; command_id is not
-// reused - recreating the same name yields a NEW id).
-var SlashCommandDelete = common.Shortcut{
-	Service:     "application",
-	Command:     "+slash-command-delete",
-	Description: "Delete a slash command from the current bound app (high-risk: irreversible; recreating the same name yields a new command_id)",
-	Risk:        "high-risk-write",
-	Scopes:      []string{"application:app_slash_command:write"},
-	ConditionalScopes: []string{
-		"application:app_slash_command:read", // only the --command by-name path
-	},
-	AuthTypes: []string{"bot", "user"},
-	Flags: []common.Flag{
-		{Name: "command-id", Desc: "target command_id; mutually exclusive with --command"},
-		{Name: "command", Desc: "target command name WITHOUT leading slash (resolved via live list, needs read scope); mutually exclusive with --command-id"},
-	},
-	Tips: []string{
-		"lark-cli application +slash-command-delete --command greet --yes --as bot",
-		"deleted commands may linger in clients for ~5 minutes (client cache)",
-	},
-	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		id := strings.TrimSpace(runtime.Str("command-id"))
-		name := strings.TrimSpace(runtime.Str("command"))
-		if (id == "") == (name == "") {
-			return errs.NewValidationError(errs.SubtypeInvalidArgument,
-				"provide exactly one of --command-id or --command").WithParam("--command-id")
-		}
-		if name != "" {
-			return validateCommandName(name, "--command")
-		}
-		return nil
-	},
-	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
-		d := common.NewDryRunAPI().Desc("HIGH-RISK: delete a slash command (irreversible; same-name recreate gets a NEW command_id)")
-		target := strings.TrimSpace(runtime.Str("command-id"))
-		if target == "" {
-			name := strings.TrimSpace(runtime.Str("command"))
-			d.GET(slashCommandBasePath).
-				Desc(fmt.Sprintf("resolve command_id by name %q via GET list first", name))
-			target = "<resolved_command_id>"
-		} else {
-			target = encodeCommandIDPathSegment(target)
-		}
-		return d.DELETE(slashCommandBasePath + "/" + target)
-	},
-	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		id := strings.TrimSpace(runtime.Str("command-id"))
-		name := strings.TrimSpace(runtime.Str("command"))
-		if id == "" {
-			resolved, err := resolveCommandID(runtime, name)
-			if err != nil {
-				return err
-			}
-			id = resolved
-		}
-		if _, err := runtime.CallAPITyped("DELETE", slashCommandBasePath+"/"+encodeCommandIDPathSegment(id), nil, nil); err != nil {
-			return err
-		}
-		out := map[string]interface{}{"action": "deleted", "command_id": id}
-		if name != "" {
-			out["command"] = name
-		}
-		fmt.Fprintln(runtime.IO().ErrOut, clientCacheHint)
-		fmt.Fprintln(runtime.IO().ErrOut, "note: recreating the same command name will yield a NEW command_id.")
-		runtime.OutFormat(out, nil, func(w io.Writer) {
-			fmt.Fprintf(w, "deleted command_id %s\n", id)
-		})
-		return nil
-	},
-}

shortcuts/application/slash_command_delete_test.go

@@ -1,135 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package application
-
-import (
-	"encoding/json"
-	"strings"
-	"testing"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/internal/cmdutil"
-	"github.com/larksuite/cli/internal/httpmock"
-)
-
-func deleteOKStub(id string) *httpmock.Stub {
-	return &httpmock.Stub{
-		Method: "DELETE",
-		URL:    slashCommandBasePath + "/" + id,
-		Body:   map[string]interface{}{"code": 0, "msg": "success", "data": map[string]interface{}{}},
-	}
-}
-
-func TestSlashCommandDelete_RequiresYes(t *testing.T) {
-	f, stdout, _, _ := cmdutil.TestFactory(t, appTestConfig())
-	err := mountAndRun(t, SlashCommandDelete, []string{"+slash-command-delete",
-		"--command-id", "id1", "--as", "bot"}, f, stdout)
-	if err == nil {
-		t.Fatal("expected confirmation_required without --yes")
-	}
-	if errs.CategoryOf(err) != errs.CategoryConfirmation {
-		t.Fatalf("expected confirmation category, got %v (%v)", errs.CategoryOf(err), err)
-	}
-}
-
-func TestSlashCommandDelete_ByIDWithYes(t *testing.T) {
-	f, stdout, _, reg := cmdutil.TestFactory(t, appTestConfig())
-	reg.Register(deleteOKStub("id1"))
-
-	err := mountAndRun(t, SlashCommandDelete, []string{"+slash-command-delete",
-		"--command-id", "id1", "--yes", "--format", "json", "--as", "bot"}, f, stdout)
-	if err != nil {
-		t.Fatalf("execute: %v", err)
-	}
-	var got map[string]interface{}
-	if err := json.Unmarshal(stdout.Bytes(), &got); err != nil {
-		t.Fatalf("json: %v", err)
-	}
-	data := got["data"].(map[string]interface{})
-	// 上游 DELETE 返回空对象；CLI 必须补 action/command_id（写操作返回资源 ID）
-	if data["action"] != "deleted" || data["command_id"] != "id1" {
-		t.Fatalf("data = %v", data)
-	}
-}
-
-func TestSlashCommandDelete_ByNameWithYes(t *testing.T) {
-	f, stdout, _, reg := cmdutil.TestFactory(t, appTestConfig())
-	reg.Register(listStub([]interface{}{sampleItem("greet", "id7")}))
-	reg.Register(deleteOKStub("id7"))
-
-	err := mountAndRun(t, SlashCommandDelete, []string{"+slash-command-delete",
-		"--command", "greet", "--yes", "--format", "json", "--as", "bot"}, f, stdout)
-	if err != nil {
-		t.Fatalf("execute: %v", err)
-	}
-	var got map[string]interface{}
-	if err := json.Unmarshal(stdout.Bytes(), &got); err != nil {
-		t.Fatalf("json: %v", err)
-	}
-	data := got["data"].(map[string]interface{})
-	if data["command"] != "greet" || data["command_id"] != "id7" {
-		t.Fatalf("data = %v", data)
-	}
-}
-
-func TestSlashCommandDelete_ByNameDryRun(t *testing.T) {
-	f, stdout, _, _ := cmdutil.TestFactory(t, appTestConfig())
-
-	err := mountAndRun(t, SlashCommandDelete, []string{"+slash-command-delete",
-		"--command", "greet", "--dry-run", "--as", "bot"}, f, stdout)
-	if err != nil {
-		t.Fatalf("execute: %v", err)
-	}
-	var envlp struct {
-		Data struct {
-			Description string `json:"description"`
-			API         []struct {
-				Desc   string `json:"desc"`
-				Method string `json:"method"`
-			} `json:"api"`
-		} `json:"data"`
-	}
-	if err := json.Unmarshal(stdout.Bytes(), &envlp); err != nil {
-		t.Fatalf("json: %v", err)
-	}
-	got := envlp.Data
-	if !strings.Contains(got.Description, "HIGH-RISK") || strings.Contains(got.Description, "resolve command_id") {
-		t.Fatalf("top-level description must contain only the risk context: %q", got.Description)
-	}
-	if len(got.API) != 2 || got.API[0].Method != "GET" || !strings.Contains(got.API[0].Desc, "resolve command_id") {
-		t.Fatalf("first call must describe name resolution: %#v", got.API)
-	}
-	if got.API[1].Method != "DELETE" || strings.Contains(got.API[1].Desc, "resolve command_id") {
-		t.Fatalf("second call must be the delete without the resolve description: %#v", got.API)
-	}
-}
-
-func TestSlashCommandDelete_Validate(t *testing.T) {
-	f, stdout, _, _ := cmdutil.TestFactory(t, appTestConfig())
-	for _, args := range [][]string{
-		{"+slash-command-delete", "--yes", "--as", "bot"},
-		{"+slash-command-delete", "--command-id", "id1", "--command", "greet", "--yes", "--as", "bot"},
-	} {
-		err := mountAndRun(t, SlashCommandDelete, args, f, stdout)
-		if err == nil {
-			t.Errorf("%v: expected validation error", args)
-			continue
-		}
-		p, ok := errs.ProblemOf(err)
-		if !ok || p.Category != errs.CategoryValidation || p.Subtype != errs.SubtypeInvalidArgument {
-			t.Errorf("%v: expected validation problem, got %v", args, err)
-		}
-	}
-}
-
-func TestSlashCommandDelete_ByIDEncodesTrimmedPathSegment(t *testing.T) {
-	f, stdout, _, reg := cmdutil.TestFactory(t, appTestConfig())
-	reg.Register(deleteOKStub("id%2Fwith%20space%3Fx"))
-
-	err := mountAndRun(t, SlashCommandDelete, []string{"+slash-command-delete",
-		"--command-id", " id/with space?x ", "--yes", "--as", "bot"}, f, stdout)
-	if err != nil {
-		t.Fatalf("execute: %v", err)
-	}
-}

shortcuts/application/slash_command_list.go

@@ -1,58 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package application
-
-import (
-	"context"
-	"fmt"
-	"io"
-
-	"github.com/larksuite/cli/shortcuts/common"
-)
-
-// SlashCommandList lists all slash commands of the current bound app.
-var SlashCommandList = common.Shortcut{
-	Service:     "application",
-	Command:     "+slash-command-list",
-	Description: "List all slash commands (/ commands) registered on the currently bound Open Platform app; source of command_id for update/delete",
-	Risk:        "read",
-	Scopes:      []string{"application:app_slash_command:read"},
-	AuthTypes:   []string{"bot", "user"},
-	Tips: []string{
-		"lark-cli application +slash-command-list --as bot",
-		"user identity needs explicit authorization first: lark-cli auth login --scope application:app_slash_command:read",
-		"the upstream API returns all commands at once (max 100 per app, no pagination)",
-	},
-	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
-		return common.NewDryRunAPI().
-			Desc("List all slash commands of the current bound app (read-only)").
-			GET(slashCommandBasePath)
-	},
-	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		data, err := runtime.CallAPITyped("GET", slashCommandBasePath, nil, nil)
-		if err != nil {
-			return err
-		}
-		items, _ := data["items"].([]interface{})
-		if items == nil {
-			items = []interface{}{}
-		}
-		out := map[string]interface{}{"items": items, "count": len(items)}
-		runtime.OutFormat(out, nil, func(w io.Writer) {
-			fmt.Fprintf(w, "%d slash command(s)\n", len(items))
-			for _, it := range items {
-				m, ok := it.(map[string]interface{})
-				if !ok {
-					continue
-				}
-				desc := ""
-				if d, ok := m["description"].(map[string]interface{}); ok {
-					desc, _ = d["default_value"].(string)
-				}
-				fmt.Fprintf(w, "  /%v\t%v\t%s\n", m["command"], m["command_id"], desc)
-			}
-		})
-		return nil
-	},
-}

shortcuts/application/slash_command_list_test.go

@@ -1,115 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package application
-
-import (
-	"bytes"
-	"encoding/json"
-	"strings"
-	"testing"
-
-	"github.com/larksuite/cli/internal/cmdutil"
-	"github.com/larksuite/cli/internal/core"
-	"github.com/larksuite/cli/internal/httpmock"
-	"github.com/larksuite/cli/shortcuts/common"
-	"github.com/spf13/cobra"
-)
-
-func appTestConfig() *core.CliConfig {
-	return &core.CliConfig{AppID: "test-app", AppSecret: "test-secret", Brand: core.BrandFeishu}
-}
-
-// mountAndRun mounts the shortcut under a parent cobra command and runs it.
-// Mirrors shortcuts/contact tests.
-func mountAndRun(t *testing.T, s common.Shortcut, args []string, f *cmdutil.Factory, stdout *bytes.Buffer) error {
-	t.Helper()
-	parent := &cobra.Command{Use: "application"}
-	s.Mount(parent, f)
-	parent.SetArgs(args)
-	parent.SilenceErrors = true
-	parent.SilenceUsage = true
-	if stdout != nil {
-		stdout.Reset()
-	}
-	return parent.Execute()
-}
-
-func listStub(items []interface{}) *httpmock.Stub {
-	return &httpmock.Stub{
-		Method: "GET",
-		URL:    "/open-apis/application/v7/app_slash_commands",
-		Body: map[string]interface{}{
-			"code": 0, "msg": "success",
-			"data": map[string]interface{}{"items": items},
-		},
-	}
-}
-
-func sampleItem(name, id string) map[string]interface{} {
-	return map[string]interface{}{
-		"command": name, "command_id": id,
-		"create_time": "1783318553", "update_time": "1783318553",
-		"description": map[string]interface{}{"default_value": "desc of " + name},
-		"icon":        map[string]interface{}{"icon_key": "skill_outlined"},
-	}
-}
-
-func TestSlashCommandList_JSON(t *testing.T) {
-	f, stdout, _, reg := cmdutil.TestFactory(t, appTestConfig())
-	reg.Register(listStub([]interface{}{sampleItem("greet", "id1"), sampleItem("weather", "id2")}))
-
-	if err := mountAndRun(t, SlashCommandList, []string{"+slash-command-list", "--format", "json", "--as", "bot"}, f, stdout); err != nil {
-		t.Fatalf("execute: %v", err)
-	}
-	var got map[string]interface{}
-	if err := json.Unmarshal(stdout.Bytes(), &got); err != nil {
-		t.Fatalf("json: %v\n%s", err, stdout.String())
-	}
-	data := got["data"].(map[string]interface{})
-	items := data["items"].([]interface{})
-	if len(items) != 2 {
-		t.Fatalf("items = %d", len(items))
-	}
-	if data["count"] != float64(2) {
-		t.Fatalf("count = %v", data["count"])
-	}
-	first := items[0].(map[string]interface{})
-	for _, k := range []string{"command", "command_id", "description", "icon", "create_time", "update_time"} {
-		if _, ok := first[k]; !ok {
-			t.Errorf("missing item key %q", k)
-		}
-	}
-}
-
-func TestSlashCommandList_Empty(t *testing.T) {
-	f, stdout, _, reg := cmdutil.TestFactory(t, appTestConfig())
-	reg.Register(listStub(nil))
-
-	if err := mountAndRun(t, SlashCommandList, []string{"+slash-command-list", "--format", "json", "--as", "bot"}, f, stdout); err != nil {
-		t.Fatalf("execute: %v", err)
-	}
-	var got map[string]interface{}
-	if err := json.Unmarshal(stdout.Bytes(), &got); err != nil {
-		t.Fatalf("json: %v", err)
-	}
-	data := got["data"].(map[string]interface{})
-	items, ok := data["items"].([]interface{})
-	if !ok || len(items) != 0 {
-		t.Fatalf("empty list must be [] not %v", data["items"])
-	}
-	if data["count"] != float64(0) {
-		t.Fatalf("count = %v", data["count"])
-	}
-}
-
-func TestSlashCommandList_DryRun(t *testing.T) {
-	f, stdout, _, _ := cmdutil.TestFactory(t, appTestConfig())
-	if err := mountAndRun(t, SlashCommandList, []string{"+slash-command-list", "--dry-run", "--as", "bot"}, f, stdout); err != nil {
-		t.Fatalf("execute: %v", err)
-	}
-	out := stdout.String()
-	if !strings.Contains(out, "/open-apis/application/v7/app_slash_commands") || !strings.Contains(out, "GET") {
-		t.Fatalf("dry-run must show GET path, got %s", out)
-	}
-}

shortcuts/application/slash_command_resolve.go

@@ -1,54 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package application
-
-import (
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/shortcuts/common"
-)
-
-// matchCommandID finds the command_id of the item whose "command" equals
-// name (exact match - the server enforces name uniqueness, so first hit is the
-// only hit).
-func matchCommandID(items []interface{}, name string) string {
-	for _, it := range items {
-		m, ok := it.(map[string]interface{})
-		if !ok {
-			continue
-		}
-		if m["command"] == name {
-			id, _ := m["command_id"].(string)
-			if id != "" {
-				return id
-			}
-		}
-	}
-	return ""
-}
-
-// commandNotFoundError reports a resolution miss against the live list as an
-// API-category not-found error (the name is a valid argument shape; the
-// resource simply does not exist server-side - this is not a validation
-// failure of caller input).
-func commandNotFoundError(name string) error {
-	return errs.NewAPIError(errs.SubtypeNotFound,
-		"slash command %q not found in the current bound app", name).
-		WithHint("run `lark-cli application +slash-command-list` to see registered commands")
-}
-
-// resolveCommandID resolves a command name to its command_id via the live
-// list endpoint (in-memory only; never touches local files). Requires the
-// read scope on the current identity.
-func resolveCommandID(runtime *common.RuntimeContext, name string) (string, error) {
-	data, err := runtime.CallAPITyped("GET", slashCommandBasePath, nil, nil)
-	if err != nil {
-		return "", err
-	}
-	items, _ := data["items"].([]interface{})
-	id := matchCommandID(items, name)
-	if id == "" {
-		return "", commandNotFoundError(name)
-	}
-	return id, nil
-}

shortcuts/application/slash_command_resolve_test.go

@@ -1,41 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package application
-
-import (
-	"testing"
-
-	"github.com/larksuite/cli/errs"
-)
-
-func TestMatchCommandID(t *testing.T) {
-	items := []interface{}{
-		sampleItem("greet", "id1"),
-		sampleItem("weather", "id2"),
-	}
-	id := matchCommandID(items, "weather")
-	if id != "id2" {
-		t.Fatalf("got id=%q", id)
-	}
-	id = matchCommandID(items, "nope")
-	if id != "" {
-		t.Fatalf("miss should return empty, got id=%q", id)
-	}
-	// 精确匹配：大小写与空白不做宽容
-	id = matchCommandID(items, "Greet")
-	if id != "" {
-		t.Fatalf("match must be exact, got %q", id)
-	}
-}
-
-func TestResolveNotFoundErrorShape(t *testing.T) {
-	err := commandNotFoundError("nope")
-	if err == nil {
-		t.Fatalf("err = %v", err)
-	}
-	p, ok := errs.ProblemOf(err)
-	if !ok || p.Category != errs.CategoryAPI || p.Subtype != errs.SubtypeNotFound {
-		t.Fatalf("expected api/not_found, got %#v", p)
-	}
-}

shortcuts/application/slash_command_update.go

@@ -1,124 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package application
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"strings"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/shortcuts/common"
-)
-
-// validateUpdateTarget enforces: exactly one of --command-id/--command, and at
-// least one editable field; --description-i18n requires --description (PATCH
-// replaces the whole description object - sending i18n alone would drop
-// default_value, so both values must be provided together).
-func validateUpdateTarget(runtime *common.RuntimeContext) error {
-	id := strings.TrimSpace(runtime.Str("command-id"))
-	name := strings.TrimSpace(runtime.Str("command"))
-	if (id == "") == (name == "") {
-		return errs.NewValidationError(errs.SubtypeInvalidArgument,
-			"provide exactly one of --command-id or --command").WithParam("--command-id")
-	}
-	if name != "" {
-		if err := validateCommandName(name, "--command"); err != nil {
-			return err
-		}
-	}
-	hasDesc := strings.TrimSpace(runtime.Str("description")) != ""
-	hasI18n := len(runtime.StrArray("description-i18n")) > 0
-	hasIcon := strings.TrimSpace(runtime.Str("icon-key")) != ""
-	if !hasDesc && !hasI18n && !hasIcon {
-		return errs.NewValidationError(errs.SubtypeInvalidArgument,
-			"provide at least one of --description / --description-i18n / --icon-key").WithParam("--description")
-	}
-	if hasI18n && !hasDesc {
-		return errs.NewValidationError(errs.SubtypeInvalidArgument,
-			"--description-i18n requires --description: PATCH replaces the whole description object, so default_value must be provided together").WithParam("--description-i18n")
-	}
-	if _, err := parseDescriptionI18n(runtime.StrArray("description-i18n")); err != nil {
-		return err
-	}
-	return nil
-}
-
-// SlashCommandUpdate updates description/i18n/icon of an existing slash command.
-var SlashCommandUpdate = common.Shortcut{
-	Service:     "application",
-	Command:     "+slash-command-update",
-	Description: "Update description / localized descriptions / icon of a slash command on the current bound app, addressed by --command-id or by name via --command",
-	Risk:        "write",
-	Scopes:      []string{"application:app_slash_command:write"},
-	ConditionalScopes: []string{
-		"application:app_slash_command:read", // only the --command by-name path lists to resolve the id
-	},
-	AuthTypes: []string{"bot", "user"},
-	Flags: []common.Flag{
-		{Name: "command-id", Desc: "target command_id (from +slash-command-list or create output); mutually exclusive with --command"},
-		{Name: "command", Desc: "target command name WITHOUT leading slash; resolved via live list (needs read scope); mutually exclusive with --command-id"},
-		{Name: "description", Desc: "new default description (description.default_value)"},
-		{Name: "description-i18n", Type: "string_array", Desc: "localized description, repeatable <lang>=<text>; REPLACES the whole i18n map (missing languages are dropped); requires --description"},
-		{Name: "icon-key", Desc: "new icon key (invalid keys rejected server-side with code 40000031)"},
-	},
-	Tips: []string{
-		`lark-cli application +slash-command-update --command greet --description "new text" --as bot`,
-		"PATCH is field-level partial: fields you do not pass are preserved server-side",
-		"the command NAME itself cannot be changed (API limitation): rename = delete + create (new command_id)",
-	},
-	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		return validateUpdateTarget(runtime)
-	},
-	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
-		i18n, err := parseDescriptionI18n(runtime.StrArray("description-i18n"))
-		if err != nil {
-			// The CLI validates first; keep this guard for direct DryRun callers.
-			return common.NewDryRunAPI().Set("error", err.Error())
-		}
-		body := buildSlashCommandBody("", runtime.Str("description"), i18n, runtime.Str("icon-key"))
-		d := common.NewDryRunAPI()
-		target := strings.TrimSpace(runtime.Str("command-id"))
-		if target == "" {
-			name := strings.TrimSpace(runtime.Str("command"))
-			d.GET(slashCommandBasePath).
-				Desc(fmt.Sprintf("resolve command_id by name %q via GET list first", name))
-			target = "<resolved_command_id>"
-		} else {
-			target = encodeCommandIDPathSegment(target)
-		}
-		return d.PATCH(slashCommandBasePath + "/" + target).
-			Desc("Update a slash command by command_id").
-			Body(body)
-	},
-	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		id := strings.TrimSpace(runtime.Str("command-id"))
-		if id == "" {
-			resolved, err := resolveCommandID(runtime, strings.TrimSpace(runtime.Str("command")))
-			if err != nil {
-				return err
-			}
-			id = resolved
-		}
-		i18n, err := parseDescriptionI18n(runtime.StrArray("description-i18n"))
-		if err != nil {
-			return err
-		}
-		body := buildSlashCommandBody("", runtime.Str("description"), i18n, runtime.Str("icon-key"))
-		data, err := runtime.CallAPITyped("PATCH", slashCommandBasePath+"/"+encodeCommandIDPathSegment(id), nil, body)
-		if err != nil {
-			return err
-		}
-		if data == nil {
-			data = map[string]interface{}{}
-		}
-		data["action"] = "updated"
-		fmt.Fprintln(runtime.IO().ErrOut, clientCacheHint)
-		runtime.OutFormat(data, nil, func(w io.Writer) {
-			fmt.Fprintf(w, "updated /%v (command_id: %v)\n", data["command"], data["command_id"])
-		})
-		return nil
-	},
-}

shortcuts/application/slash_command_update_test.go

@@ -1,150 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package application
-
-import (
-	"encoding/json"
-	"strings"
-	"testing"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/internal/cmdutil"
-)
-
-func TestSlashCommandUpdate_ByID(t *testing.T) {
-	f, stdout, _, reg := cmdutil.TestFactory(t, appTestConfig())
-	reg.Register(patchOKStub("id1"))
-
-	err := mountAndRun(t, SlashCommandUpdate, []string{"+slash-command-update",
-		"--command-id", "id1", "--description", "new", "--format", "json", "--as", "bot"}, f, stdout)
-	if err != nil {
-		t.Fatalf("execute: %v", err)
-	}
-	var got map[string]interface{}
-	if err := json.Unmarshal(stdout.Bytes(), &got); err != nil {
-		t.Fatalf("json: %v", err)
-	}
-	data := got["data"].(map[string]interface{})
-	if data["action"] != "updated" {
-		t.Fatalf("action = %v", data["action"])
-	}
-}
-
-func TestSlashCommandUpdate_ByName(t *testing.T) {
-	f, stdout, _, reg := cmdutil.TestFactory(t, appTestConfig())
-	reg.Register(listStub([]interface{}{sampleItem("greet", "id9")}))
-	reg.Register(patchOKStub("id9"))
-
-	err := mountAndRun(t, SlashCommandUpdate, []string{"+slash-command-update",
-		"--command", "greet", "--icon-key", "skill_outlined", "--format", "json", "--as", "bot"}, f, stdout)
-	if err != nil {
-		t.Fatalf("execute: %v", err)
-	}
-}
-
-func TestSlashCommandUpdate_ByNameNotFound(t *testing.T) {
-	f, stdout, _, reg := cmdutil.TestFactory(t, appTestConfig())
-	reg.Register(listStub(nil))
-
-	err := mountAndRun(t, SlashCommandUpdate, []string{"+slash-command-update",
-		"--command", "nope", "--description", "x", "--as", "bot"}, f, stdout)
-	if err == nil {
-		t.Fatal("expected not-found error")
-	}
-	p, ok := errs.ProblemOf(err)
-	if !ok || p.Category != errs.CategoryAPI || p.Subtype != errs.SubtypeNotFound {
-		t.Fatalf("expected api/not_found, got %#v", p)
-	}
-}
-
-func TestSlashCommandUpdate_Validate(t *testing.T) {
-	f, stdout, _, _ := cmdutil.TestFactory(t, appTestConfig())
-	cases := []struct {
-		name string
-		args []string
-	}{
-		{"both id and name", []string{"+slash-command-update", "--command-id", "id1", "--command", "greet", "--description", "x", "--as", "bot"}},
-		{"neither id nor name", []string{"+slash-command-update", "--description", "x", "--as", "bot"}},
-		{"no editable field", []string{"+slash-command-update", "--command-id", "id1", "--as", "bot"}},
-		{"i18n without description", []string{"+slash-command-update", "--command-id", "id1", "--description-i18n", "zh_cn=x", "--as", "bot"}},
-	}
-	for _, c := range cases {
-		err := mountAndRun(t, SlashCommandUpdate, c.args, f, stdout)
-		if err == nil {
-			t.Errorf("%s: expected validation error", c.name)
-			continue
-		}
-		p, ok := errs.ProblemOf(err)
-		if !ok || p.Category != errs.CategoryValidation || p.Subtype != errs.SubtypeInvalidArgument {
-			t.Errorf("%s: expected validation problem, got %v", c.name, err)
-		}
-	}
-}
-
-func TestSlashCommandUpdate_ByIDEncodesTrimmedPathSegment(t *testing.T) {
-	f, stdout, _, reg := cmdutil.TestFactory(t, appTestConfig())
-	reg.Register(patchOKStub("id%2Fwith%20space%3Fx"))
-
-	err := mountAndRun(t, SlashCommandUpdate, []string{"+slash-command-update",
-		"--command-id", " id/with space?x ", "--description", "new", "--as", "bot"}, f, stdout)
-	if err != nil {
-		t.Fatalf("execute: %v", err)
-	}
-}
-
-func TestSlashCommandUpdate_ByNameDryRunDescriptions(t *testing.T) {
-	f, stdout, _, _ := cmdutil.TestFactory(t, appTestConfig())
-	err := mountAndRun(t, SlashCommandUpdate, []string{"+slash-command-update",
-		"--command", " greet ", "--description", "new", "--dry-run", "--as", "bot"}, f, stdout)
-	if err != nil {
-		t.Fatalf("execute: %v", err)
-	}
-	var envlp struct {
-		Data struct {
-			Description string `json:"description"`
-			API         []struct {
-				Desc   string `json:"desc"`
-				Method string `json:"method"`
-			} `json:"api"`
-		} `json:"data"`
-	}
-	if err := json.Unmarshal(stdout.Bytes(), &envlp); err != nil {
-		t.Fatalf("json: %v", err)
-	}
-	got := envlp.Data
-	if strings.Contains(got.Description, "resolve command_id") {
-		t.Fatalf("resolve description must be attached to GET, not top-level: %q", got.Description)
-	}
-	if len(got.API) != 2 || got.API[0].Method != "GET" || !strings.Contains(got.API[0].Desc, "resolve command_id") {
-		t.Fatalf("first call must describe name resolution: %#v", got.API)
-	}
-	if got.API[1].Method != "PATCH" || !strings.Contains(got.API[1].Desc, "Update a slash command") {
-		t.Fatalf("second call must describe update: %#v", got.API)
-	}
-}
-
-func TestSlashCommandUpdate_ByIDDryRunEncodesTrimmedPathSegment(t *testing.T) {
-	f, stdout, _, _ := cmdutil.TestFactory(t, appTestConfig())
-	err := mountAndRun(t, SlashCommandUpdate, []string{"+slash-command-update",
-		"--command-id", " id/with space?x ", "--description", "new", "--dry-run", "--as", "bot"}, f, stdout)
-	if err != nil {
-		t.Fatalf("execute: %v", err)
-	}
-	var envlp struct {
-		Data struct {
-			API []struct {
-				Desc string `json:"desc"`
-				URL  string `json:"url"`
-			} `json:"api"`
-		} `json:"data"`
-	}
-	if err := json.Unmarshal(stdout.Bytes(), &envlp); err != nil {
-		t.Fatalf("json: %v", err)
-	}
-	got := envlp.Data
-	wantURL := slashCommandBasePath + "/id%2Fwith%20space%3Fx"
-	if len(got.API) != 1 || got.API[0].URL != wantURL || got.API[0].Desc == "" {
-		t.Fatalf("dry-run call = %#v, want encoded URL %q with description", got.API, wantURL)
-	}
-}

shortcuts/apps/apps_analytics_test.go

@@ -23,21 +23,19 @@ func TestAppsAnalyticsList_DryRunUsesNanoseconds(t *testing.T) {
 		t.Fatalf("dry-run err=%v", err)
 	}
 	var env struct {
-		Data struct {
-			API []struct {
-				Method string                 `json:"method"`
-				URL    string                 `json:"url"`
-				Body   map[string]interface{} `json:"body"`
-			} `json:"api"`
-		} `json:"data"`
+		API []struct {
+			Method string                 `json:"method"`
+			URL    string                 `json:"url"`
+			Body   map[string]interface{} `json:"body"`
+		} `json:"api"`
 	}
 	if err := json.Unmarshal(stdout.Bytes(), &env); err != nil {
 		t.Fatalf("decode dry-run: %v\n%s", err, stdout.String())
 	}
-	if env.Data.API[0].Method != "POST" || env.Data.API[0].URL != "/open-apis/spark/v1/apps/app_x/query_analytics_data" {
-		t.Fatalf("method/url = %s %s", env.Data.API[0].Method, env.Data.API[0].URL)
+	if env.API[0].Method != "POST" || env.API[0].URL != "/open-apis/spark/v1/apps/app_x/query_analytics_data" {
+		t.Fatalf("method/url = %s %s", env.API[0].Method, env.API[0].URL)
 	}
-	body := env.Data.API[0].Body
+	body := env.API[0].Body
 	if _, ok := body["start_timestamp_ns"]; !ok {
 		t.Fatalf("analytics dry-run missing start_timestamp_ns: %#v", body)
 	}
@@ -94,16 +92,14 @@ func TestAppsAnalyticsList_PageViewDesktopSeriesSetsDeviceFilter(t *testing.T) {
 				t.Fatalf("dry-run err=%v", err)
 			}
 			var env struct {
-				Data struct {
-					API []struct {
-						Body map[string]interface{} `json:"body"`
-					} `json:"api"`
-				} `json:"data"`
+				API []struct {
+					Body map[string]interface{} `json:"body"`
+				} `json:"api"`
 			}
 			if err := json.Unmarshal(stdout.Bytes(), &env); err != nil {
 				t.Fatalf("decode dry-run: %v\n%s", err, stdout.String())
 			}
-			filter := env.Data.API[0].Body["filter"].(map[string]interface{})
+			filter := env.API[0].Body["filter"].(map[string]interface{})
 			deviceTypes := filter["device_types"].([]interface{})
 			if len(deviceTypes) != 1 || deviceTypes[0] != "desktop" {
 				t.Fatalf("device_types = %#v", deviceTypes)

shortcuts/apps/apps_db_audit_test.go

@@ -101,16 +101,14 @@ func TestAppsDBAuditEnable_DryRunAndSuccess(t *testing.T) {
 		t.Fatalf("dry-run err=%v", err)
 	}
 	var env struct {
-		Data struct {
-			API []struct {
-				Method string                 `json:"method"`
-				URL    string                 `json:"url"`
-				Body   map[string]interface{} `json:"body"`
-			} `json:"api"`
-		} `json:"data"`
+		API []struct {
+			Method string                 `json:"method"`
+			URL    string                 `json:"url"`
+			Body   map[string]interface{} `json:"body"`
+		} `json:"api"`
 	}
 	_ = json.Unmarshal([]byte(stdout.String()), &env)
-	a := env.Data.API[0]
+	a := env.API[0]
 	if a.Method != "POST" || a.URL != dbAuditSetURL || a.Body["enabled"] != true || a.Body["retention"] != "30d" || a.Body["table"] != "orders" {
 		t.Fatalf("dry-run = %s %s body=%v", a.Method, a.URL, a.Body)
 	}
@@ -138,15 +136,13 @@ func TestAppsDBAuditDisable_DryRunAndSuccess(t *testing.T) {
 		t.Fatalf("dry-run err=%v", err)
 	}
 	var env struct {
-		Data struct {
-			API []struct {
-				Body map[string]interface{} `json:"body"`
-			} `json:"api"`
-		} `json:"data"`
+		API []struct {
+			Body map[string]interface{} `json:"body"`
+		} `json:"api"`
 	}
 	_ = json.Unmarshal([]byte(stdout.String()), &env)
-	if env.Data.API[0].Body["enabled"] != false || env.Data.API[0].Body["table"] != "orders" {
-		t.Fatalf("dry-run body=%v (want enabled:false)", env.Data.API[0].Body)
+	if env.API[0].Body["enabled"] != false || env.API[0].Body["table"] != "orders" {
+		t.Fatalf("dry-run body=%v (want enabled:false)", env.API[0].Body)
 	}
 
 	factory2, stdout2, reg := newAppsExecuteFactory(t)
@@ -182,16 +178,14 @@ func TestAppsDBAuditList_DryRunJoinsTables(t *testing.T) {
 		t.Fatalf("dry-run err=%v", err)
 	}
 	var env struct {
-		Data struct {
-			API []struct {
-				Method string                 `json:"method"`
-				URL    string                 `json:"url"`
-				Params map[string]interface{} `json:"params"`
-			} `json:"api"`
-		} `json:"data"`
+		API []struct {
+			Method string                 `json:"method"`
+			URL    string                 `json:"url"`
+			Params map[string]interface{} `json:"params"`
+		} `json:"api"`
 	}
 	_ = json.Unmarshal([]byte(stdout.String()), &env)
-	a := env.Data.API[0]
+	a := env.API[0]
 	if a.Method != "GET" || a.URL != dbAuditListURL || a.Params["tables"] != "orders,users" {
 		t.Fatalf("dry-run = %s %s tables=%v", a.Method, a.URL, a.Params["tables"])
 	}

shortcuts/apps/apps_db_changelog_list_test.go

@@ -37,7 +37,13 @@ func TestAppsDBChangelogList_DryRunFiltersAndTimeNormalize(t *testing.T) {
 			"--change-id", "01J", "--since", "2026-01-01", "--page-size", "5", "--dry-run", "--as", "user"}, factory, stdout); err != nil {
 		t.Fatalf("dry-run err=%v", err)
 	}
-	var env dryRunAPIEnvelope
+	var env struct {
+		API []struct {
+			Method string                 `json:"method"`
+			URL    string                 `json:"url"`
+			Params map[string]interface{} `json:"params"`
+		} `json:"api"`
+	}
 	_ = json.Unmarshal([]byte(stdout.String()), &env)
 	a := env.API[0]
 	if a.Method != "GET" || a.URL != dbChangelogURL {

shortcuts/apps/apps_db_data_export_test.go

@@ -71,7 +71,13 @@ func TestAppsDBDataExport_DryRunFormatFromOutput(t *testing.T) {
 		if err := runAppsShortcut(t, AppsDBDataExport, args, factory, stdout); err != nil {
 			t.Fatalf("dry-run err=%v", err)
 		}
-		var env dryRunAPIEnvelope
+		var env struct {
+			API []struct {
+				Method string                 `json:"method"`
+				URL    string                 `json:"url"`
+				Params map[string]interface{} `json:"params"`
+			} `json:"api"`
+		}
 		_ = json.Unmarshal([]byte(stdout.String()), &env)
 		a := env.API[0]
 		if a.Method != "GET" || a.URL != dbDataExportURL {

shortcuts/apps/apps_db_data_import_test.go

@@ -97,7 +97,14 @@ func TestAppsDBDataImport_DryRunMultipartShape(t *testing.T) {
 		[]string{"+db-data-import", "--app-id", "app_x", "--file", "orders.csv", "--environment", "dev", "--dry-run", "--yes", "--as", "user"}, factory, stdout); err != nil {
 		t.Fatalf("dry-run err=%v", err)
 	}
-	var env dryRunAPIEnvelope
+	var env struct {
+		API []struct {
+			Method string                 `json:"method"`
+			URL    string                 `json:"url"`
+			Params map[string]interface{} `json:"params"`
+			Body   map[string]interface{} `json:"body"`
+		} `json:"api"`
+	}
 	_ = json.Unmarshal([]byte(stdout.String()), &env)
 	a := env.API[0]
 	if a.Method != "POST" || a.URL != dbDataImportURL {
@@ -124,11 +131,12 @@ func TestAppsDBDataImport_DryRunOmitsEnvWhenUnset(t *testing.T) {
 		[]string{"+db-data-import", "--app-id", "app_x", "--file", "orders.csv", "--dry-run", "--yes", "--as", "user"}, factory, stdout); err != nil {
 		t.Fatalf("dry-run err=%v", err)
 	}
-	var env dryRunAPIEnvelope
-	_ = json.Unmarshal([]byte(stdout.String()), &env)
-	if len(env.API) != 1 {
-		t.Fatalf("dry-run API calls = %d, want 1; stdout=%s", len(env.API), stdout.String())
+	var env struct {
+		API []struct {
+			Params map[string]interface{} `json:"params"`
+		} `json:"api"`
 	}
+	_ = json.Unmarshal([]byte(stdout.String()), &env)
 	p := env.API[0].Params
 	if _, ok := p["env"]; ok {
 		t.Fatalf("no --environment → env key must be omitted, got params=%v", p)
@@ -166,7 +174,11 @@ func TestAppsDBDataImport_TableDefaultsToFileBasename(t *testing.T) {
 		[]string{"+db-data-import", "--app-id", "app_x", "--file", "customers.json", "--dry-run", "--yes", "--as", "user"}, factory, stdout); err != nil {
 		t.Fatalf("dry-run err=%v", err)
 	}
-	var env dryRunAPIEnvelope
+	var env struct {
+		API []struct {
+			Params map[string]interface{} `json:"params"`
+		} `json:"api"`
+	}
 	_ = json.Unmarshal([]byte(stdout.String()), &env)
 	if env.API[0].Params["table"] != "customers" {
 		t.Fatalf("expected table=customers (from file basename) in params, got %v", env.API[0].Params)

shortcuts/apps/apps_db_env_recovery_quota_test.go

@@ -30,7 +30,13 @@ func TestAppsDBEnvDiff_DryRunBody(t *testing.T) {
 		[]string{"+db-env-diff", "--app-id", "app_x", "--dry-run", "--as", "user"}, factory, stdout); err != nil {
 		t.Fatalf("dry-run err=%v", err)
 	}
-	var env dryRunAPIEnvelope
+	var env struct {
+		API []struct {
+			Method string                 `json:"method"`
+			URL    string                 `json:"url"`
+			Body   map[string]interface{} `json:"body"`
+		} `json:"api"`
+	}
 	_ = json.Unmarshal([]byte(stdout.String()), &env)
 	a := env.API[0]
 	if a.Method != "POST" || a.URL != dbEnvMigrateURL || a.Body["dry_run"] != true {
@@ -85,7 +91,11 @@ func TestAppsDBEnvMigrate_DryRunBody(t *testing.T) {
 		[]string{"+db-env-migrate", "--app-id", "app_x", "--dry-run", "--as", "user"}, factory, stdout); err != nil {
 		t.Fatalf("dry-run err=%v", err)
 	}
-	var env dryRunAPIEnvelope
+	var env struct {
+		API []struct {
+			Body map[string]interface{} `json:"body"`
+		} `json:"api"`
+	}
 	_ = json.Unmarshal([]byte(stdout.String()), &env)
 	if env.API[0].Body["dry_run"] != false {
 		t.Fatalf("dry-run body=%v (want dry_run:false)", env.API[0].Body)
@@ -170,7 +180,13 @@ func TestAppsDBRecoveryDiff_DryRunNormalizesTarget(t *testing.T) {
 		[]string{"+db-recovery-diff", "--app-id", "app_x", "--target", "2026-04-15", "--dry-run", "--as", "user"}, factory, stdout); err != nil {
 		t.Fatalf("dry-run err=%v", err)
 	}
-	var env dryRunAPIEnvelope
+	var env struct {
+		API []struct {
+			Method string                 `json:"method"`
+			URL    string                 `json:"url"`
+			Body   map[string]interface{} `json:"body"`
+		} `json:"api"`
+	}
 	_ = json.Unmarshal([]byte(stdout.String()), &env)
 	a := env.API[0]
 	if a.Method != "POST" || a.URL != dbRecoveryURL || a.Body["dry_run"] != true {
@@ -315,11 +331,14 @@ func TestAppsDBQuotaGet_DryRunOmitsEnvWhenUnset(t *testing.T) {
 		[]string{"+db-quota-get", "--app-id", "app_x", "--dry-run", "--as", "user"}, factory, stdout); err != nil {
 		t.Fatalf("dry-run err=%v", err)
 	}
-	var env dryRunAPIEnvelope
-	_ = json.Unmarshal([]byte(stdout.String()), &env)
-	if len(env.API) != 1 {
-		t.Fatalf("dry-run API calls = %d, want 1; stdout=%s", len(env.API), stdout.String())
+	var env struct {
+		API []struct {
+			Method string                 `json:"method"`
+			URL    string                 `json:"url"`
+			Params map[string]interface{} `json:"params"`
+		} `json:"api"`
 	}
+	_ = json.Unmarshal([]byte(stdout.String()), &env)
 	a := env.API[0]
 	if a.Method != "GET" || a.URL != dbQuotaURL {
 		t.Fatalf("dry-run = %s %s", a.Method, a.URL)

shortcuts/apps/apps_db_execute_test.go

@@ -165,7 +165,14 @@ func TestAppsDBExecute_DryRunSendsTransactionalFalse(t *testing.T) {
 		factory, stdout); err != nil {
 		t.Fatalf("dry-run err=%v", err)
 	}
-	var env dryRunAPIEnvelope
+	var env struct {
+		API []struct {
+			Method string                 `json:"method"`
+			URL    string                 `json:"url"`
+			Body   map[string]interface{} `json:"body"`
+			Params map[string]interface{} `json:"params"`
+		} `json:"api"`
+	}
 	if err := json.Unmarshal([]byte(stdout.String()), &env); err != nil {
 		t.Fatalf("decode: %v\n%s", err, stdout.String())
 	}
@@ -247,7 +254,11 @@ func TestAppsDBExecute_FileReadsSQLIntoBody(t *testing.T) {
 		factory, stdout); err != nil {
 		t.Fatalf("dry-run err=%v", err)
 	}
-	var env dryRunAPIEnvelope
+	var env struct {
+		API []struct {
+			Body map[string]interface{} `json:"body"`
+		} `json:"api"`
+	}
 	if err := json.Unmarshal([]byte(stdout.String()), &env); err != nil {
 		t.Fatalf("decode: %v\n%s", err, stdout.String())
 	}

shortcuts/apps/apps_db_table_get_test.go

@@ -79,7 +79,11 @@ func TestAppsDBTableGet_NonPrettyFormatsOmitFormatQuery(t *testing.T) {
 			if err := runAppsShortcut(t, AppsDBTableGet, args, factory, stdout); err != nil {
 				t.Fatalf("dry-run err=%v", err)
 			}
-			var env dryRunAPIEnvelope
+			var env struct {
+				API []struct {
+					Params map[string]interface{} `json:"params"`
+				} `json:"api"`
+			}
 			if err := json.Unmarshal([]byte(stdout.String()), &env); err != nil {
 				t.Fatalf("decode: %v", err)
 			}

shortcuts/apps/apps_db_table_list_test.go

@@ -165,7 +165,13 @@ func TestAppsDBTableList_DryRunSendsPaginationAndEnv(t *testing.T) {
 		factory, stdout); err != nil {
 		t.Fatalf("dry-run err=%v", err)
 	}
-	var env dryRunAPIEnvelope
+	var env struct {
+		API []struct {
+			Method string                 `json:"method"`
+			URL    string                 `json:"url"`
+			Params map[string]interface{} `json:"params"`
+		} `json:"api"`
+	}
 	if err := json.Unmarshal([]byte(stdout.String()), &env); err != nil {
 		t.Fatalf("decode dry-run: %v\n%s", err, stdout.String())
 	}
@@ -190,7 +196,11 @@ func TestAppsDBTableList_DoesNotSendIncludeStatsQuery(t *testing.T) {
 		factory, stdout); err != nil {
 		t.Fatalf("dry-run err=%v", err)
 	}
-	var env dryRunAPIEnvelope
+	var env struct {
+		API []struct {
+			Params map[string]interface{} `json:"params"`
+		} `json:"api"`
+	}
 	if err := json.Unmarshal([]byte(stdout.String()), &env); err != nil {
 		t.Fatalf("decode: %v", err)
 	}

shortcuts/apps/apps_env_test.go

@@ -149,7 +149,11 @@ func TestAppsEnvVarList_DryRunIncludesScene(t *testing.T) {
 	}, factory, stdout); err != nil {
 		t.Fatalf("dry-run err=%v", err)
 	}
-	var dryRun dryRunAPIEnvelope
+	var dryRun struct {
+		API []struct {
+			Body map[string]interface{} `json:"body"`
+		} `json:"api"`
+	}
 	if err := json.Unmarshal(stdout.Bytes(), &dryRun); err != nil {
 		t.Fatalf("decode dry-run: %v\n%s", err, stdout.String())
 	}
@@ -224,7 +228,11 @@ func TestAppsEnvVarSet_OnlineDryRunDoesNotRequireYes(t *testing.T) {
 			t.Fatalf("dry-run missing %q: %s", want, got)
 		}
 	}
-	var dryRun dryRunAPIEnvelope
+	var dryRun struct {
+		API []struct {
+			Body map[string]interface{} `json:"body"`
+		} `json:"api"`
+	}
 	if err := json.Unmarshal([]byte(got), &dryRun); err != nil {
 		t.Fatalf("decode dry-run: %v\n%s", err, got)
 	}
@@ -345,7 +353,13 @@ func TestAppsEnvVarDelete_OnlineDryRunDoesNotRequireYes(t *testing.T) {
 		t.Fatalf("dry-run err=%v", err)
 	}
 
-	var dryRun dryRunAPIEnvelope
+	var dryRun struct {
+		API []struct {
+			Method string                 `json:"method"`
+			URL    string                 `json:"url"`
+			Body   map[string]interface{} `json:"body"`
+		} `json:"api"`
+	}
 	got := stdout.String()
 	if err := json.Unmarshal([]byte(got), &dryRun); err != nil {
 		t.Fatalf("decode dry-run: %v\n%s", err, got)

shortcuts/apps/apps_file_delete_test.go

@@ -48,7 +48,13 @@ func TestAppsFileDelete_DryRunSendsPaths(t *testing.T) {
 		[]string{"+file-delete", "--app-id", "app_x", "--path", "/a.png", "--path", "/b.png", "--yes", "--dry-run", "--as", "user"}, factory, stdout); err != nil {
 		t.Fatalf("dry-run err=%v", err)
 	}
-	var env dryRunAPIEnvelope
+	var env struct {
+		API []struct {
+			Method string                 `json:"method"`
+			URL    string                 `json:"url"`
+			Body   map[string]interface{} `json:"body"`
+		} `json:"api"`
+	}
 	_ = json.Unmarshal([]byte(stdout.String()), &env)
 	a := env.API[0]
 	if a.Method != "POST" || a.URL != fileDeleteURL {

shortcuts/apps/apps_file_download_test.go

@@ -41,7 +41,12 @@ func TestAppsFileDownload_DryRunSignsFirst(t *testing.T) {
 		[]string{"+file-download", "--app-id", "app_x", "--path", "/x.png", "--dry-run", "--as", "user"}, factory, stdout); err != nil {
 		t.Fatalf("dry-run err=%v", err)
 	}
-	var env dryRunAPIEnvelope
+	var env struct {
+		API []struct {
+			Method string `json:"method"`
+			URL    string `json:"url"`
+		} `json:"api"`
+	}
 	_ = json.Unmarshal([]byte(stdout.String()), &env)
 	if env.API[0].Method != "POST" || env.API[0].URL != fileSignURLForDownload {
 		t.Fatalf("dry-run = %s %s (want POST sign)", env.API[0].Method, env.API[0].URL)

shortcuts/apps/apps_file_get_test.go

@@ -46,7 +46,13 @@ func TestAppsFileGet_DryRunSendsPathQuery(t *testing.T) {
 		[]string{"+file-get", "--app-id", "app_x", "--path", "/x.png", "--dry-run", "--as", "user"}, factory, stdout); err != nil {
 		t.Fatalf("dry-run err=%v", err)
 	}
-	var env dryRunAPIEnvelope
+	var env struct {
+		API []struct {
+			Method string                 `json:"method"`
+			URL    string                 `json:"url"`
+			Params map[string]interface{} `json:"params"`
+		} `json:"api"`
+	}
 	_ = json.Unmarshal([]byte(stdout.String()), &env)
 	if env.API[0].Method != "GET" || env.API[0].URL != fileGetURL || env.API[0].Params["path"] != "/x.png" {
 		t.Fatalf("dry-run = %s %s params=%v", env.API[0].Method, env.API[0].URL, env.API[0].Params)

shortcuts/apps/apps_file_list_test.go

@@ -95,7 +95,13 @@ func TestAppsFileList_DryRunSendsFiltersAndPagination(t *testing.T) {
 		factory, stdout); err != nil {
 		t.Fatalf("dry-run err=%v", err)
 	}
-	var env dryRunAPIEnvelope
+	var env struct {
+		API []struct {
+			Method string                 `json:"method"`
+			URL    string                 `json:"url"`
+			Params map[string]interface{} `json:"params"`
+		} `json:"api"`
+	}
 	if err := json.Unmarshal([]byte(stdout.String()), &env); err != nil {
 		t.Fatalf("decode dry-run: %v\n%s", err, stdout.String())
 	}
@@ -133,7 +139,11 @@ func TestAppsFileList_DryRunOmitsEmptyFilters(t *testing.T) {
 		[]string{"+file-list", "--app-id", "app_x", "--dry-run", "--as", "user"}, factory, stdout); err != nil {
 		t.Fatalf("dry-run err=%v", err)
 	}
-	var env dryRunAPIEnvelope
+	var env struct {
+		API []struct {
+			Params map[string]interface{} `json:"params"`
+		} `json:"api"`
+	}
 	_ = json.Unmarshal([]byte(stdout.String()), &env)
 	for _, banned := range []string{"name", "path", "type", "size_gt", "size_lt", "uploaded_since", "uploaded_until", "page_token"} {
 		if _, ok := env.API[0].Params[banned]; ok {

shortcuts/apps/apps_file_sign_test.go

@@ -22,7 +22,13 @@ func TestAppsFileSign_DryRunBody(t *testing.T) {
 		[]string{"+file-sign", "--app-id", "app_x", "--path", "/x.png", "--expires-in", "3600", "--dry-run", "--as", "user"}, factory, stdout); err != nil {
 		t.Fatalf("dry-run err=%v", err)
 	}
-	var env dryRunAPIEnvelope
+	var env struct {
+		API []struct {
+			Method string                 `json:"method"`
+			URL    string                 `json:"url"`
+			Body   map[string]interface{} `json:"body"`
+		} `json:"api"`
+	}
 	_ = json.Unmarshal([]byte(stdout.String()), &env)
 	a := env.API[0]
 	if a.Method != "POST" || a.URL != fileSignURL || a.Body["path"] != "/x.png" {

shortcuts/apps/apps_file_upload_test.go

@@ -76,7 +76,13 @@ func TestAppsFileUpload_DryRunPreUpload(t *testing.T) {
 		[]string{"+file-upload", "--app-id", "app_x", "--file", "logo.png", "--dry-run", "--as", "user"}, factory, stdout); err != nil {
 		t.Fatalf("dry-run err=%v", err)
 	}
-	var env dryRunAPIEnvelope
+	var env struct {
+		API []struct {
+			Method string                 `json:"method"`
+			URL    string                 `json:"url"`
+			Body   map[string]interface{} `json:"body"`
+		} `json:"api"`
+	}
 	_ = json.Unmarshal([]byte(stdout.String()), &env)
 	a := env.API[0]
 	if a.Method != "POST" || a.URL != "/open-apis/spark/v1/apps/app_x/storage/file_pre_upload" {

shortcuts/apps/apps_init.go

@@ -39,7 +39,7 @@ const (
 )
 
 const (
-	miaodaCLIPkg    = "@lark-apaas/miaoda-cli@latest"
+	miaodaCLIPkg    = "@lark-apaas/miaoda-cli@0.1.20-alpha.dd573f8"
 	npmRegistry     = "https://registry.npmmirror.com"
 	metaRelPath     = ".spark/meta.json"
 	steeringRelPath = ".agent/skills/steering"

shortcuts/apps/apps_init_test.go

@@ -737,12 +737,15 @@ func newAppsExecuteFactoryWithStderr(t *testing.T) (*cmdutil.Factory, *bytes.Buf
 }
 
 func TestAppsInit_Req1_Wording(t *testing.T) {
+	// The --dry-run output is a flat object (DryRunAPI marshals to top-level keys
+	// description/scaffold/api/...), NOT wrapped in {"data":...}, so parse stdout
+	// directly rather than via parseEnvelopeData.
 	factory, stdout, _ := newAppsExecuteFactoryWithStderr(t)
 	if err := runAppsShortcut(t, AppsInit, []string{"+init", "--app-id", "app_x", "--as", "user", "--dry-run"}, factory, stdout); err != nil {
 		t.Fatalf("dry-run err=%v", err)
 	}
-	data, err := decodeDryRunDataMap(stdout.Bytes())
-	if err != nil {
+	var data map[string]interface{}
+	if err := json.Unmarshal(stdout.Bytes(), &data); err != nil {
 		t.Fatalf("decode dry-run output: %v (raw=%q)", err, stdout.String())
 	}
 	desc, _ := data["description"].(string)
@@ -1444,8 +1447,8 @@ func TestAppsInit_DryRun_DescribesEnvPull(t *testing.T) {
 	if err := runAppsShortcut(t, AppsInit, []string{"+init", "--app-id", "app_x", "--dir", dir, "--as", "user", "--dry-run"}, factory, stdout); err != nil {
 		t.Fatalf("unexpected error: %v", err)
 	}
-	m, err := decodeDryRunDataMap(stdout.Bytes())
-	if err != nil {
+	var m map[string]interface{}
+	if err := json.Unmarshal(stdout.Bytes(), &m); err != nil {
 		t.Fatalf("decode dry-run: %v (raw=%q)", err, stdout.String())
 	}
 	ep, _ := m["env_pull"].(string)

shortcuts/apps/apps_logs_test.go

@@ -25,7 +25,13 @@ func TestAppsLogList_DryRunBuildsSearchLogsBody(t *testing.T) {
 	if err != nil {
 		t.Fatalf("dry-run err=%v", err)
 	}
-	var env dryRunAPIEnvelope
+	var env struct {
+		API []struct {
+			Method string                 `json:"method"`
+			URL    string                 `json:"url"`
+			Body   map[string]interface{} `json:"body"`
+		} `json:"api"`
+	}
 	if err := json.Unmarshal(stdout.Bytes(), &env); err != nil {
 		t.Fatalf("decode dry-run: %v\n%s", err, stdout.String())
 	}

shortcuts/apps/apps_metrics_test.go

@@ -39,7 +39,13 @@ func TestAppsMetricList_DryRunUsesSeconds(t *testing.T) {
 	if err != nil {
 		t.Fatalf("dry-run err=%v", err)
 	}
-	var env dryRunAPIEnvelope
+	var env struct {
+		API []struct {
+			Method string                 `json:"method"`
+			URL    string                 `json:"url"`
+			Body   map[string]interface{} `json:"body"`
+		} `json:"api"`
+	}
 	if err := json.Unmarshal(stdout.Bytes(), &env); err != nil {
 		t.Fatalf("decode dry-run: %v\n%s", err, stdout.String())
 	}
@@ -84,7 +90,11 @@ func TestAppsMetricList_AutoDownSampleByRange(t *testing.T) {
 			if err != nil {
 				t.Fatalf("dry-run err=%v", err)
 			}
-			var env dryRunAPIEnvelope
+			var env struct {
+				API []struct {
+					Body map[string]interface{} `json:"body"`
+				} `json:"api"`
+			}
 			if err := json.Unmarshal(stdout.Bytes(), &env); err != nil {
 				t.Fatalf("decode dry-run: %v\n%s", err, stdout.String())
 			}

shortcuts/apps/apps_traces_test.go

@@ -24,7 +24,13 @@ func TestAppsTraceList_DryRunBuildsSearchTracesBody(t *testing.T) {
 		t.Fatalf("dry-run err=%v", err)
 	}
 
-	var env dryRunAPIEnvelope
+	var env struct {
+		API []struct {
+			Method string                 `json:"method"`
+			URL    string                 `json:"url"`
+			Body   map[string]interface{} `json:"body"`
+		} `json:"api"`
+	}
 	if err := json.Unmarshal(stdout.Bytes(), &env); err != nil {
 		t.Fatalf("decode dry-run: %v\n%s", err, stdout.String())
 	}
@@ -67,7 +73,13 @@ func TestAppsTraceGet_DryRunBuildsGetTraceBody(t *testing.T) {
 		t.Fatalf("dry-run err=%v", err)
 	}
 
-	var env dryRunAPIEnvelope
+	var env struct {
+		API []struct {
+			Method string                 `json:"method"`
+			URL    string                 `json:"url"`
+			Body   map[string]interface{} `json:"body"`
+		} `json:"api"`
+	}
 	if err := json.Unmarshal(stdout.Bytes(), &env); err != nil {
 		t.Fatalf("decode dry-run: %v\n%s", err, stdout.String())
 	}

shortcuts/apps/dryrun_test.go

@@ -1,46 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package apps
-
-import (
-	"encoding/json"
-	"fmt"
-)
-
-type dryRunAPICall struct {
-	Method string                 `json:"method"`
-	URL    string                 `json:"url"`
-	Params map[string]interface{} `json:"params"`
-	Body   map[string]interface{} `json:"body"`
-}
-
-type dryRunAPIEnvelope struct {
-	API []dryRunAPICall
-}
-
-func (e *dryRunAPIEnvelope) UnmarshalJSON(data []byte) error {
-	var raw struct {
-		Data struct {
-			API []dryRunAPICall `json:"api"`
-		} `json:"data"`
-	}
-	if err := json.Unmarshal(data, &raw); err != nil {
-		return err
-	}
-	e.API = raw.Data.API
-	return nil
-}
-
-func decodeDryRunDataMap(data []byte) (map[string]interface{}, error) {
-	var raw struct {
-		Data map[string]interface{} `json:"data"`
-	}
-	if err := json.Unmarshal(data, &raw); err != nil {
-		return nil, err
-	}
-	if raw.Data == nil {
-		return nil, fmt.Errorf("dry-run stdout is not a success envelope: %s", data)
-	}
-	return raw.Data, nil
-}

shortcuts/apps/git_credential_test.go

@@ -38,27 +38,25 @@ func TestAppsGitCredentialInitDryRunRequestShape(t *testing.T) {
 		t.Fatalf("dry-run err=%v", err)
 	}
 	var payload struct {
-		Data struct {
-			API []struct {
-				Method string                 `json:"method"`
-				URL    string                 `json:"url"`
-				Params map[string]interface{} `json:"params"`
-				Body   interface{}            `json:"body"`
-			} `json:"api"`
-			Mode         string   `json:"mode"`
-			Action       string   `json:"action"`
-			AppID        string   `json:"app_id"`
-			MetadataFile string   `json:"metadata_file"`
-			LocalEffects []string `json:"local_effects"`
-		} `json:"data"`
+		API []struct {
+			Method string                 `json:"method"`
+			URL    string                 `json:"url"`
+			Params map[string]interface{} `json:"params"`
+			Body   interface{}            `json:"body"`
+		} `json:"api"`
+		Mode         string   `json:"mode"`
+		Action       string   `json:"action"`
+		AppID        string   `json:"app_id"`
+		MetadataFile string   `json:"metadata_file"`
+		LocalEffects []string `json:"local_effects"`
 	}
 	if err := json.Unmarshal([]byte(stdout.String()), &payload); err != nil {
 		t.Fatalf("decode dry-run output: %v\n%s", err, stdout.String())
 	}
-	if len(payload.Data.API) != 1 {
-		t.Fatalf("api len = %d, want 1", len(payload.Data.API))
+	if len(payload.API) != 1 {
+		t.Fatalf("api len = %d, want 1", len(payload.API))
 	}
-	call := payload.Data.API[0]
+	call := payload.API[0]
 	if call.Method != "GET" {
 		t.Fatalf("method = %q, want GET", call.Method)
 	}
@@ -71,19 +69,19 @@ func TestAppsGitCredentialInitDryRunRequestShape(t *testing.T) {
 	if call.Body != nil {
 		t.Fatalf("body = %#v, want nil", call.Body)
 	}
-	if payload.Data.Mode != "api-plus-local-setup" {
-		t.Fatalf("mode = %q", payload.Data.Mode)
+	if payload.Mode != "api-plus-local-setup" {
+		t.Fatalf("mode = %q", payload.Mode)
 	}
-	if payload.Data.Action != "initialize_local_git_credential" {
-		t.Fatalf("action = %q", payload.Data.Action)
+	if payload.Action != "initialize_local_git_credential" {
+		t.Fatalf("action = %q", payload.Action)
 	}
-	if payload.Data.AppID != "app_xxx" {
-		t.Fatalf("app_id = %q", payload.Data.AppID)
+	if payload.AppID != "app_xxx" {
+		t.Fatalf("app_id = %q", payload.AppID)
 	}
-	if !strings.HasSuffix(payload.Data.MetadataFile, filepath.Join("spark", "app_xxx", "git.json")) {
-		t.Fatalf("metadata_file = %q", payload.Data.MetadataFile)
+	if !strings.HasSuffix(payload.MetadataFile, filepath.Join("spark", "app_xxx", "git.json")) {
+		t.Fatalf("metadata_file = %q", payload.MetadataFile)
 	}
-	assertStringSliceEqual(t, payload.Data.LocalEffects, []string{
+	assertStringSliceEqual(t, payload.LocalEffects, []string{
 		"save the issued PAT in the local system credential store",
 		"write app-scoped git credential metadata",
 		"configure a URL-scoped Git credential helper in global git config when possible",
@@ -98,34 +96,32 @@ func TestAppsGitCredentialListDryRunDescribesLocalReads(t *testing.T) {
 		t.Fatalf("dry-run err=%v", err)
 	}
 	var payload struct {
-		Data struct {
-			Description string        `json:"description"`
-			API         []interface{} `json:"api"`
-			Mode        string        `json:"mode"`
-			Action      string        `json:"action"`
-			StorageRoot string        `json:"storage_root"`
-			Reads       []string      `json:"reads"`
-		} `json:"data"`
+		Description string        `json:"description"`
+		API         []interface{} `json:"api"`
+		Mode        string        `json:"mode"`
+		Action      string        `json:"action"`
+		StorageRoot string        `json:"storage_root"`
+		Reads       []string      `json:"reads"`
 	}
 	if err := json.Unmarshal([]byte(stdout.String()), &payload); err != nil {
 		t.Fatalf("decode dry-run output: %v\n%s", err, stdout.String())
 	}
-	if payload.Data.Description != "Preview local Git credential listing (no API call, read-only local state)." {
-		t.Fatalf("description = %q", payload.Data.Description)
+	if payload.Description != "Preview local Git credential listing (no API call, read-only local state)." {
+		t.Fatalf("description = %q", payload.Description)
 	}
-	if len(payload.Data.API) != 0 {
-		t.Fatalf("api len = %d, want 0", len(payload.Data.API))
+	if len(payload.API) != 0 {
+		t.Fatalf("api len = %d, want 0", len(payload.API))
 	}
-	if payload.Data.Mode != "local-read-only" {
-		t.Fatalf("mode = %q", payload.Data.Mode)
+	if payload.Mode != "local-read-only" {
+		t.Fatalf("mode = %q", payload.Mode)
 	}
-	if payload.Data.Action != "list_local_git_credentials" {
-		t.Fatalf("action = %q", payload.Data.Action)
+	if payload.Action != "list_local_git_credentials" {
+		t.Fatalf("action = %q", payload.Action)
 	}
-	if !strings.HasSuffix(payload.Data.StorageRoot, filepath.Join("spark")) {
-		t.Fatalf("storage_root = %q", payload.Data.StorageRoot)
+	if !strings.HasSuffix(payload.StorageRoot, filepath.Join("spark")) {
+		t.Fatalf("storage_root = %q", payload.StorageRoot)
 	}
-	assertStringSliceEqual(t, payload.Data.Reads, []string{
+	assertStringSliceEqual(t, payload.Reads, []string{
 		"scan app-scoped git credential metadata under the CLI config directory",
 		"derive per-app repository URLs and local credential status from local metadata",
 	})
@@ -139,38 +135,36 @@ func TestAppsGitCredentialRemoveDryRunDescribesLocalCleanup(t *testing.T) {
 		t.Fatalf("dry-run err=%v", err)
 	}
 	var payload struct {
-		Data struct {
-			Description  string        `json:"description"`
-			API          []interface{} `json:"api"`
-			Mode         string        `json:"mode"`
-			Action       string        `json:"action"`
-			AppID        string        `json:"app_id"`
-			MetadataFile string        `json:"metadata_file"`
-			Effects      []string      `json:"effects"`
-		} `json:"data"`
+		Description  string        `json:"description"`
+		API          []interface{} `json:"api"`
+		Mode         string        `json:"mode"`
+		Action       string        `json:"action"`
+		AppID        string        `json:"app_id"`
+		MetadataFile string        `json:"metadata_file"`
+		Effects      []string      `json:"effects"`
 	}
 	if err := json.Unmarshal([]byte(stdout.String()), &payload); err != nil {
 		t.Fatalf("decode dry-run output: %v\n%s", err, stdout.String())
 	}
-	if payload.Data.Description != "Preview local Git credential cleanup (no API call; would clean up local-only state)." {
-		t.Fatalf("description = %q", payload.Data.Description)
+	if payload.Description != "Preview local Git credential cleanup (no API call; would clean up local-only state)." {
+		t.Fatalf("description = %q", payload.Description)
 	}
-	if len(payload.Data.API) != 0 {
-		t.Fatalf("api len = %d, want 0", len(payload.Data.API))
+	if len(payload.API) != 0 {
+		t.Fatalf("api len = %d, want 0", len(payload.API))
 	}
-	if payload.Data.Mode != "local-cleanup-only" {
-		t.Fatalf("mode = %q", payload.Data.Mode)
+	if payload.Mode != "local-cleanup-only" {
+		t.Fatalf("mode = %q", payload.Mode)
 	}
-	if payload.Data.Action != "remove_local_git_credential" {
-		t.Fatalf("action = %q", payload.Data.Action)
+	if payload.Action != "remove_local_git_credential" {
+		t.Fatalf("action = %q", payload.Action)
 	}
-	if payload.Data.AppID != "app_xxx" {
-		t.Fatalf("app_id = %q", payload.Data.AppID)
+	if payload.AppID != "app_xxx" {
+		t.Fatalf("app_id = %q", payload.AppID)
 	}
-	if !strings.HasSuffix(payload.Data.MetadataFile, filepath.Join("spark", "app_xxx", "git.json")) {
-		t.Fatalf("metadata_file = %q", payload.Data.MetadataFile)
+	if !strings.HasSuffix(payload.MetadataFile, filepath.Join("spark", "app_xxx", "git.json")) {
+		t.Fatalf("metadata_file = %q", payload.MetadataFile)
 	}
-	assertStringSliceEqual(t, payload.Data.Effects, []string{
+	assertStringSliceEqual(t, payload.Effects, []string{
 		"read app-scoped git credential metadata",
 		"remove the saved PAT from the local system credential store",
 		"remove the app-scoped Git helper from global git config when present",

shortcuts/common/runner.go

@@ -431,6 +431,11 @@ func (ctx *RuntimeContext) buildRequest(method, url string, params map[string]in
 	if optFn := cmdutil.ShortcutHeaderOpts(ctx.ctx); optFn != nil {
 		req.ExtraOpts = append(req.ExtraOpts, optFn)
 	}
+	// TODO: remove PPE headers once testing is complete and promoted to production.
+	ppeHeaders := http.Header{}
+	ppeHeaders.Set("x-use-ppe", "1")
+	ppeHeaders.Set("x-tt-env", "ppe_miaoda_lark_cli")
+	req.ExtraOpts = append(req.ExtraOpts, larkcore.WithHeaders(ppeHeaders))
 	return req
 }
 
@@ -1070,7 +1075,7 @@ func resolveInputFlags(rctx *RuntimeContext, flags []Flag) error {
 			if rctx.stdinConsumed {
 				return ValidationErrorf("--%s: stdin (-) can only be used by one flag", fl.Name).
 					WithParam("--"+fl.Name).
-					WithHint("a process has a single stdin, so only one flag per call may use '-'; pass the others inline or as @file with a relative path under the current directory (e.g. --%s @./payload.json)", fl.Name)
+					WithHint("a process has a single stdin, so only one flag per call may use '-'; pass the others as @file (e.g. --%s @/path/to/file)", fl.Name)
 			}
 			rctx.stdinConsumed = true
 			data, err := io.ReadAll(rctx.IO().In)
@@ -1104,16 +1109,9 @@ func resolveInputFlags(rctx *RuntimeContext, flags []Flag) error {
 			}
 			data, err := cmdutil.ReadInputFile(rctx.FileIO(), path)
 			if err != nil {
-				verr := ValidationErrorf("--%s: %v", fl.Name, err).
+				return ValidationErrorf("--%s: %v", fl.Name, err).
 					WithParam("--" + fl.Name).
 					WithCause(err)
-				if slices.Contains(fl.Input, Stdin) {
-					// Rejected @file paths are usually absolute (temp files under
-					// /tmp). Steer toward stdin rather than cd / copying the file
-					// into the project tree.
-					verr = verr.WithHint("this flag also reads stdin: pipe the file contents into this command and pass --%s -", fl.Name)
-				}
-				return verr
 			}
 			// strip a leading UTF-8 BOM so it
 			// can't corrupt the first CSV cell or break JSON parsing downstream.
@@ -1153,19 +1151,14 @@ func handleShortcutDryRun(f *cmdutil.Factory, rctx *RuntimeContext, s *Shortcut)
 		return ValidationErrorf("--dry-run is not supported for %s %s", s.Service, s.Command).
 			WithParam("--dry-run")
 	}
+	fmt.Fprintln(f.IOStreams.ErrOut, "=== Dry Run ===")
 	dryResult := s.DryRun(rctx.ctx, rctx)
-	if dryResult != nil {
-		// Same data.context contract as the service/api dry-run paths.
-		dryResult.Context(rctx.Config.AppID, rctx.UserOpenId())
+	if rctx.Format == "pretty" {
+		fmt.Fprint(f.IOStreams.Out, dryResult.Format())
+	} else {
+		output.PrintJson(f.IOStreams.Out, dryResult)
 	}
-	return cmdutil.WriteDryRun(dryResult, cmdutil.DryRunOutputOptions{
-		Format:      rctx.Format,
-		JqExpr:      rctx.JqExpr,
-		CommandPath: rctx.Cmd.CommandPath(),
-		Identity:    rctx.As(),
-		Out:         f.IOStreams.Out,
-		ErrOut:      f.IOStreams.ErrOut,
-	})
+	return nil
 }
 
 // rejectPositionalArgs returns a cobra.PositionalArgs that rejects any

shortcuts/common/runner_input_test.go

@@ -227,35 +227,6 @@ func TestResolveInputFlags_DuplicateStdin(t *testing.T) {
 	}
 }
 
-// TestResolveInputFlags_FileErrorSuggestsStdin pins the recovery hint when
-// an @file path is rejected (typically an absolute /tmp path): flags that
-// also accept stdin must explain the portable `--flag -` form — never cd'ing
-// into the target directory or copying the file into the project tree.
-func TestResolveInputFlags_FileErrorSuggestsStdin(t *testing.T) {
-	rctx := newTestRuntimeWithStdin(map[string]string{"csv": "@/tmp/does-not-exist.csv"}, "")
-	flags := []Flag{{Name: "csv", Input: []string{File, Stdin}}}
-
-	err := resolveInputFlags(rctx, flags)
-	if err == nil {
-		t.Fatal("expected error for rejected @file path")
-	}
-	vErr := assertValidationParam(t, err, "--csv")
-	if !strings.Contains(vErr.Hint, "pipe the file contents") || !strings.Contains(vErr.Hint, "--csv -") {
-		t.Errorf("hint %q should explain the portable stdin form", vErr.Hint)
-	}
-
-	// A flag without stdin support must not get the stdin hint.
-	rctx = newTestRuntimeWithStdin(map[string]string{"file": "@/tmp/does-not-exist.xlsx"}, "")
-	err = resolveInputFlags(rctx, []Flag{{Name: "file", Input: []string{File}}})
-	if err == nil {
-		t.Fatal("expected error for rejected @file path")
-	}
-	vErr = assertValidationParam(t, err, "--file")
-	if strings.Contains(vErr.Hint, "stdin") {
-		t.Errorf("hint %q must not suggest stdin for a file-only flag", vErr.Hint)
-	}
-}
-
 func TestStripUTF8BOM(t *testing.T) {
 	cases := []struct{ name, in, want string }{
 		{"leading BOM removed", "\uFEFFhello", "hello"},

shortcuts/common/runner_jq_test.go

@@ -6,7 +6,6 @@ package common
 import (
 	"bytes"
 	"context"
-	"encoding/json"
 	"io"
 	"strings"
 	"testing"
@@ -230,75 +229,6 @@ func TestRunShortcut_JqRuntimeError_PropagatesError(t *testing.T) {
 	}
 }
 
-func TestRunShortcut_DryRunJSONUsesEnvelope(t *testing.T) {
-	s := &Shortcut{
-		Service:   "test",
-		Command:   "test-shortcut",
-		AuthTypes: []string{"bot"},
-		DryRun: func(ctx context.Context, rctx *RuntimeContext) *cmdutil.DryRunAPI {
-			return cmdutil.NewDryRunAPI().GET("/open-apis/test")
-		},
-		Execute: func(ctx context.Context, rctx *RuntimeContext) error {
-			t.Fatal("Execute should not run in dry-run")
-			return nil
-		},
-	}
-	f := newTestFactory()
-	cmd := newTestShortcutCmd(s, f)
-	cmd.Flags().Set("dry-run", "true")
-	cmd.Flags().Set("as", "bot")
-
-	if err := runShortcut(cmd, f, s, false); err != nil {
-		t.Fatalf("runShortcut() error = %v", err)
-	}
-	stdout := f.IOStreams.Out.(*bytes.Buffer)
-	var env map[string]interface{}
-	if err := json.Unmarshal(stdout.Bytes(), &env); err != nil {
-		t.Fatalf("dry-run stdout is not JSON: %v\n%s", err, stdout.String())
-	}
-	if env["ok"] != true || env["identity"] != "bot" || env["dry_run"] != true {
-		t.Fatalf("unexpected dry-run envelope: %#v", env)
-	}
-	data := env["data"].(map[string]interface{})
-	api := data["api"].([]interface{})
-	call := api[0].(map[string]interface{})
-	if call["url"] != "/open-apis/test" {
-		t.Fatalf("api[0] = %#v", call)
-	}
-	dctx, ok := data["context"].(map[string]interface{})
-	if !ok || dctx["app_id"] != "test" {
-		t.Fatalf("runner must inject data.context like the service/api paths, got: %#v", data["context"])
-	}
-}
-
-func TestRunShortcut_DryRunWithJq(t *testing.T) {
-	s := &Shortcut{
-		Service:   "test",
-		Command:   "test-shortcut",
-		AuthTypes: []string{"bot"},
-		DryRun: func(ctx context.Context, rctx *RuntimeContext) *cmdutil.DryRunAPI {
-			return cmdutil.NewDryRunAPI().GET("/open-apis/test")
-		},
-		Execute: func(ctx context.Context, rctx *RuntimeContext) error {
-			t.Fatal("Execute should not run in dry-run")
-			return nil
-		},
-	}
-	f := newTestFactory()
-	cmd := newTestShortcutCmd(s, f)
-	cmd.Flags().Set("dry-run", "true")
-	cmd.Flags().Set("jq", ".dry_run")
-	cmd.Flags().Set("as", "bot")
-
-	if err := runShortcut(cmd, f, s, false); err != nil {
-		t.Fatalf("runShortcut() error = %v", err)
-	}
-	stdout := f.IOStreams.Out.(*bytes.Buffer)
-	if got := strings.TrimSpace(stdout.String()); got != "true" {
-		t.Fatalf("jq output = %q, want true", got)
-	}
-}
-
 func TestRuntimeContext_Out_WithoutJq_NormalOutput(t *testing.T) {
 	rctx, stdout, _ := newJqTestContext("", "")
 

shortcuts/drive/drive_add_comment_test.go

@@ -45,16 +45,6 @@ func decodeJSONMap(t *testing.T, raw string) map[string]interface{} {
 	return data
 }
 
-func dryRunDataMap(t *testing.T, raw string) map[string]interface{} {
-	t.Helper()
-	out := decodeJSONMap(t, raw)
-	data, ok := out["data"].(map[string]interface{})
-	if !ok {
-		t.Fatalf("dry-run data is %T, want map[string]interface{}\nstdout:\n%s", out["data"], raw)
-	}
-	return data
-}
-
 func mustMapValue(t *testing.T, value interface{}, path string) map[string]interface{} {
 	t.Helper()
 
@@ -1638,8 +1628,8 @@ func TestDryRunSlidesDirectURL(t *testing.T) {
 	if !strings.Contains(stdout.String(), "slide block comment") {
 		t.Fatalf("dry-run output missing slide block comment: %s", stdout.String())
 	}
-	out := dryRunDataMap(t, stdout.String())
-	api := mustSliceValue(t, out["api"], "data.api")
+	out := decodeJSONMap(t, stdout.String())
+	api := mustSliceValue(t, out["api"], "api")
 	call := mustMapValue(t, api[0], "api[0]")
 	body := mustMapValue(t, call["body"], "api[0].body")
 	anchor := mustMapValue(t, body["anchor"], "api[0].body.anchor")
@@ -1666,8 +1656,8 @@ func TestDryRunBaseDirectURL(t *testing.T) {
 	if !strings.Contains(stdout.String(), "record-local comment") {
 		t.Fatalf("dry-run output missing record-local comment: %s", stdout.String())
 	}
-	out := dryRunDataMap(t, stdout.String())
-	api := mustSliceValue(t, out["api"], "data.api")
+	out := decodeJSONMap(t, stdout.String())
+	api := mustSliceValue(t, out["api"], "api")
 	call := mustMapValue(t, api[0], "api[0]")
 	body := mustMapValue(t, call["body"], "api[0].body")
 	anchor := mustMapValue(t, body["anchor"], "api[0].body.anchor")
@@ -1709,8 +1699,8 @@ func TestDryRunWikiResolvesToSlides(t *testing.T) {
 	if !strings.Contains(stdout.String(), "slide block comment") {
 		t.Fatalf("dry-run output missing slide block comment: %s", stdout.String())
 	}
-	out := dryRunDataMap(t, stdout.String())
-	api := mustSliceValue(t, out["api"], "data.api")
+	out := decodeJSONMap(t, stdout.String())
+	api := mustSliceValue(t, out["api"], "api")
 	call := mustMapValue(t, api[0], "api[0]")
 	body := mustMapValue(t, call["body"], "api[0].body")
 	anchor := mustMapValue(t, body["anchor"], "api[0].body.anchor")
@@ -1746,8 +1736,8 @@ func TestDryRunWikiSlidesInvalidBlockIDSurfaces(t *testing.T) {
 	if !strings.Contains(stdout.String(), "slide --block-id must be") || !strings.Contains(stdout.String(), "shape_2") {
 		t.Fatalf("dry-run output missing block-id format error: %s", stdout.String())
 	}
-	out := dryRunDataMap(t, stdout.String())
-	api := mustSliceValue(t, out["api"], "data.api")
+	out := decodeJSONMap(t, stdout.String())
+	api := mustSliceValue(t, out["api"], "api")
 	if len(api) != 0 {
 		t.Fatalf("dry-run should not preview API calls with malformed block-id: %s", stdout.String())
 	}
@@ -1831,8 +1821,8 @@ func TestDryRunFileDirectURL(t *testing.T) {
 	if !strings.Contains(stdout.String(), "verify supported file metadata") {
 		t.Fatalf("dry-run output missing supported file metadata verification step: %s", stdout.String())
 	}
-	out := dryRunDataMap(t, stdout.String())
-	api := mustSliceValue(t, out["api"], "data.api")
+	out := decodeJSONMap(t, stdout.String())
+	api := mustSliceValue(t, out["api"], "api")
 	if len(api) != 2 {
 		t.Fatalf("expected 2 dry-run api calls, got %d\nstdout:\n%s", len(api), stdout.String())
 	}

shortcuts/drive/drive_export.go

@@ -39,7 +39,7 @@ func wrapExportContextErr(err error) error {
 var DriveExport = common.Shortcut{
 	Service:     "drive",
 	Command:     "+export",
-	Description: "Export a doc/docx/sheet/bitable/slides or wiki document to a local file with limited polling",
+	Description: "Export a doc/docx/sheet/bitable/slides to a local file with limited polling",
 	Risk:        "read",
 	Scopes: []string{
 		"docs:document.content:read",
@@ -47,12 +47,10 @@ var DriveExport = common.Shortcut{
 		"docx:document:readonly",
 		"drive:drive.metadata:readonly",
 	},
-	ConditionalScopes: []string{"wiki:node:retrieve"},
-	AuthTypes:         []string{"user", "bot"},
+	AuthTypes: []string{"user", "bot"},
 	Flags: []common.Flag{
-		{Name: "url", Desc: "source document URL; doc type and token are inferred, and wiki URLs are resolved to the underlying document"},
-		{Name: "token", Desc: "source document token; bare tokens require --doc-type, and wiki tokens should use --doc-type wiki"},
-		{Name: "doc-type", Desc: "source document type: doc | docx | sheet | bitable | slides | wiki (required only when --token is a bare token)", Enum: []string{"doc", "docx", "sheet", "bitable", "slides", "wiki"}},
+		{Name: "token", Desc: "source document token", Required: true},
+		{Name: "doc-type", Desc: "source document type: doc | docx | sheet | bitable | slides", Required: true, Enum: []string{"doc", "docx", "sheet", "bitable", "slides"}},
 		{Name: "file-extension", Desc: "export format: docx | pdf | xlsx | csv | markdown | base (bitable only) | pptx (slides only)", Required: true, Enum: []string{"docx", "pdf", "xlsx", "csv", "markdown", "base", "pptx"}},
 		{Name: "sub-id", Desc: "sub-table/sheet ID, required when exporting sheet/bitable as csv"},
 		{Name: "only-schema", Type: "bool", Desc: "export only bitable schema when --doc-type bitable --file-extension base"},
@@ -77,7 +75,6 @@ var DriveExport = common.Shortcut{
 // task and poll, but do not download" — callers that only need the ready file
 // token / status get it back without writing a local file.
 type ExportParams struct {
-	URL           string
 	Token         string
 	DocType       string
 	FileExtension string
@@ -90,7 +87,6 @@ type ExportParams struct {
 
 func (p ExportParams) spec() driveExportSpec {
 	return driveExportSpec{
-		URL:           p.URL,
 		Token:         p.Token,
 		DocType:       p.DocType,
 		FileExtension: p.FileExtension,
@@ -110,7 +106,6 @@ func exportParamsFromFlags(runtime *common.RuntimeContext) ExportParams {
 		outputDir = "."
 	}
 	return ExportParams{
-		URL:           runtime.Str("url"),
 		Token:         runtime.Str("token"),
 		DocType:       runtime.Str("doc-type"),
 		FileExtension: runtime.Str("file-extension"),
@@ -132,90 +127,60 @@ func validateExport(p ExportParams) error {
 
 // PlanExportDryRun builds the dry-run plan for an export without performing I/O.
 func PlanExportDryRun(runtime *common.RuntimeContext, p ExportParams) *common.DryRunAPI {
-	spec, source, err := normalizeDriveExportSpecInput(p.spec())
-	if err != nil {
-		return common.NewDryRunAPI().Set("error", err.Error())
-	}
-	if err := validateDriveExportNormalizedSpecForSource(spec, source); err != nil {
-		return common.NewDryRunAPI().Set("error", err.Error())
-	}
-
-	dry := common.NewDryRunAPI()
-	if source.Type == "wiki" {
-		dry.GET("/open-apis/wiki/v2/spaces/get_node").
-			Desc("[0] Resolve wiki node to underlying document token").
-			Params(map[string]interface{}{"token": source.Token})
-		spec.Token = "obj_token_from_step_0"
-		if spec.DocType == "" {
-			spec.DocType = "obj_type_from_step_0"
-		}
-		dry.Set("wiki_token", source.Token)
-	}
-
+	spec := p.spec()
 	// Markdown export is a special case: docx markdown comes from the V2
 	// docs_ai fetch API directly instead of the Drive export task API.
 	if spec.FileExtension == "markdown" {
 		apiPath := fmt.Sprintf("/open-apis/docs_ai/v1/documents/%s/fetch", validate.EncodePathSegment(spec.Token))
-		desc := "2-step orchestration: fetch docx markdown -> write local file"
-		if source.Type == "wiki" {
-			desc = "3-step orchestration: resolve wiki -> fetch docx markdown -> write local file"
-		}
-		dry.Desc(desc).
+		dr := common.NewDryRunAPI().
+			Desc("2-step orchestration: fetch docx markdown -> write local file").
 			POST(apiPath).
 			Body(map[string]interface{}{
 				"format": "markdown",
 			}).
 			Set("output_dir", p.OutputDir)
 		if name := strings.TrimSpace(p.FileName); name != "" {
-			dry.Set("file_name", ensureExportFileExtension(sanitizeExportFileName(name, spec.Token), spec.FileExtension))
+			dr.Set("file_name", ensureExportFileExtension(sanitizeExportFileName(name, spec.Token), spec.FileExtension))
 		}
-		return dry
+		return dr
 	}
 
-	desc := "3-step orchestration: create export task -> limited polling -> download file"
-	if source.Type == "wiki" {
-		desc = "4-step orchestration: resolve wiki -> create export task -> limited polling -> download file"
+	body := map[string]interface{}{
+		"token":          spec.Token,
+		"type":           spec.DocType,
+		"file_extension": spec.FileExtension,
 	}
-	dry.Desc(desc).
+	if strings.TrimSpace(spec.SubID) != "" {
+		body["sub_id"] = spec.SubID
+	}
+	if spec.OnlySchema {
+		body["only_schema"] = true
+	}
+
+	dr := common.NewDryRunAPI().
+		Desc("3-step orchestration: create export task -> limited polling -> download file").
 		POST("/open-apis/drive/v1/export_tasks").
-		Body(buildDriveExportTaskBody(spec)).
+		Body(body).
 		Set("output_dir", p.OutputDir)
 	if name := strings.TrimSpace(p.FileName); name != "" {
-		dry.Set("file_name", ensureExportFileExtension(sanitizeExportFileName(name, spec.Token), spec.FileExtension))
+		dr.Set("file_name", ensureExportFileExtension(sanitizeExportFileName(name, spec.Token), spec.FileExtension))
 	}
-	return dry
+	return dr
 }
 
 // RunExport drives create export task -> bounded poll -> optional download. It
 // is the shared core behind both drive +export and sheets +workbook-export. An
 // empty p.OutputDir skips the download step and returns the ready file token.
 func RunExport(ctx context.Context, runtime *common.RuntimeContext, p ExportParams) error {
-	spec, source, err := normalizeDriveExportSpecInput(p.spec())
-	if err != nil {
-		return err
-	}
-	if err := validateDriveExportNormalizedSpecForSource(spec, source); err != nil {
-		return err
-	}
-
+	spec := p.spec()
 	outputDir := p.OutputDir
 	preferredFileName := strings.TrimSpace(p.FileName)
 	overwrite := p.Overwrite
 
-	var wikiResolution driveExportWikiResolution
-
 	// Markdown export bypasses the async export task and writes the fetched
 	// markdown content directly to disk. Uses the V2 docs_ai fetch API for
 	// higher-quality Lark-flavored Markdown output.
 	if spec.FileExtension == "markdown" {
-		if source.Type == "wiki" {
-			resolvedSpec, resolution, err := resolveDriveExportWikiSource(ctx, runtime, spec, source.Token)
-			if err != nil {
-				return err
-			}
-			spec = resolvedSpec
-			wikiResolution = resolution
-		}
 		fmt.Fprintf(runtime.IO().ErrOut, "Exporting docx as markdown: %s\n", common.MaskToken(spec.Token))
 		apiPath := fmt.Sprintf("/open-apis/docs_ai/v1/documents/%s/fetch", validate.EncodePathSegment(spec.Token))
 		data, err := runtime.CallAPITyped(
@@ -257,23 +222,21 @@ func RunExport(ctx context.Context, runtime *common.RuntimeContext, p ExportPara
 			return err
 		}
 
-		runtime.Out(annotateDriveExportWikiOutput(map[string]interface{}{
+		runtime.Out(map[string]interface{}{
 			"token":          spec.Token,
 			"doc_type":       spec.DocType,
 			"file_extension": spec.FileExtension,
 			"file_name":      filepath.Base(savedPath),
 			"saved_path":     savedPath,
 			"size_bytes":     len(content),
-		}, wikiResolution), nil)
+		}, nil)
 		return nil
 	}
 
-	ticket, resolvedSpec, resolution, err := createDriveExportTaskResolvingWiki(ctx, runtime, spec, source)
+	ticket, err := createDriveExportTask(runtime, spec)
 	if err != nil {
 		return err
 	}
-	spec = resolvedSpec
-	wikiResolution = resolution
 	fmt.Fprintf(runtime.IO().ErrOut, "Created export task: %s\n", ticket)
 
 	var lastStatus driveExportStatus
@@ -311,7 +274,7 @@ func RunExport(ctx context.Context, runtime *common.RuntimeContext, p ExportPara
 			// no local download (e.g. sheets +workbook-export without an output
 			// path). Skip the download and return the status envelope.
 			if strings.TrimSpace(outputDir) == "" {
-				runtime.Out(annotateDriveExportWikiOutput(map[string]interface{}{
+				runtime.Out(map[string]interface{}{
 					"ticket":         ticket,
 					"token":          spec.Token,
 					"doc_type":       spec.DocType,
@@ -321,7 +284,7 @@ func RunExport(ctx context.Context, runtime *common.RuntimeContext, p ExportPara
 					"file_size":      status.FileSize,
 					"ready":          true,
 					"downloaded":     false,
-				}, wikiResolution), nil)
+				}, nil)
 				return nil
 			}
 
@@ -344,7 +307,7 @@ func RunExport(ctx context.Context, runtime *common.RuntimeContext, p ExportPara
 			out["ticket"] = ticket
 			out["doc_type"] = spec.DocType
 			out["file_extension"] = spec.FileExtension
-			runtime.Out(annotateDriveExportWikiOutput(out, wikiResolution), nil)
+			runtime.Out(out, nil)
 			return nil
 		}
 
@@ -394,19 +357,7 @@ func RunExport(ctx context.Context, runtime *common.RuntimeContext, p ExportPara
 	if preferredFileName != "" {
 		result["file_name"] = ensureExportFileExtension(sanitizeExportFileName(preferredFileName, spec.Token), spec.FileExtension)
 	}
-	runtime.Out(annotateDriveExportWikiOutput(result, wikiResolution), nil)
+	runtime.Out(result, nil)
 	fmt.Fprintf(runtime.IO().ErrOut, "Export task is still in progress. Continue with: %s\n", nextCommand)
 	return nil
 }
-
-func annotateDriveExportWikiOutput(out map[string]interface{}, resolution driveExportWikiResolution) map[string]interface{} {
-	if !resolution.Resolved {
-		return out
-	}
-	out["wiki_token"] = resolution.WikiToken
-	out["wiki_node"] = map[string]interface{}{
-		"obj_token": resolution.ObjToken,
-		"obj_type":  resolution.ObjType,
-	}
-	return out
-}

shortcuts/drive/drive_export_common.go

@@ -27,16 +27,9 @@ var (
 	driveExportPollInterval = 5 * time.Second
 )
 
-const (
-	driveExportResolvedDocTypeValues = "doc, docx, sheet, bitable, slides"
-	driveExportInputDocTypeValues    = driveExportResolvedDocTypeValues + ", wiki"
-	driveExportFileExtensionValues   = "docx, pdf, xlsx, csv, markdown, base, pptx"
-)
-
 // driveExportSpec contains the normalized export request understood by the
 // shortcut and the underlying export task APIs.
 type driveExportSpec struct {
-	URL           string
 	Token         string
 	DocType       string
 	FileExtension string
@@ -44,19 +37,6 @@ type driveExportSpec struct {
 	OnlySchema    bool
 }
 
-type driveExportInputSource struct {
-	Type  string
-	Token string
-	Param string
-}
-
-type driveExportWikiResolution struct {
-	Resolved  bool
-	WikiToken string
-	ObjToken  string
-	ObjType   string
-}
-
 // driveExportTaskResultCommand prints the resume command shown when bounded
 // export polling times out locally.
 func driveExportTaskResultCommand(ticket, docToken string) string {
@@ -147,49 +127,45 @@ func (s driveExportStatus) StatusLabel() string {
 // validateDriveExportSpec enforces shortcut-level export constraints before any
 // backend request is sent.
 func validateDriveExportSpec(spec driveExportSpec) error {
-	normalized, source, err := normalizeDriveExportSpecInput(spec)
-	if err != nil {
-		return err
+	if err := validate.ResourceName(spec.Token, "--token"); err != nil {
+		return errs.NewValidationError(errs.SubtypeInvalidArgument, "%s", err).WithParam("--token")
 	}
-	return validateDriveExportNormalizedSpecForSource(normalized, source)
-}
 
-func validateDriveExportNormalizedSpec(spec driveExportSpec) error {
 	switch spec.DocType {
 	case "doc", "docx", "sheet", "bitable", "slides":
 	default:
-		return errs.NewValidationError(errs.SubtypeInvalidArgument, "invalid --doc-type %q: allowed values are %s", spec.DocType, driveExportInputDocTypeValues).
-			WithParam("--doc-type").
-			WithHint("use --url when you have a document URL; use --doc-type wiki only with a bare Wiki node token so the CLI can resolve the underlying document type")
-	}
-
-	if err := validate.ResourceName(spec.Token, "--token"); err != nil {
-		return errs.NewValidationError(errs.SubtypeInvalidArgument, "%s", err).WithParam("--token")
+		return errs.NewValidationError(errs.SubtypeInvalidArgument, "invalid --doc-type %q: allowed values are doc, docx, sheet, bitable, slides", spec.DocType).WithParam("--doc-type")
 	}
 
 	switch spec.FileExtension {
 	case "docx", "pdf", "xlsx", "csv", "markdown", "base", "pptx":
 	default:
-		return errs.NewValidationError(errs.SubtypeInvalidArgument, "invalid --file-extension %q: allowed values are %s", spec.FileExtension, driveExportFileExtensionValues).
-			WithParam("--file-extension").
-			WithHint("choose an export format supported by the source type; common choices are docx/pdf for docs, xlsx/csv for sheets, xlsx/csv/base for bitable, and pptx/pdf for slides")
+		return errs.NewValidationError(errs.SubtypeInvalidArgument, "invalid --file-extension %q: allowed values are docx, pdf, xlsx, csv, markdown, base, pptx", spec.FileExtension).WithParam("--file-extension")
 	}
 
-	if err := validateDriveExportFormatCompatibility(spec); err != nil {
-		return err
+	if spec.FileExtension == "markdown" && spec.DocType != "docx" {
+		return errs.NewValidationError(errs.SubtypeInvalidArgument, "--file-extension markdown only supports --doc-type docx")
+	}
+
+	if spec.FileExtension == "base" && spec.DocType != "bitable" {
+		return errs.NewValidationError(errs.SubtypeInvalidArgument, "--file-extension base only supports --doc-type bitable")
 	}
 
 	if spec.OnlySchema && (spec.DocType != "bitable" || spec.FileExtension != "base") {
-		return errs.NewValidationError(errs.SubtypeInvalidArgument, "--only-schema is only used when exporting bitable as base").
-			WithParam("--only-schema").
-			WithHint("retry with --doc-type bitable --file-extension base, or remove --only-schema")
+		return errs.NewValidationError(errs.SubtypeInvalidArgument, "--only-schema is only used when exporting bitable as base").WithParam("--only-schema")
+	}
+
+	if spec.FileExtension == "pptx" && spec.DocType != "slides" {
+		return errs.NewValidationError(errs.SubtypeInvalidArgument, "--file-extension pptx only supports --doc-type slides")
+	}
+
+	if spec.DocType == "slides" && spec.FileExtension != "pptx" && spec.FileExtension != "pdf" {
+		return errs.NewValidationError(errs.SubtypeInvalidArgument, "--doc-type slides only supports --file-extension pptx or pdf")
 	}
 
 	if strings.TrimSpace(spec.SubID) != "" {
 		if spec.FileExtension != "csv" || (spec.DocType != "sheet" && spec.DocType != "bitable") {
-			return errs.NewValidationError(errs.SubtypeInvalidArgument, "--sub-id is only used when exporting sheet/bitable as csv").
-				WithParam("--sub-id").
-				WithHint("remove --sub-id, or retry with --doc-type sheet|bitable --file-extension csv")
+			return errs.NewValidationError(errs.SubtypeInvalidArgument, "--sub-id is only used when exporting sheet/bitable as csv").WithParam("--sub-id")
 		}
 		if err := validate.ResourceName(spec.SubID, "--sub-id"); err != nil {
 			return errs.NewValidationError(errs.SubtypeInvalidArgument, "%s", err).WithParam("--sub-id")
@@ -197,212 +173,15 @@ func validateDriveExportNormalizedSpec(spec driveExportSpec) error {
 	}
 
 	if spec.FileExtension == "csv" && (spec.DocType == "sheet" || spec.DocType == "bitable") && strings.TrimSpace(spec.SubID) == "" {
-		return errs.NewValidationError(errs.SubtypeInvalidArgument, "--sub-id is required when exporting sheet/bitable as csv").
-			WithParam("--sub-id").
-			WithHint("retry with --sub-id <sheet_id_or_table_id>; if you need the whole workbook, use --file-extension xlsx instead")
+		return errs.NewValidationError(errs.SubtypeInvalidArgument, "--sub-id is required when exporting sheet/bitable as csv").WithParam("--sub-id")
 	}
 
 	return nil
 }
 
-func validateDriveExportFormatCompatibility(spec driveExportSpec) error {
-	if driveExportFileExtensionAllowedForDocType(spec.DocType, spec.FileExtension) {
-		return nil
-	}
-	allowed := strings.Join(driveExportAllowedFileExtensions(spec.DocType), ", ")
-	return errs.NewValidationError(
-		errs.SubtypeInvalidArgument,
-		"unsupported export format: --doc-type %s cannot be exported as %s",
-		spec.DocType,
-		spec.FileExtension,
-	).
-		WithParam("--file-extension").
-		WithHint("retry with --file-extension %s. If the token came from a URL, prefer --url so the CLI infers the correct source type before validating the export format", allowed)
-}
-
-func driveExportFileExtensionAllowedForDocType(docType, fileExtension string) bool {
-	for _, allowed := range driveExportAllowedFileExtensions(docType) {
-		if fileExtension == allowed {
-			return true
-		}
-	}
-	return false
-}
-
-func driveExportAllowedFileExtensions(docType string) []string {
-	switch normalizeDriveExportDocType(docType) {
-	case "doc":
-		return []string{"docx", "pdf"}
-	case "docx":
-		return []string{"docx", "pdf", "markdown"}
-	case "sheet":
-		return []string{"xlsx", "csv"}
-	case "bitable":
-		return []string{"xlsx", "csv", "base"}
-	case "slides":
-		return []string{"pptx", "pdf"}
-	default:
-		return []string{"docx", "pdf", "xlsx", "csv", "markdown", "base", "pptx"}
-	}
-}
-
-func validateDriveExportNormalizedSpecForSource(spec driveExportSpec, source driveExportInputSource) error {
-	if source.Type == "wiki" && spec.DocType == "" {
-		return validateDriveExportPendingWikiSpec(spec, source)
-	}
-	return validateDriveExportNormalizedSpec(spec)
-}
-
-func validateDriveExportPendingWikiSpec(spec driveExportSpec, source driveExportInputSource) error {
-	param := source.Param
-	if param == "" {
-		param = "--token"
-	}
-	if err := validate.ResourceName(spec.Token, param); err != nil {
-		return errs.NewValidationError(errs.SubtypeInvalidArgument, "%s", err).WithParam(param)
-	}
-
-	switch spec.FileExtension {
-	case "docx", "pdf", "xlsx", "csv", "markdown", "base", "pptx":
-	default:
-		return errs.NewValidationError(errs.SubtypeInvalidArgument, "invalid --file-extension %q: allowed values are %s", spec.FileExtension, driveExportFileExtensionValues).
-			WithParam("--file-extension").
-			WithHint("Wiki export format is validated after resolving the Wiki node; choose a format normally supported by the underlying document type")
-	}
-	if spec.OnlySchema && spec.FileExtension != "base" {
-		return errs.NewValidationError(errs.SubtypeInvalidArgument, "--only-schema is only used when exporting bitable as base").
-			WithParam("--only-schema").
-			WithHint("retry with --file-extension base, or remove --only-schema")
-	}
-	if strings.TrimSpace(spec.SubID) != "" && spec.FileExtension != "csv" {
-		return errs.NewValidationError(errs.SubtypeInvalidArgument, "--sub-id is only used when exporting sheet/bitable as csv").
-			WithParam("--sub-id").
-			WithHint("remove --sub-id, or retry with --file-extension csv if the Wiki node resolves to a sheet/bitable")
-	}
-	if strings.TrimSpace(spec.SubID) != "" {
-		if err := validate.ResourceName(spec.SubID, "--sub-id"); err != nil {
-			return errs.NewValidationError(errs.SubtypeInvalidArgument, "%s", err).WithParam("--sub-id")
-		}
-	}
-	return nil
-}
-
-func normalizeDriveExportSpecInput(spec driveExportSpec) (driveExportSpec, driveExportInputSource, error) {
-	spec.URL = strings.TrimSpace(spec.URL)
-	spec.Token = strings.TrimSpace(spec.Token)
-	spec.DocType = strings.ToLower(strings.TrimSpace(spec.DocType))
-	spec.FileExtension = strings.ToLower(strings.TrimSpace(spec.FileExtension))
-
-	if spec.Token == "" && spec.URL == "" {
-		return spec, driveExportInputSource{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "either --url or --token is required").WithParam("--url")
-	}
-	if spec.Token != "" && spec.URL != "" {
-		return spec, driveExportInputSource{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "--url and --token are mutually exclusive").WithParam("--url")
-	}
-
-	source := driveExportInputSource{
-		Type:  spec.DocType,
-		Token: spec.Token,
-		Param: "--token",
-	}
-
-	rawInput := spec.Token
-	inputParam := "--token"
-	if spec.URL != "" {
-		rawInput = spec.URL
-		inputParam = "--url"
-	}
-
-	if ref, ok := common.ParseResourceURL(rawInput); ok {
-		refType := normalizeDriveExportDocType(ref.Type)
-		source = driveExportInputSource{
-			Type:  refType,
-			Token: ref.Token,
-			Param: inputParam,
-		}
-		spec.Token = ref.Token
-		if refType != "wiki" {
-			if !isDriveExportDocType(refType) {
-				return spec, source, errs.NewValidationError(
-					errs.SubtypeInvalidArgument,
-					"%s URL type %q is not supported by drive +export; use a doc/docx/sheet/base/slides/wiki URL or token",
-					inputParam,
-					ref.Type,
-				).WithParam(inputParam)
-			}
-			if spec.DocType == "wiki" {
-				return spec, source, errs.NewValidationError(
-					errs.SubtypeInvalidArgument,
-					"--doc-type wiki conflicts with %s URL type %q",
-					inputParam,
-					refType,
-				).
-					WithParam("--doc-type").
-					WithHint("remove --doc-type when passing --url; the CLI will infer %q from the URL", refType)
-			}
-			if spec.DocType != "" && spec.DocType != refType {
-				return spec, source, errs.NewValidationError(
-					errs.SubtypeInvalidArgument,
-					"--doc-type %q conflicts with %s URL type %q",
-					spec.DocType,
-					inputParam,
-					refType,
-				).WithParam("--doc-type")
-			}
-			spec.DocType = refType
-		} else if spec.DocType == "wiki" {
-			spec.DocType = ""
-		}
-		return spec, source, nil
-	}
-
-	if strings.Contains(rawInput, "://") {
-		return spec, source, errs.NewValidationError(
-			errs.SubtypeInvalidArgument,
-			"unsupported %s URL %q: use a recognized Lark document URL",
-			inputParam,
-			rawInput,
-		).WithParam(inputParam)
-	}
-	if spec.URL != "" {
-		return spec, source, errs.NewValidationError(
-			errs.SubtypeInvalidArgument,
-			"unsupported --url %q: use a recognized Lark document URL",
-			spec.URL,
-		).WithParam("--url")
-	}
-	if spec.DocType == "" {
-		return spec, source, errs.NewValidationError(errs.SubtypeInvalidArgument, "--doc-type is required when --token is a bare token (allowed: %s)", driveExportInputDocTypeValues).
-			WithParam("--doc-type").
-			WithHint("if you have the original document link, prefer --url <document_url>; if this is a Wiki node token, use --doc-type wiki")
-	}
-	if spec.DocType == "wiki" {
-		source.Type = "wiki"
-		source.Token = spec.Token
-		spec.DocType = ""
-	}
-	return spec, source, nil
-}
-
-func normalizeDriveExportDocType(docType string) string {
-	switch strings.ToLower(strings.TrimSpace(docType)) {
-	case "base":
-		return "bitable"
-	default:
-		return strings.ToLower(strings.TrimSpace(docType))
-	}
-}
-
-func isDriveExportDocType(docType string) bool {
-	switch normalizeDriveExportDocType(docType) {
-	case "doc", "docx", "sheet", "bitable", "slides":
-		return true
-	default:
-		return false
-	}
-}
-
-func buildDriveExportTaskBody(spec driveExportSpec) map[string]interface{} {
+// createDriveExportTask starts the asynchronous export job and returns its
+// ticket for subsequent polling.
+func createDriveExportTask(runtime *common.RuntimeContext, spec driveExportSpec) (string, error) {
 	body := map[string]interface{}{
 		"token":          spec.Token,
 		"type":           spec.DocType,
@@ -414,13 +193,8 @@ func buildDriveExportTaskBody(spec driveExportSpec) map[string]interface{} {
 	if spec.OnlySchema {
 		body["only_schema"] = true
 	}
-	return body
-}
 
-// createDriveExportTask starts the asynchronous export job and returns its
-// ticket for subsequent polling.
-func createDriveExportTask(runtime *common.RuntimeContext, spec driveExportSpec) (string, error) {
-	data, err := runtime.CallAPITyped("POST", "/open-apis/drive/v1/export_tasks", nil, buildDriveExportTaskBody(spec))
+	data, err := runtime.CallAPITyped("POST", "/open-apis/drive/v1/export_tasks", nil, body)
 	if err != nil {
 		return "", err
 	}
@@ -432,79 +206,6 @@ func createDriveExportTask(runtime *common.RuntimeContext, spec driveExportSpec)
 	return ticket, nil
 }
 
-func resolveDriveExportWikiSource(ctx context.Context, runtime *common.RuntimeContext, spec driveExportSpec, wikiToken string) (driveExportSpec, driveExportWikiResolution, error) {
-	wikiToken = strings.TrimSpace(wikiToken)
-	if err := validate.ResourceName(wikiToken, "--token"); err != nil {
-		return spec, driveExportWikiResolution{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "%s", err).WithParam("--token")
-	}
-
-	fmt.Fprintf(runtime.IO().ErrOut, "Resolving wiki node for export: %s\n", common.MaskToken(wikiToken))
-	data, err := driveInspectCallWithRetry(ctx, func() (map[string]interface{}, error) {
-		return runtime.CallAPITyped(
-			"GET",
-			"/open-apis/wiki/v2/spaces/get_node",
-			map[string]interface{}{"token": wikiToken},
-			nil,
-		)
-	})
-	if err != nil {
-		return spec, driveExportWikiResolution{}, err
-	}
-
-	node := common.GetMap(data, "node")
-	objType := normalizeDriveExportDocType(common.GetString(node, "obj_type"))
-	objToken := common.GetString(node, "obj_token")
-	if objType == "" || objToken == "" {
-		return spec, driveExportWikiResolution{}, errs.NewInternalError(errs.SubtypeInvalidResponse, "wiki get_node returned incomplete node data (obj_type=%q, obj_token=%q)", objType, objToken)
-	}
-	if !isDriveExportDocType(objType) {
-		return spec, driveExportWikiResolution{}, errs.NewValidationError(
-			errs.SubtypeInvalidArgument,
-			"wiki resolved to %q, but drive +export only supports doc, docx, sheet, bitable, and slides",
-			objType,
-		).WithParam("--token")
-	}
-	if spec.DocType != "" && spec.DocType != objType {
-		return spec, driveExportWikiResolution{}, errs.NewValidationError(
-			errs.SubtypeInvalidArgument,
-			"wiki resolved to %q, but --doc-type is %q; use --doc-type %s",
-			objType,
-			spec.DocType,
-			objType,
-		).WithParam("--doc-type")
-	}
-
-	spec.Token = objToken
-	spec.DocType = objType
-	if err := validateDriveExportNormalizedSpec(spec); err != nil {
-		return spec, driveExportWikiResolution{}, err
-	}
-	fmt.Fprintf(runtime.IO().ErrOut, "Resolved wiki to %s: %s\n", objType, common.MaskToken(objToken))
-	return spec, driveExportWikiResolution{
-		Resolved:  true,
-		WikiToken: wikiToken,
-		ObjToken:  objToken,
-		ObjType:   objType,
-	}, nil
-}
-
-func createDriveExportTaskResolvingWiki(ctx context.Context, runtime *common.RuntimeContext, spec driveExportSpec, source driveExportInputSource) (string, driveExportSpec, driveExportWikiResolution, error) {
-	if source.Type == "wiki" {
-		resolvedSpec, resolution, err := resolveDriveExportWikiSource(ctx, runtime, spec, source.Token)
-		if err != nil {
-			return "", spec, resolution, err
-		}
-		ticket, err := createDriveExportTask(runtime, resolvedSpec)
-		return ticket, resolvedSpec, resolution, err
-	}
-
-	ticket, err := createDriveExportTask(runtime, spec)
-	if err != nil {
-		return "", spec, driveExportWikiResolution{}, err
-	}
-	return ticket, spec, driveExportWikiResolution{}, nil
-}
-
 // getDriveExportStatus fetches the current backend state for a previously
 // created export task.
 func getDriveExportStatus(runtime *common.RuntimeContext, token, ticket string) (driveExportStatus, error) {

shortcuts/drive/drive_export_test.go

@@ -33,36 +33,10 @@ func TestValidateDriveExportSpec(t *testing.T) {
 			name: "markdown docx ok",
 			spec: driveExportSpec{Token: "docx123", DocType: "docx", FileExtension: "markdown"},
 		},
-		{
-			name: "docx url infers doc type",
-			spec: driveExportSpec{URL: "https://example.feishu.cn/docx/docxURL123", FileExtension: "pdf"},
-		},
-		{
-			name: "wiki url can defer doc type until resolution",
-			spec: driveExportSpec{URL: "https://example.feishu.cn/wiki/wikiURL123", FileExtension: "pdf"},
-		},
-		{
-			name: "wiki url with doc-type wiki can defer doc type until resolution",
-			spec: driveExportSpec{URL: "https://example.feishu.cn/wiki/wikiURL123", DocType: "wiki", FileExtension: "pdf"},
-		},
-		{
-			name: "wiki token with doc-type wiki can defer doc type until resolution",
-			spec: driveExportSpec{Token: "wiki123", DocType: "wiki", FileExtension: "pdf"},
-		},
-		{
-			name:    "bare token requires doc type",
-			spec:    driveExportSpec{Token: "docx123", FileExtension: "pdf"},
-			wantErr: "--doc-type is required",
-		},
 		{
 			name:    "markdown non docx rejected",
 			spec:    driveExportSpec{Token: "doc123", DocType: "doc", FileExtension: "markdown"},
-			wantErr: "cannot be exported as markdown",
-		},
-		{
-			name:    "docx csv rejected",
-			spec:    driveExportSpec{Token: "docx123", DocType: "docx", FileExtension: "csv"},
-			wantErr: "cannot be exported as csv",
+			wantErr: "only supports --doc-type docx",
 		},
 		{
 			name:    "csv without sub id rejected",
@@ -98,27 +72,17 @@ func TestValidateDriveExportSpec(t *testing.T) {
 		{
 			name:    "base non bitable rejected",
 			spec:    driveExportSpec{Token: "sheet123", DocType: "sheet", FileExtension: "base"},
-			wantErr: "cannot be exported as base",
-		},
-		{
-			name:    "sheet pdf rejected",
-			spec:    driveExportSpec{Token: "sheet123", DocType: "sheet", FileExtension: "pdf"},
-			wantErr: "cannot be exported as pdf",
-		},
-		{
-			name:    "bitable pdf rejected",
-			spec:    driveExportSpec{Token: "base123", DocType: "bitable", FileExtension: "pdf"},
-			wantErr: "cannot be exported as pdf",
+			wantErr: "only supports --doc-type bitable",
 		},
 		{
 			name:    "pptx non slides rejected",
 			spec:    driveExportSpec{Token: "docx123", DocType: "docx", FileExtension: "pptx"},
-			wantErr: "cannot be exported as pptx",
+			wantErr: "only supports --doc-type slides",
 		},
 		{
 			name:    "slides csv rejected",
 			spec:    driveExportSpec{Token: "slides123", DocType: "slides", FileExtension: "csv"},
-			wantErr: "cannot be exported as csv",
+			wantErr: "slides only supports",
 		},
 		{
 			name:    "unknown doc type rejected",
@@ -149,29 +113,6 @@ func TestValidateDriveExportSpec(t *testing.T) {
 	}
 }
 
-func TestValidateDriveExportUnsupportedFormatHasHint(t *testing.T) {
-	t.Parallel()
-
-	err := validateDriveExportSpec(driveExportSpec{
-		Token:         "docx123",
-		DocType:       "docx",
-		FileExtension: "csv",
-	})
-	if err == nil {
-		t.Fatal("expected unsupported format error, got nil")
-	}
-	var valErr *errs.ValidationError
-	if !errors.As(err, &valErr) {
-		t.Fatalf("expected *errs.ValidationError, got %T", err)
-	}
-	if valErr.Param != "--file-extension" {
-		t.Fatalf("param = %q, want --file-extension", valErr.Param)
-	}
-	if !strings.Contains(valErr.Hint, "docx, pdf, markdown") || !strings.Contains(valErr.Hint, "--url") {
-		t.Fatalf("hint = %q, want allowed formats and URL retry guidance", valErr.Hint)
-	}
-}
-
 func TestDriveExportMarkdownWritesFile(t *testing.T) {
 	f, stdout, _, reg := cmdutil.TestFactory(t, driveTestConfig())
 	fetchStub := &httpmock.Stub{
@@ -499,76 +440,6 @@ func TestDriveExportMarkdownRejectsMissingDocumentContent(t *testing.T) {
 	}
 }
 
-func TestDriveExportURLInfersDocType(t *testing.T) {
-	f, stdout, _, reg := cmdutil.TestFactory(t, driveTestConfig())
-	createStub := &httpmock.Stub{
-		Method: "POST",
-		URL:    "/open-apis/drive/v1/export_tasks",
-		Body: map[string]interface{}{
-			"code": 0,
-			"data": map[string]interface{}{"ticket": "tk_url"},
-		},
-	}
-	reg.Register(createStub)
-	reg.Register(&httpmock.Stub{
-		Method: "GET",
-		URL:    "/open-apis/drive/v1/export_tasks/tk_url",
-		Body: map[string]interface{}{
-			"code": 0,
-			"data": map[string]interface{}{
-				"result": map[string]interface{}{
-					"job_status":     0,
-					"file_token":     "box_url",
-					"file_name":      "url-report",
-					"file_extension": "pdf",
-					"type":           "docx",
-					"file_size":      3,
-				},
-			},
-		},
-	})
-	reg.Register(&httpmock.Stub{
-		Method:  "GET",
-		URL:     "/open-apis/drive/v1/export_tasks/file/box_url/download",
-		Status:  200,
-		RawBody: []byte("pdf"),
-		Headers: http.Header{
-			"Content-Type":        []string{"application/pdf"},
-			"Content-Disposition": []string{`attachment; filename="url-report.pdf"`},
-		},
-	})
-
-	tmpDir := t.TempDir()
-	withDriveWorkingDir(t, tmpDir)
-
-	prevAttempts, prevInterval := driveExportPollAttempts, driveExportPollInterval
-	driveExportPollAttempts, driveExportPollInterval = 1, 0
-	t.Cleanup(func() {
-		driveExportPollAttempts, driveExportPollInterval = prevAttempts, prevInterval
-	})
-
-	err := mountAndRunDrive(t, DriveExport, []string{
-		"+export",
-		"--url", "https://example.feishu.cn/docx/docxURL123",
-		"--file-extension", "pdf",
-		"--as", "bot",
-	}, f, stdout)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	var createBody map[string]interface{}
-	if err := json.Unmarshal(createStub.CapturedBody, &createBody); err != nil {
-		t.Fatalf("unmarshal export_tasks body: %v", err)
-	}
-	if createBody["token"] != "docxURL123" {
-		t.Fatalf("export_tasks body token = %v, want token from URL", createBody["token"])
-	}
-	if createBody["type"] != "docx" {
-		t.Fatalf("export_tasks body type = %v, want inferred docx", createBody["type"])
-	}
-}
-
 func TestDriveExportAsyncSuccess(t *testing.T) {
 	f, stdout, _, reg := cmdutil.TestFactory(t, driveTestConfig())
 	reg.Register(&httpmock.Stub{
@@ -639,266 +510,6 @@ func TestDriveExportAsyncSuccess(t *testing.T) {
 	}
 }
 
-func TestDriveExportWikiURLResolvesBeforeAsyncTask(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,
-			"data": map[string]interface{}{
-				"node": map[string]interface{}{
-					"obj_type":  "docx",
-					"obj_token": "docxResolved",
-				},
-			},
-		},
-	})
-	createStub := &httpmock.Stub{
-		Method: "POST",
-		URL:    "/open-apis/drive/v1/export_tasks",
-		Body: map[string]interface{}{
-			"code": 0,
-			"data": map[string]interface{}{"ticket": "tk_wiki"},
-		},
-	}
-	reg.Register(createStub)
-	reg.Register(&httpmock.Stub{
-		Method: "GET",
-		URL:    "/open-apis/drive/v1/export_tasks/tk_wiki",
-		Body: map[string]interface{}{
-			"code": 0,
-			"data": map[string]interface{}{
-				"result": map[string]interface{}{
-					"job_status":     0,
-					"file_token":     "box_wiki",
-					"file_name":      "wiki-report",
-					"file_extension": "pdf",
-					"type":           "docx",
-					"file_size":      3,
-				},
-			},
-		},
-	})
-	reg.Register(&httpmock.Stub{
-		Method:  "GET",
-		URL:     "/open-apis/drive/v1/export_tasks/file/box_wiki/download",
-		Status:  200,
-		RawBody: []byte("pdf"),
-		Headers: http.Header{
-			"Content-Type":        []string{"application/pdf"},
-			"Content-Disposition": []string{`attachment; filename="wiki-report.pdf"`},
-		},
-	})
-
-	tmpDir := t.TempDir()
-	withDriveWorkingDir(t, tmpDir)
-
-	prevAttempts, prevInterval := driveExportPollAttempts, driveExportPollInterval
-	driveExportPollAttempts, driveExportPollInterval = 1, 0
-	t.Cleanup(func() {
-		driveExportPollAttempts, driveExportPollInterval = prevAttempts, prevInterval
-	})
-
-	err := mountAndRunDrive(t, DriveExport, []string{
-		"+export",
-		"--url", "https://example.feishu.cn/wiki/wikiNode123",
-		"--file-extension", "pdf",
-		"--as", "bot",
-	}, f, stdout)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	var createBody map[string]interface{}
-	if err := json.Unmarshal(createStub.CapturedBody, &createBody); err != nil {
-		t.Fatalf("unmarshal export_tasks body: %v", err)
-	}
-	if createBody["token"] != "docxResolved" {
-		t.Fatalf("export_tasks body token = %v, want resolved docx token", createBody["token"])
-	}
-	if createBody["type"] != "docx" {
-		t.Fatalf("export_tasks body type = %v, want docx", createBody["type"])
-	}
-	if !strings.Contains(stdout.String(), `"wiki_token": "wikiNode123"`) {
-		t.Fatalf("stdout missing wiki token context: %s", stdout.String())
-	}
-}
-
-func TestDriveExportBareWikiTypeResolvesBeforeAsyncTask(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,
-			"data": map[string]interface{}{
-				"node": map[string]interface{}{
-					"obj_type":  "docx",
-					"obj_token": "docxResolved",
-				},
-			},
-		},
-	})
-	createStub := &httpmock.Stub{
-		Method: "POST",
-		URL:    "/open-apis/drive/v1/export_tasks",
-		Body: map[string]interface{}{
-			"code": 0,
-			"data": map[string]interface{}{"ticket": "tk_wiki_token"},
-		},
-	}
-	reg.Register(createStub)
-	reg.Register(&httpmock.Stub{
-		Method: "GET",
-		URL:    "/open-apis/drive/v1/export_tasks/tk_wiki_token",
-		Body: map[string]interface{}{
-			"code": 0,
-			"data": map[string]interface{}{
-				"result": map[string]interface{}{
-					"job_status":     0,
-					"file_token":     "box_wiki_token",
-					"file_name":      "wiki-token-report",
-					"file_extension": "pdf",
-					"type":           "docx",
-					"file_size":      3,
-				},
-			},
-		},
-	})
-	reg.Register(&httpmock.Stub{
-		Method:  "GET",
-		URL:     "/open-apis/drive/v1/export_tasks/file/box_wiki_token/download",
-		Status:  200,
-		RawBody: []byte("pdf"),
-		Headers: http.Header{
-			"Content-Type":        []string{"application/pdf"},
-			"Content-Disposition": []string{`attachment; filename="wiki-token-report.pdf"`},
-		},
-	})
-
-	tmpDir := t.TempDir()
-	withDriveWorkingDir(t, tmpDir)
-
-	prevAttempts, prevInterval := driveExportPollAttempts, driveExportPollInterval
-	driveExportPollAttempts, driveExportPollInterval = 1, 0
-	t.Cleanup(func() {
-		driveExportPollAttempts, driveExportPollInterval = prevAttempts, prevInterval
-	})
-
-	err := mountAndRunDrive(t, DriveExport, []string{
-		"+export",
-		"--token", "wikiNodeBare",
-		"--doc-type", "wiki",
-		"--file-extension", "pdf",
-		"--as", "bot",
-	}, f, stdout)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	var createBody map[string]interface{}
-	if err := json.Unmarshal(createStub.CapturedBody, &createBody); err != nil {
-		t.Fatalf("unmarshal export_tasks body: %v", err)
-	}
-	if createBody["token"] != "docxResolved" {
-		t.Fatalf("export_tasks body token = %v, want resolved docx token", createBody["token"])
-	}
-	if createBody["type"] != "docx" {
-		t.Fatalf("export_tasks body type = %v, want resolved docx type", createBody["type"])
-	}
-	if !strings.Contains(stdout.String(), `"wiki_token": "wikiNodeBare"`) {
-		t.Fatalf("stdout missing wiki token context: %s", stdout.String())
-	}
-}
-
-func TestDriveExportBareWikiTokenFileTokenInvalidDoesNotFallback(t *testing.T) {
-	f, stdout, stderr, reg := cmdutil.TestFactory(t, driveTestConfig())
-	firstCreate := &httpmock.Stub{
-		Method: "POST",
-		URL:    "/open-apis/drive/v1/export_tasks",
-		Status: 404,
-		Body: map[string]interface{}{
-			"code":   1069914,
-			"msg":    "file token invalid",
-			"log_id": "20260708000000TEST",
-		},
-		BodyFilter: func(body []byte) bool {
-			return strings.Contains(string(body), `"token":"wikiNodeBare"`)
-		},
-	}
-	reg.Register(firstCreate)
-
-	tmpDir := t.TempDir()
-	withDriveWorkingDir(t, tmpDir)
-
-	prevAttempts, prevInterval := driveExportPollAttempts, driveExportPollInterval
-	driveExportPollAttempts, driveExportPollInterval = 1, 0
-	t.Cleanup(func() {
-		driveExportPollAttempts, driveExportPollInterval = prevAttempts, prevInterval
-	})
-
-	err := mountAndRunDrive(t, DriveExport, []string{
-		"+export",
-		"--token", "wikiNodeBare",
-		"--doc-type", "docx",
-		"--file-extension", "pdf",
-		"--as", "bot",
-	}, f, stdout)
-	if err == nil {
-		t.Fatal("expected file token invalid error, got nil")
-	}
-
-	if len(firstCreate.CapturedBody) == 0 {
-		t.Fatal("first export task request was not sent with the original token")
-	}
-	problem, ok := errs.ProblemOf(err)
-	if !ok {
-		t.Fatalf("expected typed API error, got %T: %v", err, err)
-	}
-	if problem.Code != 1069914 {
-		t.Fatalf("error code = %d, want 1069914", problem.Code)
-	}
-	if strings.Contains(stderr.String(), "Resolving wiki node for export") {
-		t.Fatalf("stderr unexpectedly contains wiki resolution log: %s", stderr.String())
-	}
-}
-
-func TestDriveExportWikiResolvedTypeMismatch(t *testing.T) {
-	f, _, _, 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,
-			"data": map[string]interface{}{
-				"node": map[string]interface{}{
-					"obj_type":  "sheet",
-					"obj_token": "shtResolved",
-				},
-			},
-		},
-	})
-
-	err := mountAndRunDrive(t, DriveExport, []string{
-		"+export",
-		"--token", "https://example.feishu.cn/wiki/wikiSheet123",
-		"--doc-type", "docx",
-		"--file-extension", "pdf",
-		"--as", "bot",
-	}, f, nil)
-	if err == nil {
-		t.Fatal("expected type mismatch error, got nil")
-	}
-	var valErr *errs.ValidationError
-	if !errors.As(err, &valErr) {
-		t.Fatalf("expected *errs.ValidationError, got %T", err)
-	}
-	if !strings.Contains(valErr.Message, `wiki resolved to "sheet"`) {
-		t.Fatalf("error message = %q, want resolved type", valErr.Message)
-	}
-}
-
 // TestDriveExportEmptyOutputDirDownloadsToCwd guards the export refactor: an
 // explicit empty --output-dir must still download to the current directory
 // (normalized to "."), not trigger the export-only no-download path that the

shortcuts/drive/drive_import.go

@@ -54,21 +54,15 @@ type ImportParams struct {
 	FolderToken string
 	Name        string
 	TargetToken string
-	// FileExtension optionally overrides the extension inferred from File's
-	// name. Leave empty to infer from File (the default). Callers that have
-	// sniffed the file's real container use this to correct a mislabeled name
-	// so the backend receives the true format.
-	FileExtension string
 }
 
 func (p ImportParams) spec() driveImportSpec {
 	return driveImportSpec{
-		FilePath:     p.File,
-		DocType:      strings.ToLower(p.DocType),
-		FolderToken:  p.FolderToken,
-		Name:         p.Name,
-		TargetToken:  p.TargetToken,
-		EffectiveExt: strings.TrimPrefix(strings.ToLower(p.FileExtension), "."),
+		FilePath:    p.File,
+		DocType:     strings.ToLower(p.DocType),
+		FolderToken: p.FolderToken,
+		Name:        p.Name,
+		TargetToken: p.TargetToken,
 	}
 }
 
@@ -133,7 +127,7 @@ func RunImport(ctx context.Context, runtime *common.RuntimeContext, p ImportPara
 	}
 
 	// Step 1: Upload file as media
-	fileToken, uploadErr := uploadMediaForImport(ctx, runtime, spec)
+	fileToken, uploadErr := uploadMediaForImport(ctx, runtime, spec.FilePath, spec.SourceFileName(), spec.DocType)
 	if uploadErr != nil {
 		return uploadErr
 	}
@@ -209,14 +203,14 @@ func preflightDriveImportFile(fio fileio.FileIO, spec *driveImportSpec) (int64,
 	if !info.Mode().IsRegular() {
 		return 0, errs.NewValidationError(errs.SubtypeInvalidArgument, "file must be a regular file: %s", spec.FilePath).WithParam("--file")
 	}
-	if err = validateDriveImportFileSize(spec.FileExtension(), spec.DocType, info.Size()); err != nil {
+	if err = validateDriveImportFileSize(spec.FilePath, spec.DocType, info.Size()); err != nil {
 		return 0, err
 	}
 	return info.Size(), nil
 }
 
 func appendDriveImportUploadDryRun(dry *common.DryRunAPI, spec driveImportSpec, fileSize int64) {
-	extra, err := buildImportMediaExtra(spec.FileExtension(), spec.DocType)
+	extra, err := buildImportMediaExtra(spec.FilePath, spec.DocType)
 	if err != nil {
 		extra = fmt.Sprintf(`{"obj_type":"%s","file_extension":"%s"}`, spec.DocType, spec.FileExtension())
 	}

shortcuts/drive/drive_import_common.go

@@ -59,39 +59,14 @@ type driveImportSpec struct {
 	FolderToken string
 	Name        string
 	TargetToken string // existing bitable token to import data into (only for type=bitable)
-
-	// EffectiveExt is a caller-supplied override for the extension otherwise
-	// derived from FilePath (see ImportParams.FileExtension). It lets a caller
-	// that has detected the file's real container correct a mislabeled name
-	// (e.g. an OOXML workbook saved as .xls). Empty means "trust the filename".
-	EffectiveExt string
 }
 
-// rawExtension is the lowercased extension taken verbatim from the file name.
-func (s driveImportSpec) rawExtension() string {
+func (s driveImportSpec) FileExtension() string {
 	return strings.TrimPrefix(strings.ToLower(filepath.Ext(s.FilePath)), ".")
 }
 
-// FileExtension is the extension the import pipeline treats as authoritative:
-// the content-sniffed override when set, otherwise the file name's extension.
-func (s driveImportSpec) FileExtension() string {
-	if s.EffectiveExt != "" {
-		return s.EffectiveExt
-	}
-	return s.rawExtension()
-}
-
-// SourceFileName is the name used when staging the upload media. When content
-// sniffing corrected the extension, the staged name must carry the corrected
-// suffix too: the import backend cross-checks the media file name's extension
-// against the file_extension in the import task and rejects a mismatch with
-// "import file extension not match" (code 1069910).
 func (s driveImportSpec) SourceFileName() string {
-	base := filepath.Base(s.FilePath)
-	if s.EffectiveExt != "" && s.EffectiveExt != s.rawExtension() {
-		base = strings.TrimSuffix(base, filepath.Ext(base)) + "." + s.EffectiveExt
-	}
-	return base
+	return filepath.Base(s.FilePath)
 }
 
 func (s driveImportSpec) TargetFileName() string {
@@ -122,20 +97,18 @@ func (s driveImportSpec) CreateTaskBody(fileToken string) map[string]interface{}
 
 // uploadMediaForImport uploads the source file to the temporary import media
 // endpoint and returns the file token consumed by import_tasks.
-func uploadMediaForImport(ctx context.Context, runtime *common.RuntimeContext, spec driveImportSpec) (string, error) {
-	filePath := spec.FilePath
-	fileName := spec.SourceFileName()
+func uploadMediaForImport(ctx context.Context, runtime *common.RuntimeContext, filePath, fileName, docType string) (string, error) {
 	importInfo, err := runtime.FileIO().Stat(filePath)
 	if err != nil {
 		return "", driveInputStatError(err)
 	}
 
 	fileSize := importInfo.Size()
-	if err = validateDriveImportFileSize(spec.FileExtension(), spec.DocType, fileSize); err != nil {
+	if err = validateDriveImportFileSize(filePath, docType, fileSize); err != nil {
 		return "", err
 	}
 
-	extra, err := buildImportMediaExtra(spec.FileExtension(), spec.DocType)
+	extra, err := buildImportMediaExtra(filePath, docType)
 	if err != nil {
 		return "", err
 	}
@@ -166,12 +139,12 @@ func uploadMediaForImport(ctx context.Context, runtime *common.RuntimeContext, s
 	})
 }
 
-func buildImportMediaExtra(ext, docType string) (string, error) {
+func buildImportMediaExtra(filePath, docType string) (string, error) {
 	// The import media endpoint uses extra to decide both the target native type
 	// and how to interpret the uploaded source file.
 	extraBytes, err := json.Marshal(map[string]string{
 		"obj_type":       docType,
-		"file_extension": ext,
+		"file_extension": strings.TrimPrefix(strings.ToLower(filepath.Ext(filePath)), "."),
 	})
 	if err != nil {
 		return "", errs.NewInternalError(errs.SubtypeUnknown, "build upload extra failed: %v", err).WithCause(err)
@@ -179,10 +152,10 @@ func buildImportMediaExtra(ext, docType string) (string, error) {
 	return string(extraBytes), nil
 }
 
-func driveImportFileSizeLimit(ext, docType string) (int64, bool) {
+func driveImportFileSizeLimit(filePath, docType string) (int64, bool) {
 	// Keep the limit mapping local to import flows so we do not widen behavior
 	// changes beyond drive +import.
-	switch ext {
+	switch strings.TrimPrefix(strings.ToLower(filepath.Ext(filePath)), ".") {
 	case "docx", "doc":
 		return driveImport600MBFileSizeLimit, true
 	case "pptx":
@@ -201,12 +174,13 @@ func driveImportFileSizeLimit(ext, docType string) (int64, bool) {
 	}
 }
 
-func validateDriveImportFileSize(ext, docType string, fileSize int64) error {
-	limit, ok := driveImportFileSizeLimit(ext, docType)
+func validateDriveImportFileSize(filePath, docType string, fileSize int64) error {
+	limit, ok := driveImportFileSizeLimit(filePath, docType)
 	if !ok || fileSize <= limit {
 		return nil
 	}
 
+	ext := strings.TrimPrefix(strings.ToLower(filepath.Ext(filePath)), ".")
 	if ext == "csv" {
 		// CSV is the only source format whose limit depends on the target type.
 		return errs.NewValidationError(errs.SubtypeInvalidArgument,

shortcuts/drive/drive_import_common_test.go

@@ -94,61 +94,61 @@ func TestValidateDriveImportFileSize(t *testing.T) {
 
 	tests := []struct {
 		name     string
-		ext      string
+		filePath string
 		docType  string
 		fileSize int64
 		wantText string
 	}{
 		{
 			name:     "docx exceeds 600mb limit",
-			ext:      "docx",
+			filePath: "./report.docx",
 			docType:  "docx",
 			fileSize: driveImport600MBFileSizeLimit + 1,
 			wantText: "exceeds 600.0 MB import limit for .docx",
 		},
 		{
 			name:     "csv sheet exceeds 20mb limit",
-			ext:      "csv",
+			filePath: "./data.csv",
 			docType:  "sheet",
 			fileSize: driveImport20MBFileSizeLimit + 1,
 			wantText: "exceeds 20.0 MB import limit for .csv when importing as sheet",
 		},
 		{
 			name:     "csv bitable exceeds 100mb limit",
-			ext:      "csv",
+			filePath: "./data.csv",
 			docType:  "bitable",
 			fileSize: driveImport100MBFileSizeLimit + 1,
 			wantText: "exceeds 100.0 MB import limit for .csv when importing as bitable",
 		},
 		{
 			name:     "xlsx within 800mb limit",
-			ext:      "xlsx",
+			filePath: "./data.xlsx",
 			docType:  "sheet",
 			fileSize: driveImport800MBFileSizeLimit,
 		},
 		{
 			name:     "pptx exceeds 500mb limit",
-			ext:      "pptx",
+			filePath: "./deck.pptx",
 			docType:  "slides",
 			fileSize: driveImport500MBFileSizeLimit + 1,
 			wantText: "exceeds 500.0 MB import limit for .pptx",
 		},
 		{
 			name:     "pptx within 500mb limit",
-			ext:      "pptx",
+			filePath: "./deck.pptx",
 			docType:  "slides",
 			fileSize: driveImport500MBFileSizeLimit,
 		},
 		{
 			name:     "base exceeds 20mb limit",
-			ext:      "base",
+			filePath: "./snapshot.base",
 			docType:  "bitable",
 			fileSize: driveImport20MBFileSizeLimit + 1,
 			wantText: "exceeds 20.0 MB import limit for .base",
 		},
 		{
 			name:     "base within 20mb limit",
-			ext:      "base",
+			filePath: "./snapshot.base",
 			docType:  "bitable",
 			fileSize: driveImport20MBFileSizeLimit,
 		},
@@ -158,7 +158,7 @@ func TestValidateDriveImportFileSize(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
 
-			err := validateDriveImportFileSize(tt.ext, tt.docType, tt.fileSize)
+			err := validateDriveImportFileSize(tt.filePath, tt.docType, tt.fileSize)
 			if tt.wantText == "" {
 				if err != nil {
 					t.Fatalf("expected no error, got %v", err)

shortcuts/drive/drive_list_comments.go

@@ -1,328 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package drive
-
-import (
-	"context"
-	"fmt"
-	"strings"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/internal/validate"
-	"github.com/larksuite/cli/shortcuts/common"
-)
-
-const (
-	driveListCommentsDefaultPageSize     = 50
-	driveListCommentsDefaultSolvedStatus = "false"
-	driveListCommentsDefaultScope        = "all"
-)
-
-var driveListCommentsTypes = []string{"doc", "docx", "sheet", "file", "slides", "bitable", "base", "wiki"}
-
-type driveListCommentsRef struct {
-	Token      string
-	Type       string
-	SourceFlag string
-}
-
-type driveListCommentsTarget struct {
-	FileToken string
-	FileType  string
-}
-
-type driveListCommentsSpec struct {
-	Ref          driveListCommentsRef
-	PageSize     int
-	PageToken    string
-	SolvedStatus string
-	CommentScope string
-	NeedReaction bool
-	NeedRelation bool
-}
-
-// DriveListComments lists document comments through the Drive comments API,
-// 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), 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/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"}},
-		{Name: "comment-scope", Default: driveListCommentsDefaultScope, Desc: "comment scope filter: all=all comments, whole=full-document comments, partial=local/selection comments", Enum: []string{"all", "whole", "partial"}},
-		{Name: "need-reaction", Type: "bool", Desc: "include reaction data on comment cards"},
-		{Name: "need-relation", Type: "bool", Desc: "include docx comment relation data; ignored for non-docx targets"},
-		{Name: "page-size", Type: "int", Default: "50", Desc: "page size, 1-100"},
-		{Name: "page-token", Desc: "pagination token from previous response"},
-	},
-	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		spec, err := readDriveListCommentsSpec(runtime)
-		if err != nil {
-			return err
-		}
-		return validateDriveListCommentsSpec(spec)
-	},
-	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
-		spec, err := readDriveListCommentsSpec(runtime)
-		if err != nil {
-			return common.NewDryRunAPI().Set("error", err.Error())
-		}
-		if err := validateDriveListCommentsSpec(spec); err != nil {
-			return common.NewDryRunAPI().Set("error", err.Error())
-		}
-		return buildDriveListCommentsDryRun(spec)
-	},
-	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
-		spec, err := readDriveListCommentsSpec(runtime)
-		if err != nil {
-			return err
-		}
-		if err := validateDriveListCommentsSpec(spec); err != nil {
-			return err
-		}
-
-		target, err := resolveDriveListCommentsTarget(ctx, runtime, spec.Ref)
-		if err != nil {
-			return err
-		}
-		params := buildDriveListCommentsParams(spec, target.FileType)
-		path := fmt.Sprintf("/open-apis/drive/v1/files/%s/comments", validate.EncodePathSegment(target.FileToken))
-
-		data, err := runtime.CallAPITyped("GET", path, params, nil)
-		if err != nil {
-			return err
-		}
-		runtime.Out(buildDriveListCommentsOutput(target, data), nil)
-		return nil
-	},
-}
-
-func readDriveListCommentsSpec(runtime *common.RuntimeContext) (driveListCommentsSpec, error) {
-	ref, err := resolveDriveListCommentsInput(runtime.Str("url"), runtime.Str("token"), runtime.Str("type"))
-	if err != nil {
-		return driveListCommentsSpec{}, err
-	}
-	return driveListCommentsSpec{
-		Ref:          ref,
-		PageSize:     runtime.Int("page-size"),
-		PageToken:    strings.TrimSpace(runtime.Str("page-token")),
-		SolvedStatus: strings.TrimSpace(runtime.Str("solved-status")),
-		CommentScope: strings.TrimSpace(runtime.Str("comment-scope")),
-		NeedReaction: runtime.Bool("need-reaction"),
-		NeedRelation: runtime.Bool("need-relation"),
-	}, nil
-}
-
-func validateDriveListCommentsSpec(spec driveListCommentsSpec) error {
-	if spec.PageSize < 1 || spec.PageSize > 100 {
-		return errs.NewValidationError(errs.SubtypeInvalidArgument, "--page-size must be between 1 and 100").WithParam("--page-size")
-	}
-	if _, ok := driveListCommentsSolvedStatusParam(spec.SolvedStatus); !ok {
-		return errs.NewValidationError(errs.SubtypeInvalidArgument, "invalid --solved-status %q; allowed: false, true, all", spec.SolvedStatus).WithParam("--solved-status")
-	}
-	if _, ok := driveListCommentsScopeParam(spec.CommentScope); !ok {
-		return errs.NewValidationError(errs.SubtypeInvalidArgument, "invalid --comment-scope %q; allowed: all, whole, partial", spec.CommentScope).WithParam("--comment-scope")
-	}
-	return nil
-}
-
-func resolveDriveListCommentsInput(urlInput, tokenInput, explicitType string) (driveListCommentsRef, error) {
-	urlInput = strings.TrimSpace(urlInput)
-	tokenInput = strings.TrimSpace(tokenInput)
-	if urlInput != "" && tokenInput != "" {
-		return driveListCommentsRef{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "--url and --token are mutually exclusive; pass one input only").WithParam("--url")
-	}
-	if urlInput == "" && tokenInput == "" {
-		return driveListCommentsRef{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "specify --url or --token").WithParam("--url")
-	}
-
-	raw := urlInput
-	sourceFlag := "--url"
-	if raw == "" {
-		raw = tokenInput
-		sourceFlag = "--token"
-	}
-	inputType := normalizeDriveListCommentsType(strings.ToLower(strings.TrimSpace(explicitType)))
-
-	if ref, ok := common.ParseResourceURL(raw); ok {
-		refType := normalizeDriveListCommentsType(ref.Type)
-		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")
-		}
-		if !driveListCommentsTypeSupported(refType) {
-			return driveListCommentsRef{}, errs.NewValidationError(
-				errs.SubtypeInvalidArgument,
-				"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 strings.Contains(raw, "://") {
-		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, wiki)", sourceFlag).WithParam("--type")
-	}
-	if !driveListCommentsTypeSupported(inputType) {
-		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 normalizeDriveListCommentsType(docType string) string {
-	switch strings.TrimSpace(docType) {
-	case "base":
-		return "bitable"
-	default:
-		return strings.TrimSpace(docType)
-	}
-}
-
-func driveListCommentsTypeSupported(docType string) bool {
-	switch normalizeDriveListCommentsType(docType) {
-	case "doc", "docx", "sheet", "file", "slides", "bitable", "wiki":
-		return true
-	default:
-		return false
-	}
-}
-
-func resolveDriveListCommentsTarget(ctx context.Context, runtime *common.RuntimeContext, ref driveListCommentsRef) (driveListCommentsTarget, error) {
-	if ref.Type != "wiki" {
-		return driveListCommentsTarget{FileToken: ref.Token, FileType: ref.Type}, nil
-	}
-
-	fmt.Fprintf(runtime.IO().ErrOut, "Resolving wiki node: %s\n", common.MaskToken(ref.Token))
-	data, err := runtime.CallAPITyped(
-		"GET",
-		"/open-apis/wiki/v2/spaces/get_node",
-		map[string]interface{}{"token": ref.Token},
-		nil,
-	)
-	if err != nil {
-		return driveListCommentsTarget{}, err
-	}
-
-	node := common.GetMap(data, "node")
-	objType := normalizeDriveListCommentsType(common.GetString(node, "obj_type"))
-	objToken := common.GetString(node, "obj_token")
-	if objType == "" || objToken == "" {
-		return driveListCommentsTarget{}, errs.NewInternalError(errs.SubtypeInvalidResponse, "wiki get_node returned incomplete node data")
-	}
-	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, and bitable",
-			objType,
-		).WithParam(ref.SourceFlag)
-	}
-	fmt.Fprintf(runtime.IO().ErrOut, "Resolved wiki to %s: %s\n", objType, common.MaskToken(objToken))
-	return driveListCommentsTarget{FileToken: objToken, FileType: objType}, nil
-}
-
-func buildDriveListCommentsDryRun(spec driveListCommentsSpec) *common.DryRunAPI {
-	if spec.Ref.Type == "wiki" {
-		params := buildDriveListCommentsParams(spec, "<obj_type from step 1>")
-		if spec.NeedRelation {
-			params["need_relation"] = "<sent only when obj_type is docx>"
-		}
-		return common.NewDryRunAPI().
-			Desc("2-step orchestration: resolve wiki -> list comments").
-			GET("/open-apis/wiki/v2/spaces/get_node").
-			Desc("[1] Resolve wiki node to underlying document").
-			Params(map[string]interface{}{"token": spec.Ref.Token}).
-			GET("/open-apis/drive/v1/files/<obj_token from step 1>/comments").
-			Desc("[2] List comments on resolved document").
-			Params(params)
-	}
-
-	return common.NewDryRunAPI().
-		Desc("1-step request: list comments").
-		GET("/open-apis/drive/v1/files/:file_token/comments").
-		Params(buildDriveListCommentsParams(spec, spec.Ref.Type)).
-		Set("file_token", spec.Ref.Token)
-}
-
-func buildDriveListCommentsParams(spec driveListCommentsSpec, fileType string) map[string]interface{} {
-	params := map[string]interface{}{
-		"file_type": fileType,
-		"page_size": spec.PageSize,
-	}
-	if spec.PageToken != "" {
-		params["page_token"] = spec.PageToken
-	}
-	if value, ok := driveListCommentsSolvedStatusParam(spec.SolvedStatus); ok && value != nil {
-		params["is_solved"] = *value
-	}
-	if value, ok := driveListCommentsScopeParam(spec.CommentScope); ok && value != nil {
-		params["is_whole"] = *value
-	}
-	if spec.NeedReaction {
-		params["need_reaction"] = true
-	}
-	if spec.NeedRelation && fileType == "docx" {
-		params["need_relation"] = true
-	}
-	return params
-}
-
-func driveListCommentsSolvedStatusParam(status string) (*bool, bool) {
-	switch strings.TrimSpace(status) {
-	case "false", "":
-		value := false
-		return &value, true
-	case "true":
-		value := true
-		return &value, true
-	case "all":
-		return nil, true
-	default:
-		return nil, false
-	}
-}
-
-func driveListCommentsScopeParam(scope string) (*bool, bool) {
-	switch strings.TrimSpace(scope) {
-	case "all", "":
-		return nil, true
-	case "whole":
-		value := true
-		return &value, true
-	case "partial":
-		value := false
-		return &value, true
-	default:
-		return nil, false
-	}
-}
-
-func buildDriveListCommentsOutput(target driveListCommentsTarget, data map[string]interface{}) map[string]interface{} {
-	items := common.GetSlice(data, "items")
-	return map[string]interface{}{
-		"file_token": target.FileToken,
-		"file_type":  target.FileType,
-		"items":      items,
-		"has_more":   common.GetBool(data, "has_more"),
-		"page_token": common.GetString(data, "page_token"),
-		"count":      len(items),
-	}
-}

shortcuts/drive/drive_list_comments_test.go

@@ -1,355 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package drive
-
-import (
-	"errors"
-	"net/http"
-	"strings"
-	"testing"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/internal/cmdutil"
-	"github.com/larksuite/cli/internal/httpmock"
-)
-
-func TestResolveDriveListCommentsInput(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name         string
-		urlInput     string
-		rawInput     string
-		docType      string
-		wantResource string
-		wantType     string
-		wantErr      string
-		wantParam    string
-	}{
-		{
-			name:         "url docx",
-			urlInput:     "https://example.larksuite.com/docx/docxResource?from=wiki",
-			wantResource: "docxResource",
-			wantType:     "docx",
-		},
-		{
-			name:         "token flag also accepts url",
-			rawInput:     "https://example.larksuite.com/base/bitableResource",
-			wantResource: "bitableResource",
-			wantType:     "bitable",
-		},
-		{
-			name:         "bare wiki token",
-			rawInput:     "wikiResource",
-			docType:      "wiki",
-			wantResource: "wikiResource",
-			wantType:     "wiki",
-		},
-		{
-			name:      "url and token mutually exclusive",
-			urlInput:  "https://example.larksuite.com/docx/docxResource",
-			rawInput:  "docxResource",
-			wantErr:   "mutually exclusive",
-			wantParam: "--url",
-		},
-		{
-			name:      "bare token needs type",
-			rawInput:  "docxResource",
-			wantErr:   "--type is required",
-			wantParam: "--type",
-		},
-		{
-			name:      "type conflicts with url",
-			urlInput:  "https://example.larksuite.com/wiki/wikiResource",
-			docType:   "docx",
-			wantErr:   "conflicts",
-			wantParam: "--type",
-		},
-		{
-			name:      "unsupported url type",
-			urlInput:  "https://example.larksuite.com/drive/folder/folderResource",
-			wantErr:   "unsupported",
-			wantParam: "--url",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-
-			got, err := resolveDriveListCommentsInput(tt.urlInput, tt.rawInput, tt.docType)
-			if tt.wantErr != "" {
-				if err == nil || !strings.Contains(err.Error(), tt.wantErr) {
-					t.Fatalf("expected error containing %q, got %v", tt.wantErr, err)
-				}
-				assertDriveListCommentsValidationError(t, err, tt.wantParam)
-				return
-			}
-			if err != nil {
-				t.Fatalf("unexpected error: %v", err)
-			}
-			if got.Token != tt.wantResource || got.Type != tt.wantType {
-				t.Fatalf("got (%q, %q), want (%q, %q)", got.Token, got.Type, tt.wantResource, tt.wantType)
-			}
-		})
-	}
-}
-
-func TestValidateDriveListCommentsSpec(t *testing.T) {
-	t.Parallel()
-
-	valid := driveListCommentsSpec{
-		PageSize:     50,
-		SolvedStatus: "false",
-		CommentScope: "all",
-	}
-
-	tests := []struct {
-		name      string
-		mutate    func(*driveListCommentsSpec)
-		wantParam string
-	}{
-		{
-			name: "invalid page size",
-			mutate: func(spec *driveListCommentsSpec) {
-				spec.PageSize = 0
-			},
-			wantParam: "--page-size",
-		},
-		{
-			name: "invalid solved status",
-			mutate: func(spec *driveListCommentsSpec) {
-				spec.SolvedStatus = "open"
-			},
-			wantParam: "--solved-status",
-		},
-		{
-			name: "invalid comment scope",
-			mutate: func(spec *driveListCommentsSpec) {
-				spec.CommentScope = "inline"
-			},
-			wantParam: "--comment-scope",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-
-			spec := valid
-			tt.mutate(&spec)
-			err := validateDriveListCommentsSpec(spec)
-			if err == nil {
-				t.Fatal("expected validation error, got nil")
-			}
-			assertDriveListCommentsValidationError(t, err, tt.wantParam)
-		})
-	}
-}
-
-func assertDriveListCommentsValidationError(t *testing.T, err error, wantParam string) {
-	t.Helper()
-
-	var validationErr *errs.ValidationError
-	if !errors.As(err, &validationErr) {
-		t.Fatalf("expected *errs.ValidationError, got %T: %v", err, err)
-	}
-	if validationErr.Category != errs.CategoryValidation {
-		t.Fatalf("category = %q, want %q", validationErr.Category, errs.CategoryValidation)
-	}
-	if validationErr.Subtype != errs.SubtypeInvalidArgument {
-		t.Fatalf("subtype = %q, want %q", validationErr.Subtype, errs.SubtypeInvalidArgument)
-	}
-	if validationErr.Param != wantParam {
-		t.Fatalf("param = %q, want %q", validationErr.Param, wantParam)
-	}
-	if cause := errors.Unwrap(err); cause != nil {
-		t.Fatalf("unexpected cause on direct validation error: %v", cause)
-	}
-
-	problem, ok := errs.ProblemOf(err)
-	if !ok {
-		t.Fatalf("expected errs.ProblemOf to recognize typed error: %v", err)
-	}
-	if problem.Category != errs.CategoryValidation {
-		t.Fatalf("problem category = %q, want %q", problem.Category, errs.CategoryValidation)
-	}
-	if problem.Subtype != errs.SubtypeInvalidArgument {
-		t.Fatalf("problem subtype = %q, want %q", problem.Subtype, errs.SubtypeInvalidArgument)
-	}
-}
-
-func TestBuildDriveListCommentsParams(t *testing.T) {
-	t.Parallel()
-
-	defaultSpec := driveListCommentsSpec{
-		PageSize:     50,
-		SolvedStatus: "false",
-		CommentScope: "all",
-	}
-	defaultParams := buildDriveListCommentsParams(defaultSpec, "docx")
-	if got := defaultParams["is_solved"]; got != false {
-		t.Fatalf("default is_solved = %#v, want false", got)
-	}
-	if _, ok := defaultParams["is_whole"]; ok {
-		t.Fatalf("default params should omit is_whole: %#v", defaultParams)
-	}
-	if _, ok := defaultParams["user_id_type"]; ok {
-		t.Fatalf("default params should omit user_id_type: %#v", defaultParams)
-	}
-
-	allPartialSpec := driveListCommentsSpec{
-		PageSize:     100,
-		PageToken:    "next",
-		SolvedStatus: "all",
-		CommentScope: "partial",
-		NeedReaction: true,
-		NeedRelation: true,
-	}
-	allPartialParams := buildDriveListCommentsParams(allPartialSpec, "docx")
-	if _, ok := allPartialParams["is_solved"]; ok {
-		t.Fatalf("solved-status all should omit is_solved: %#v", allPartialParams)
-	}
-	if got := allPartialParams["is_whole"]; got != false {
-		t.Fatalf("comment-scope partial is_whole = %#v, want false", got)
-	}
-	if got := allPartialParams["need_reaction"]; got != true {
-		t.Fatalf("need_reaction = %#v, want true", got)
-	}
-	if got := allPartialParams["need_relation"]; got != true {
-		t.Fatalf("need_relation = %#v, want true for docx", got)
-	}
-	if got := allPartialParams["page_token"]; got != "next" {
-		t.Fatalf("page_token = %#v, want next", got)
-	}
-
-	sheetParams := buildDriveListCommentsParams(allPartialSpec, "sheet")
-	if _, ok := sheetParams["need_relation"]; ok {
-		t.Fatalf("need_relation should be ignored for non-docx: %#v", sheetParams)
-	}
-}
-
-func TestDriveListCommentsExecuteDocx(t *testing.T) {
-	f, stdout, _, reg := cmdutil.TestFactory(t, driveTestConfig())
-	reg.Register(&httpmock.Stub{
-		Method: "GET",
-		URL:    "/open-apis/drive/v1/files/docxResource/comments",
-		OnMatch: func(req *http.Request) {
-			query := req.URL.Query()
-			if got := query.Get("file_type"); got != "docx" {
-				t.Errorf("file_type = %q, want docx", got)
-			}
-			if got := query.Get("is_solved"); got != "false" {
-				t.Errorf("is_solved = %q, want false", got)
-			}
-			if got := query.Get("is_whole"); got != "" {
-				t.Errorf("is_whole = %q, want omitted", got)
-			}
-			if got := query.Get("user_id_type"); got != "" {
-				t.Errorf("user_id_type = %q, want omitted", got)
-			}
-		},
-		Body: map[string]interface{}{
-			"code": 0,
-			"msg":  "success",
-			"data": map[string]interface{}{
-				"items": []map[string]interface{}{
-					{"comment_id": "comment_1", "is_solved": false},
-				},
-				"has_more":   true,
-				"page_token": "next",
-			},
-		},
-	})
-
-	err := mountAndRunDrive(t, DriveListComments, []string{
-		"+list-comments",
-		"--url", "https://example.larksuite.com/docx/docxResource",
-		"--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 != "docxResource" {
-		t.Fatalf("file_token = %q, want docxResource", got)
-	}
-	if got := mustStringField(t, data, "file_type", "data.file_type"); got != "docx" {
-		t.Fatalf("file_type = %q, want docx", got)
-	}
-	if got := data["count"]; got != float64(1) {
-		t.Fatalf("count = %#v, want 1", got)
-	}
-}
-
-func TestDriveListCommentsExecuteWikiResolvesToDocx(t *testing.T) {
-	f, stdout, _, reg := cmdutil.TestFactory(t, driveTestConfig())
-	reg.Register(&httpmock.Stub{
-		Method: "GET",
-		URL:    "/open-apis/wiki/v2/spaces/get_node",
-		OnMatch: func(req *http.Request) {
-			if got := req.URL.Query().Get("token"); got != "wikiResource" {
-				t.Errorf("wiki token = %q, want wikiResource", got)
-			}
-		},
-		Body: map[string]interface{}{
-			"code": 0,
-			"msg":  "success",
-			"data": map[string]interface{}{
-				"node": map[string]interface{}{
-					"obj_type":  "docx",
-					"obj_token": "docxFromWikiResource",
-				},
-			},
-		},
-	})
-	reg.Register(&httpmock.Stub{
-		Method: "GET",
-		URL:    "/open-apis/drive/v1/files/docxFromWikiResource/comments",
-		OnMatch: func(req *http.Request) {
-			query := req.URL.Query()
-			if got := query.Get("is_solved"); got != "" {
-				t.Errorf("is_solved = %q, want omitted for solved-status all", got)
-			}
-			if got := query.Get("is_whole"); got != "true" {
-				t.Errorf("is_whole = %q, want true", got)
-			}
-			if got := query.Get("need_relation"); got != "true" {
-				t.Errorf("need_relation = %q, want true for resolved docx", got)
-			}
-		},
-		Body: map[string]interface{}{
-			"code": 0,
-			"msg":  "success",
-			"data": map[string]interface{}{
-				"items":    []map[string]interface{}{},
-				"has_more": false,
-			},
-		},
-	})
-
-	err := mountAndRunDrive(t, DriveListComments, []string{
-		"+list-comments",
-		"--token", "wikiResource",
-		"--type", "wiki",
-		"--solved-status", "all",
-		"--comment-scope", "whole",
-		"--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 != "docxFromWikiResource" {
-		t.Fatalf("file_token = %q, want docxFromWikiResource", got)
-	}
-	if got := mustStringField(t, data, "file_type", "data.file_type"); got != "docx" {
-		t.Fatalf("file_type = %q, want docx", got)
-	}
-}

shortcuts/drive/drive_member_add_test.go

@@ -518,17 +518,15 @@ func TestDriveMemberAdd_PermDefaultsToView(t *testing.T) {
 	}
 
 	var got struct {
-		Data struct {
-			API []struct {
-				Body map[string]interface{} `json:"body"`
-			} `json:"api"`
-		} `json:"data"`
+		API []struct {
+			Body map[string]interface{} `json:"body"`
+		} `json:"api"`
 	}
 	if err := json.Unmarshal(stdout.Bytes(), &got); err != nil {
 		t.Fatalf("decode dry-run output: %v\n%s", err, stdout.String())
 	}
-	if got.Data.API[0].Body["perm"] != "view" {
-		t.Fatalf("perm = %v, want view", got.Data.API[0].Body["perm"])
+	if got.API[0].Body["perm"] != "view" {
+		t.Fatalf("perm = %v, want view", got.API[0].Body["perm"])
 	}
 }
 
@@ -627,20 +625,18 @@ func TestDriveMemberAdd_DryRunAcceptsAppID(t *testing.T) {
 	}
 
 	var got struct {
-		Data struct {
-			API []struct {
-				Body map[string]interface{} `json:"body"`
-			} `json:"api"`
-		} `json:"data"`
+		API []struct {
+			Body map[string]interface{} `json:"body"`
+		} `json:"api"`
 	}
 	if err := json.Unmarshal(stdout.Bytes(), &got); err != nil {
 		t.Fatalf("decode dry-run output: %v\n%s", err, stdout.String())
 	}
-	if got.Data.API[0].Body["member_type"] != "appid" {
-		t.Fatalf("member_type = %v, want appid", got.Data.API[0].Body["member_type"])
+	if got.API[0].Body["member_type"] != "appid" {
+		t.Fatalf("member_type = %v, want appid", got.API[0].Body["member_type"])
 	}
-	if _, ok := got.Data.API[0].Body["type"]; ok {
-		t.Fatalf("type = %v, want omitted for appid", got.Data.API[0].Body["type"])
+	if _, ok := got.API[0].Body["type"]; ok {
+		t.Fatalf("type = %v, want omitted for appid", got.API[0].Body["type"])
 	}
 }
 
@@ -664,17 +660,15 @@ func TestDriveMemberAdd_DryRunAcceptsWikiSpaceID(t *testing.T) {
 	}
 
 	var got struct {
-		Data struct {
-			API []struct {
-				Body map[string]interface{} `json:"body"`
-			} `json:"api"`
-		} `json:"data"`
+		API []struct {
+			Body map[string]interface{} `json:"body"`
+		} `json:"api"`
 	}
 	if err := json.Unmarshal(stdout.Bytes(), &got); err != nil {
 		t.Fatalf("decode dry-run output: %v\n%s", err, stdout.String())
 	}
-	if got.Data.API[0].Body["member_type"] != "wikispaceid" || got.Data.API[0].Body["type"] != "wiki_space_viewer" {
-		t.Fatalf("body = %#v, want wikispaceid + wiki_space_viewer", got.Data.API[0].Body)
+	if got.API[0].Body["member_type"] != "wikispaceid" || got.API[0].Body["type"] != "wiki_space_viewer" {
+		t.Fatalf("body = %#v, want wikispaceid + wiki_space_viewer", got.API[0].Body)
 	}
 }
 
@@ -798,22 +792,20 @@ func TestDriveMemberAdd_DryRunInfersTypeAndDefaultsWikiPermType(t *testing.T) {
 	}
 
 	var got struct {
-		Data struct {
-			API []struct {
-				Method string                 `json:"method"`
-				URL    string                 `json:"url"`
-				Params map[string]interface{} `json:"params"`
-				Body   map[string]interface{} `json:"body"`
-			} `json:"api"`
-		} `json:"data"`
+		API []struct {
+			Method string                 `json:"method"`
+			URL    string                 `json:"url"`
+			Params map[string]interface{} `json:"params"`
+			Body   map[string]interface{} `json:"body"`
+		} `json:"api"`
 	}
 	if err := json.Unmarshal(stdout.Bytes(), &got); err != nil {
 		t.Fatalf("decode dry-run output: %v\n%s", err, stdout.String())
 	}
-	if len(got.Data.API) != 1 {
-		t.Fatalf("api count = %d, want 1; stdout=%s", len(got.Data.API), stdout.String())
+	if len(got.API) != 1 {
+		t.Fatalf("api count = %d, want 1; stdout=%s", len(got.API), stdout.String())
 	}
-	api := got.Data.API[0]
+	api := got.API[0]
 	if api.Method != "POST" || api.URL != "/open-apis/drive/v1/permissions/wikTok/members" {
 		t.Fatalf("api = %#v", api)
 	}
@@ -844,21 +836,19 @@ func TestDriveMemberAdd_DryRunAcceptsUppercaseEnumsForDocx(t *testing.T) {
 	}
 
 	var got struct {
-		Data struct {
-			API []struct {
-				Params map[string]interface{} `json:"params"`
-				Body   map[string]interface{} `json:"body"`
-			} `json:"api"`
-		} `json:"data"`
+		API []struct {
+			Params map[string]interface{} `json:"params"`
+			Body   map[string]interface{} `json:"body"`
+		} `json:"api"`
 	}
 	if err := json.Unmarshal(stdout.Bytes(), &got); err != nil {
 		t.Fatalf("decode dry-run output: %v\n%s", err, stdout.String())
 	}
-	if got.Data.API[0].Params["type"] != "docx" {
-		t.Fatalf("params.type = %v, want docx", got.Data.API[0].Params["type"])
+	if got.API[0].Params["type"] != "docx" {
+		t.Fatalf("params.type = %v, want docx", got.API[0].Params["type"])
 	}
-	if got.Data.API[0].Body["member_type"] != "openid" || got.Data.API[0].Body["perm"] != "edit" {
-		t.Fatalf("body = %#v, want canonical lowercase enum values", got.Data.API[0].Body)
+	if got.API[0].Body["member_type"] != "openid" || got.API[0].Body["perm"] != "edit" {
+		t.Fatalf("body = %#v, want canonical lowercase enum values", got.API[0].Body)
 	}
 }
 
@@ -882,21 +872,19 @@ func TestDriveMemberAdd_DryRunAcceptsUppercaseWikiPermType(t *testing.T) {
 	}
 
 	var got struct {
-		Data struct {
-			API []struct {
-				Params map[string]interface{} `json:"params"`
-				Body   map[string]interface{} `json:"body"`
-			} `json:"api"`
-		} `json:"data"`
+		API []struct {
+			Params map[string]interface{} `json:"params"`
+			Body   map[string]interface{} `json:"body"`
+		} `json:"api"`
 	}
 	if err := json.Unmarshal(stdout.Bytes(), &got); err != nil {
 		t.Fatalf("decode dry-run output: %v\n%s", err, stdout.String())
 	}
-	if got.Data.API[0].Params["type"] != "wiki" {
-		t.Fatalf("params.type = %v, want wiki", got.Data.API[0].Params["type"])
+	if got.API[0].Params["type"] != "wiki" {
+		t.Fatalf("params.type = %v, want wiki", got.API[0].Params["type"])
 	}
-	if got.Data.API[0].Body["member_type"] != "openid" || got.Data.API[0].Body["perm"] != "edit" || got.Data.API[0].Body["perm_type"] != "container" {
-		t.Fatalf("body = %#v, want canonical lowercase enum values", got.Data.API[0].Body)
+	if got.API[0].Body["member_type"] != "openid" || got.API[0].Body["perm"] != "edit" || got.API[0].Body["perm_type"] != "container" {
+		t.Fatalf("body = %#v, want canonical lowercase enum values", got.API[0].Body)
 	}
 }
 
@@ -961,21 +949,19 @@ func TestDriveMemberAdd_DryRunBatch(t *testing.T) {
 	}
 
 	var got struct {
-		Data struct {
-			API []struct {
-				Method string                 `json:"method"`
-				URL    string                 `json:"url"`
-				Body   map[string]interface{} `json:"body"`
-			} `json:"api"`
-		} `json:"data"`
+		API []struct {
+			Method string                 `json:"method"`
+			URL    string                 `json:"url"`
+			Body   map[string]interface{} `json:"body"`
+		} `json:"api"`
 	}
 	if err := json.Unmarshal(stdout.Bytes(), &got); err != nil {
 		t.Fatalf("decode dry-run output: %v\n%s", err, stdout.String())
 	}
-	if len(got.Data.API) != 1 {
-		t.Fatalf("api count = %d, want 1", len(got.Data.API))
+	if len(got.API) != 1 {
+		t.Fatalf("api count = %d, want 1", len(got.API))
 	}
-	api := got.Data.API[0]
+	api := got.API[0]
 	if api.Method != "POST" || api.URL != "/open-apis/drive/v1/permissions/shtcnTok/members/batch_create" {
 		t.Fatalf("api = %#v", api)
 	}

shortcuts/drive/shortcuts.go

@@ -15,7 +15,6 @@ func Shortcuts() []common.Shortcut {
 		DrivePreview,
 		DriveCover,
 		DriveAddComment,
-		DriveListComments,
 		DriveExport,
 		DriveExportDownload,
 		DriveImport,

shortcuts/drive/shortcuts_test.go

@@ -20,15 +20,14 @@ func TestShortcutsIncludesExpectedCommands(t *testing.T) {
 		"+download",
 		"+preview",
 		"+cover",
-		"+add-comment",
-		"+list-comments",
-		"+export",
-		"+export-download",
-		"+import",
 		"+version-history",
 		"+version-get",
 		"+version-revert",
 		"+version-delete",
+		"+add-comment",
+		"+export",
+		"+export-download",
+		"+import",
 		"+move",
 		"+delete",
 		"+status",

shortcuts/event/helpers.go

@@ -34,53 +34,6 @@ func extractUserIDs(users []interface{}) []string {
 	return ids
 }
 
-// stringField safely extracts a string value from a map.
-func stringField(m map[string]interface{}, key string) string {
-	v, _ := m[key].(string)
-	return v
-}
-
-// mentionOpenID extracts open_id from a mention id field (nested object or plain string).
-func mentionOpenID(raw interface{}) string {
-	switch v := raw.(type) {
-	case map[string]interface{}:
-		openID, _ := v["open_id"].(string)
-		return openID
-	case string:
-		return v
-	default:
-		return ""
-	}
-}
-
-// compactMentions converts the raw mentions array into a compact form with key, id, name.
-func compactMentions(mentions []interface{}) []map[string]interface{} {
-	if len(mentions) == 0 {
-		return nil
-	}
-	out := make([]map[string]interface{}, 0, len(mentions))
-	for _, raw := range mentions {
-		item, _ := raw.(map[string]interface{})
-		m := map[string]interface{}{}
-		if k := stringField(item, "key"); k != "" {
-			m["key"] = k
-		}
-		if id := mentionOpenID(item["id"]); id != "" {
-			m["id"] = id
-		}
-		if n := stringField(item, "name"); n != "" {
-			m["name"] = n
-		}
-		if len(m) > 0 {
-			out = append(out, m)
-		}
-	}
-	if len(out) == 0 {
-		return nil
-	}
-	return out
-}
-
 // compactBase builds the common compact output fields shared by all IM event processors.
 // Every compact output includes: type (event_type), event_id, and timestamp (header create_time).
 func compactBase(raw *RawEvent) map[string]interface{} {

shortcuts/event/processor_im_message.go

@@ -16,13 +16,9 @@ import (
 // ImMessageProcessor handles im.message.receive_v1 events.
 //
 // Compact output fields:
-//   - type, event_id, timestamp
-//   - id, message_id, create_time, update_time
-//   - chat_id, chat_type, message_type
-//   - sender_id, sender_type
-//   - root_id, thread_id, reply_to
-//   - content: human-readable text converted via convertlib
-//   - mentions: compact mentions array with key, id, name
+//   - type, id, message_id, create_time, timestamp
+//   - chat_id, chat_type, message_type, sender_id
+//   - content: human-readable text converted via convertlib (supports text, post, image, file, card, etc.)
 type ImMessageProcessor struct{}
 
 func (p *ImMessageProcessor) EventType() string { return "im.message.receive_v1" }
@@ -36,20 +32,15 @@ func (p *ImMessageProcessor) Transform(_ context.Context, raw *RawEvent, mode Tr
 	var ev struct {
 		Message struct {
 			MessageID   string        `json:"message_id"`
-			RootID      string        `json:"root_id"`
-			ParentID    string        `json:"parent_id"`
-			ThreadID    string        `json:"thread_id"`
 			ChatID      string        `json:"chat_id"`
 			ChatType    string        `json:"chat_type"`
 			MessageType string        `json:"message_type"`
 			Content     string        `json:"content"`
 			CreateTime  string        `json:"create_time"`
-			UpdateTime  string        `json:"update_time"`
 			Mentions    []interface{} `json:"mentions"`
 		} `json:"message"`
 		Sender struct {
-			SenderType string `json:"sender_type"`
-			SenderID   struct {
+			SenderID struct {
 				OpenID string `json:"open_id"`
 			} `json:"sender_id"`
 		} `json:"sender"`
@@ -76,9 +67,6 @@ func (p *ImMessageProcessor) Transform(_ context.Context, raw *RawEvent, mode Tr
 	out := map[string]interface{}{
 		"type": raw.Header.EventType,
 	}
-	if raw.Header.EventID != "" {
-		out["event_id"] = raw.Header.EventID
-	}
 	if ev.Message.MessageID != "" {
 		out["id"] = ev.Message.MessageID
 		out["message_id"] = ev.Message.MessageID
@@ -92,9 +80,6 @@ func (p *ImMessageProcessor) Transform(_ context.Context, raw *RawEvent, mode Tr
 	} else if ev.Message.CreateTime != "" {
 		out["timestamp"] = ev.Message.CreateTime
 	}
-	if ev.Message.UpdateTime != "" && ev.Message.UpdateTime != ev.Message.CreateTime {
-		out["update_time"] = ev.Message.UpdateTime
-	}
 	if ev.Message.ChatID != "" {
 		out["chat_id"] = ev.Message.ChatID
 	}
@@ -107,24 +92,9 @@ func (p *ImMessageProcessor) Transform(_ context.Context, raw *RawEvent, mode Tr
 	if ev.Sender.SenderID.OpenID != "" {
 		out["sender_id"] = ev.Sender.SenderID.OpenID
 	}
-	if ev.Sender.SenderType != "" {
-		out["sender_type"] = ev.Sender.SenderType
-	}
-	if ev.Message.RootID != "" {
-		out["root_id"] = ev.Message.RootID
-	}
-	if ev.Message.ThreadID != "" {
-		out["thread_id"] = ev.Message.ThreadID
-	}
-	if ev.Message.ParentID != "" {
-		out["reply_to"] = ev.Message.ParentID
-	}
 	if content != "" {
 		out["content"] = content
 	}
-	if mentions := compactMentions(ev.Message.Mentions); len(mentions) > 0 {
-		out["mentions"] = mentions
-	}
 	return out
 }
 

shortcuts/event/processor_test.go

@@ -792,6 +792,7 @@ func TestImMessageProcessor_CompactInteractiveFallsBackToRaw(t *testing.T) {
 		t.Fatalf("stderr hint = %q, want interactive fallback message", string(hint))
 	}
 }
+
 func TestGenericProcessor_CompactUnmarshalError(t *testing.T) {
 	p := &GenericProcessor{}
 	raw := makeRawEvent("some.type", `not valid json`)

shortcuts/im/builders_test.go

@@ -504,84 +504,6 @@ func TestShortcutValidateBranches(t *testing.T) {
 		}
 	})
 
-	t.Run("validateIdempotencyKey empty string passes", func(t *testing.T) {
-		if err := validateIdempotencyKey(""); err != nil {
-			t.Fatalf("validateIdempotencyKey() unexpected error = %v", err)
-		}
-	})
-
-	t.Run("validateIdempotencyKey 50 chars passes", func(t *testing.T) {
-		if err := validateIdempotencyKey(strings.Repeat("a", 50)); err != nil {
-			t.Fatalf("validateIdempotencyKey() unexpected error = %v", err)
-		}
-	})
-
-	t.Run("validateIdempotencyKey 51 chars fails", func(t *testing.T) {
-		err := validateIdempotencyKey(strings.Repeat("a", 51))
-		if err == nil || !strings.Contains(err.Error(), "--idempotency-key exceeds the maximum of 50 characters") {
-			t.Fatalf("validateIdempotencyKey() error = %v", err)
-		}
-	})
-
-	t.Run("validateIdempotencyKey 50 Chinese chars passes", func(t *testing.T) {
-		if err := validateIdempotencyKey(strings.Repeat("中", 50)); err != nil {
-			t.Fatalf("validateIdempotencyKey() unexpected error = %v", err)
-		}
-	})
-
-	t.Run("validateIdempotencyKey 51 Chinese chars fails", func(t *testing.T) {
-		err := validateIdempotencyKey(strings.Repeat("中", 51))
-		if err == nil || !strings.Contains(err.Error(), "--idempotency-key exceeds the maximum of 50 characters") {
-			t.Fatalf("validateIdempotencyKey() error = %v", err)
-		}
-	})
-
-	t.Run("ImMessagesSend idempotency key too long", func(t *testing.T) {
-		runtime := newTestRuntimeContext(t, map[string]string{
-			"chat-id":         "oc_123",
-			"text":            "hello",
-			"idempotency-key": strings.Repeat("a", 51),
-		}, nil)
-		err := ImMessagesSend.Validate(context.Background(), runtime)
-		if err == nil || !strings.Contains(err.Error(), "--idempotency-key exceeds the maximum of 50 characters") {
-			t.Fatalf("ImMessagesSend.Validate() error = %v", err)
-		}
-	})
-
-	t.Run("ImMessagesSend idempotency key valid", func(t *testing.T) {
-		runtime := newTestRuntimeContext(t, map[string]string{
-			"chat-id":         "oc_123",
-			"text":            "hello",
-			"idempotency-key": "my-key-001",
-		}, nil)
-		if err := ImMessagesSend.Validate(context.Background(), runtime); err != nil {
-			t.Fatalf("ImMessagesSend.Validate() unexpected error = %v", err)
-		}
-	})
-
-	t.Run("ImMessagesReply idempotency key too long", func(t *testing.T) {
-		runtime := newTestRuntimeContext(t, map[string]string{
-			"message-id":      "om_123",
-			"text":            "hello",
-			"idempotency-key": strings.Repeat("b", 51),
-		}, nil)
-		err := ImMessagesReply.Validate(context.Background(), runtime)
-		if err == nil || !strings.Contains(err.Error(), "--idempotency-key exceeds the maximum of 50 characters") {
-			t.Fatalf("ImMessagesReply.Validate() error = %v", err)
-		}
-	})
-
-	t.Run("ImMessagesReply idempotency key valid", func(t *testing.T) {
-		runtime := newTestRuntimeContext(t, map[string]string{
-			"message-id":      "om_123",
-			"text":            "hello",
-			"idempotency-key": "reply-key-001",
-		}, nil)
-		if err := ImMessagesReply.Validate(context.Background(), runtime); err != nil {
-			t.Fatalf("ImMessagesReply.Validate() unexpected error = %v", err)
-		}
-	})
-
 	t.Run("ImMessagesReply invalid message id", func(t *testing.T) {
 		runtime := newTestRuntimeContext(t, map[string]string{
 			"message-id": "bad_id",
@@ -957,7 +879,7 @@ func TestShortcutDryRunShapes(t *testing.T) {
 			"message-ids": "om_1,om_2",
 		}, nil)
 		got := mustMarshalDryRun(t, ImMessagesMGet.DryRun(context.Background(), runtime))
-		if !strings.Contains(got, `"/open-apis/im/v1/messages/mget?card_msg_content_type=raw_card_content\u0026with_sender_name=true\u0026message_ids=om_1\u0026message_ids=om_2"`) {
+		if !strings.Contains(got, `"/open-apis/im/v1/messages/mget?card_msg_content_type=raw_card_content\u0026message_ids=om_1\u0026message_ids=om_2"`) {
 			t.Fatalf("ImMessagesMGet.DryRun() = %s", got)
 		}
 	})

shortcuts/im/convert_lib/helpers.go

@@ -6,11 +6,14 @@ package convertlib
 import (
 	"encoding/json"
 	"fmt"
+	"net/http"
+	"net/url"
 	"strconv"
 	"strings"
 	"time"
 
 	"github.com/larksuite/cli/shortcuts/common"
+	larkcore "github.com/larksuite/oapi-sdk-go/v3/core"
 )
 
 // ParseJSONObject parses a raw JSON string into a map.
@@ -69,66 +72,161 @@ func formatTimestamp(ts string) string {
 	return time.Unix(n, 0).Local().Format("2006-01-02 15:04:05")
 }
 
-// pickSenderName returns the server-provided display name from a message sender:
-// the plain `sender_name` (the server's default-locale name). Callers wanting a
-// specific locale should read the full `sender_i18n_names` map, which is preserved
-// on the sender. Returns "" when the server supplied no name, so the caller can
-// fall back to the raw id.
-func pickSenderName(sender map[string]interface{}) string {
-	name, _ := sender["sender_name"].(string)
-	return name
-}
-
-// ResolveSenderNames harvests the server-provided sender_name for each message
-// sender into the shared cache (keyed by sender id), so a sender appearing across
-// the render tree (e.g. merge_forward sub-items, thread replies) resolves once.
-// The message read API is the single source of truth for names (opt in via
-// with_sender_name=true); there is NO contact/mention fallback — a sender the
-// server did not name resolves to its id downstream. Pass an empty map if none exists.
-func ResolveSenderNames(_ *common.RuntimeContext, messages []map[string]interface{}, cache map[string]string) map[string]string {
+// ResolveSenderNames batch-resolves sender open_ids to display names.
+// The cache map is used to share already-resolved IDs across calls; newly resolved
+// names are written back into it. Pass an empty map if no prior cache exists.
+//
+// Step 1: extract names from message mentions (free, no API call).
+// Step 2: for remaining unresolved IDs, call contact batch API (requires contact:user.base:readonly).
+// Silently returns partial results on API error.
+//
+// [#22] Changed from variadic `cache ...map[string]string` to a required parameter.
+// The variadic form was misleading: every caller passed exactly one map, and the function
+// body both modified it and returned it, making the dual semantics confusing.
+func ResolveSenderNames(runtime *common.RuntimeContext, messages []map[string]interface{}, cache map[string]string) map[string]string {
 	nameMap := cache
 	if nameMap == nil {
 		nameMap = make(map[string]string)
 	}
+
+	// Step 1: extract names from mentions (free)
+	for _, msg := range messages {
+		switch mentions := msg["mentions"].(type) {
+		case []interface{}:
+			for _, raw := range mentions {
+				m, _ := raw.(map[string]interface{})
+				id, _ := m["id"].(string)
+				name, _ := m["name"].(string)
+				if id != "" && name != "" && strings.HasPrefix(id, "ou_") {
+					nameMap[id] = name
+				}
+			}
+		case []map[string]interface{}:
+			// Backward-compatible path for tests/callers that construct typed slices.
+			for _, m := range mentions {
+				id, _ := m["id"].(string)
+				name, _ := m["name"].(string)
+				if id != "" && name != "" && strings.HasPrefix(id, "ou_") {
+					nameMap[id] = name
+				}
+			}
+		}
+	}
+
+	// Collect sender IDs still missing a name
+	seen := make(map[string]bool)
+	var missingIDs []string
 	for _, msg := range messages {
 		sender, ok := msg["sender"].(map[string]interface{})
 		if !ok {
 			continue
 		}
-		id, _ := sender["id"].(string)
-		if id == "" {
+		senderType, _ := sender["sender_type"].(string)
+		if senderType != "user" {
 			continue
 		}
-		if name := pickSenderName(sender); name != "" {
-			nameMap[id] = name
+		id, _ := sender["id"].(string)
+		if id == "" || !strings.HasPrefix(id, "ou_") || seen[id] || nameMap[id] != "" {
+			continue
 		}
+		seen[id] = true
+		missingIDs = append(missingIDs, id)
 	}
+	if len(missingIDs) == 0 {
+		return nameMap
+	}
+
+	// Step 2: batch resolve remaining via contact API.
+	// Use basic_batch for user identity (lighter permission requirement),
+	// full batch for bot identity.
+	if runtime.As().IsBot() {
+		batchResolveUsers(runtime, missingIDs, nameMap)
+	} else {
+		batchResolveByBasicContact(runtime, missingIDs, nameMap)
+	}
+
 	return nameMap
 }
 
-// AttachSenderNames enriches message sender objects with a single resolved display
-// name in `name`, taken from the server-provided sender_name (via the sender itself
-// or the shared cache). Senders the server did not name keep no `name` (id is
-// preserved for downstream id fallback) — there is no contact/mention lookup.
-//
-// The raw `sender_name` is stripped from the output because it exactly duplicates
-// `name`; `sender_i18n_names` (the full i18n set, all locales) and `open_bot_id`
-// are preserved for consumers that need a specific locale or the id alignment.
+// batchResolveByBasicContact resolves user names via POST /contact/v3/users/basic_batch.
+// This API has lighter permission requirements and works with user identity
+// even when the target user is not in the app's visible range.
+// Response uses "users" (not "items") and "user_id" (not "open_id").
+// The basic_batch endpoint caps user_ids at 10 per request.
+func batchResolveByBasicContact(runtime *common.RuntimeContext, missingIDs []string, nameMap map[string]string) {
+	const batchSize = 10
+	for i := 0; i < len(missingIDs); i += batchSize {
+		end := i + batchSize
+		if end > len(missingIDs) {
+			end = len(missingIDs)
+		}
+		batch := missingIDs[i:end]
+
+		data, err := runtime.DoAPIJSONTyped(http.MethodPost,
+			"/open-apis/contact/v3/users/basic_batch",
+			larkcore.QueryParams{"user_id_type": []string{"open_id"}},
+			map[string]interface{}{"user_ids": batch},
+		)
+		if err != nil {
+			break
+		}
+
+		users, _ := data["users"].([]interface{})
+		for _, item := range users {
+			user, _ := item.(map[string]interface{})
+			userID, _ := user["user_id"].(string)
+			name, _ := user["name"].(string)
+			if userID != "" && name != "" {
+				nameMap[userID] = name
+			}
+		}
+	}
+}
+
+func batchResolveUsers(runtime *common.RuntimeContext, missingIDs []string, nameMap map[string]string) {
+	const batchSize = 50
+	for i := 0; i < len(missingIDs); i += batchSize {
+		end := i + batchSize
+		if end > len(missingIDs) {
+			end = len(missingIDs)
+		}
+		batch := missingIDs[i:end]
+
+		parts := []string{"user_id_type=open_id"}
+		for _, uid := range batch {
+			parts = append(parts, "user_ids="+url.QueryEscape(uid))
+		}
+		apiURL := "/open-apis/contact/v3/users/batch?" + strings.Join(parts, "&")
+
+		data, err := runtime.DoAPIJSONTyped(http.MethodGet, apiURL, nil, nil)
+		if err != nil {
+			break
+		}
+
+		items, _ := data["items"].([]interface{})
+		for _, item := range items {
+			user, _ := item.(map[string]interface{})
+			openID, _ := user["open_id"].(string)
+			name, _ := user["name"].(string)
+			if openID != "" && name != "" {
+				nameMap[openID] = name
+			}
+		}
+	}
+}
+
+// AttachSenderNames enriches message sender objects with resolved display names.
+// Senders whose name could not be resolved are left unchanged (id is preserved).
 func AttachSenderNames(messages []map[string]interface{}, nameMap map[string]string) {
 	for _, msg := range messages {
 		sender, ok := msg["sender"].(map[string]interface{})
 		if !ok {
 			continue
 		}
-		if name := pickSenderName(sender); name != "" {
+		id, _ := sender["id"].(string)
+		if name, ok := nameMap[id]; ok {
 			sender["name"] = name
-		} else if id, _ := sender["id"].(string); id != "" {
-			if name, ok := nameMap[id]; ok {
-				sender["name"] = name
-			}
 		}
-		// sender_name exactly duplicates `name`; drop it. Keep sender_i18n_names + open_bot_id.
-		delete(sender, "sender_name")
 	}
 }
 

shortcuts/im/convert_lib/helpers_test.go

@@ -4,9 +4,12 @@
 package convertlib
 
 import (
+	"encoding/json"
 	"fmt"
+	"io"
 	"net/http"
 	"reflect"
+	"strings"
 	"testing"
 	"time"
 )
@@ -126,172 +129,114 @@ func TestExtractPostBlocksText(t *testing.T) {
 }
 
 func TestResolveSenderNames(t *testing.T) {
-	// Server-provided sender_name is harvested into the cache for both user and bot;
-	// senders the server did not name are absent (id fallback downstream). There is no
-	// contact/mention lookup, so no API call is ever made.
-	rt := newBotConvertlibRuntime(t, convertlibRoundTripFunc(func(req *http.Request) (*http.Response, error) {
-		return nil, fmt.Errorf("no API call expected: %s", req.URL.String())
+	runtime := newBotConvertlibRuntime(t, convertlibRoundTripFunc(func(req *http.Request) (*http.Response, error) {
+		switch {
+		case strings.Contains(req.URL.Path, "/open-apis/contact/v3/users/batch"):
+			if got := req.URL.Query()["user_ids"]; !reflect.DeepEqual(got, []string{"ou_api", "ou_missing"}) {
+				t.Fatalf("contact batch user_ids = %#v, want %#v", got, []string{"ou_api", "ou_missing"})
+			}
+			return convertlibJSONResponse(200, map[string]interface{}{
+				"code": 0,
+				"data": map[string]interface{}{
+					"items": []interface{}{
+						map[string]interface{}{"open_id": "ou_api", "name": "API User"},
+					},
+				},
+			}), nil
+		default:
+			return nil, fmt.Errorf("unexpected request: %s", req.URL.String())
+		}
 	}))
 
-	messages := []map[string]interface{}{
-		{"sender": map[string]interface{}{"sender_type": "user", "id": "ou_named", "sender_name": "Named User"}},
-		{"sender": map[string]interface{}{"sender_type": "app", "id": "cli_bot", "sender_name": "Bot Alpha"}},
-		{"sender": map[string]interface{}{"sender_type": "user", "id": "ou_unnamed"}},
-	}
-
-	got := ResolveSenderNames(rt, messages, nil)
-	if got["ou_named"] != "Named User" {
-		t.Fatalf("named user = %#v, want %#v", got["ou_named"], "Named User")
-	}
-	if got["cli_bot"] != "Bot Alpha" {
-		t.Fatalf("named bot = %#v, want %#v", got["cli_bot"], "Bot Alpha")
-	}
-	if _, has := got["ou_unnamed"]; has {
-		t.Fatalf("unnamed sender must not be resolved (no contact fallback), got %#v", got["ou_unnamed"])
-	}
-}
-
-// TestResolveSenderNamesServerNameBeatsMention locks the priority: when a sender's id
-// also appears as a mention, the server-provided sender_name must win over the mention
-// name (which can be a remark/nickname), and no contact call is made.
-func TestResolveSenderNamesServerNameBeatsMention(t *testing.T) {
-	rt := newBotConvertlibRuntime(t, convertlibRoundTripFunc(func(req *http.Request) (*http.Response, error) {
-		return nil, fmt.Errorf("no contact call expected: %s", req.URL.String())
-	}))
 	messages := []map[string]interface{}{
 		{
-			"sender": map[string]interface{}{"sender_type": "user", "id": "ou_dual", "sender_name": "Server Name"},
+			"sender": map[string]interface{}{"sender_type": "user", "id": "ou_mention"},
 			"mentions": []interface{}{
-				map[string]interface{}{"id": "ou_dual", "name": "Mention Remark"},
+				map[string]interface{}{"id": "ou_mention", "name": "Mention User"},
 			},
 		},
+		{"sender": map[string]interface{}{"sender_type": "user", "id": "ou_api"}},
+		{"sender": map[string]interface{}{"sender_type": "user", "id": "ou_missing"}},
+		{"sender": map[string]interface{}{"sender_type": "bot", "id": "cli_1"}},
 	}
-	got := ResolveSenderNames(rt, messages, nil)
-	if got["ou_dual"] != "Server Name" {
-		t.Fatalf("server sender_name must beat mention name: got %#v, want %#v", got["ou_dual"], "Server Name")
+
+	got := ResolveSenderNames(runtime, messages, nil)
+	if got["ou_mention"] != "Mention User" {
+		t.Fatalf("mention-resolved sender = %#v, want %#v", got["ou_mention"], "Mention User")
+	}
+	if got["ou_api"] != "API User" {
+		t.Fatalf("api-resolved sender = %#v, want %#v", got["ou_api"], "API User")
+	}
+	if got["ou_missing"] != "" {
+		t.Fatalf("missing sender = %#v, want empty", got["ou_missing"])
 	}
 }
 
-// TestFormatMessageItemSenderPassthrough covers AC5: the formatted message must
-// carry the sender object through verbatim — retaining open_bot_id and leaving
-// id / id_type unchanged after enrichment.
-func TestFormatMessageItemSenderPassthrough(t *testing.T) {
+func TestBatchResolveByBasicContactRespectsAPILimit(t *testing.T) {
+	// basic_batch allows at most 10 user_ids per request. Given 25 missing IDs,
+	// expect three requests with sizes 10 / 10 / 5.
+	var batchSizes []int
 	runtime := newBotConvertlibRuntime(t, convertlibRoundTripFunc(func(req *http.Request) (*http.Response, error) {
-		return convertlibJSONResponse(200, map[string]interface{}{"code": 0, "data": map[string]interface{}{}}), nil
-	}))
-	m := map[string]interface{}{
-		"message_id": "om_1",
-		"msg_type":   "text",
-		"body":       map[string]interface{}{"content": `{"text":"hi"}`},
-		"sender": map[string]interface{}{
-			"id":          "cli_bot",
-			"id_type":     "app_id",
-			"sender_type": "app",
-			"sender_name": "Bot Alpha",
-			"open_bot_id": "ou_bot",
-		},
-	}
+		if !strings.Contains(req.URL.Path, "/open-apis/contact/v3/users/basic_batch") {
+			return nil, fmt.Errorf("unexpected path: %s", req.URL.Path)
+		}
+		body, err := io.ReadAll(req.Body)
+		if err != nil {
+			return nil, err
+		}
+		var payload map[string]interface{}
+		if err := json.Unmarshal(body, &payload); err != nil {
+			return nil, err
+		}
+		userIDs, _ := payload["user_ids"].([]interface{})
+		if len(userIDs) > 10 {
+			t.Fatalf("batch exceeded API limit: size = %d", len(userIDs))
+		}
+		batchSizes = append(batchSizes, len(userIDs))
 
-	out := FormatMessageItem(m, runtime)
-	sender, ok := out["sender"].(map[string]interface{})
-	if !ok {
-		t.Fatalf("formatted sender missing/mistyped: %#v", out["sender"])
-	}
-	if sender["open_bot_id"] != "ou_bot" {
-		t.Fatalf("open_bot_id passthrough = %#v, want %#v", sender["open_bot_id"], "ou_bot")
-	}
-	if sender["id"] != "cli_bot" || sender["id_type"] != "app_id" {
-		t.Fatalf("id/id_type must be unchanged, got id=%#v id_type=%#v", sender["id"], sender["id_type"])
-	}
-}
-
-func TestPickSenderName(t *testing.T) {
-	// Uses the server-provided sender_name.
-	if got := pickSenderName(map[string]interface{}{"sender_name": "Bot Alpha"}); got != "Bot Alpha" {
-		t.Fatalf("pickSenderName(sender_name) = %q, want %q", got, "Bot Alpha")
-	}
-	// sender_i18n_names is NOT consulted for the display name (it stays in output for
-	// consumers that want a specific locale); no sender_name -> empty (caller uses id).
-	i18nOnly := map[string]interface{}{
-		"sender_i18n_names": map[string]interface{}{"en_us": "Bot Beta", "zh_cn": "机器人乙", "ja_jp": "ロボット"},
-	}
-	if got := pickSenderName(i18nOnly); got != "" {
-		t.Fatalf("pickSenderName(i18n only, no sender_name) = %q, want empty", got)
-	}
-	// Empty sender_name -> empty (no i18n fallthrough).
-	if got := pickSenderName(map[string]interface{}{"sender_name": ""}); got != "" {
-		t.Fatalf("pickSenderName(empty sender_name) = %q, want empty", got)
-	}
-	// Nothing available -> empty (caller falls back to id).
-	if got := pickSenderName(map[string]interface{}{"id": "cli_x"}); got != "" {
-		t.Fatalf("pickSenderName(no name) = %q, want empty", got)
-	}
-}
-
-// TestAttachSenderNamesPrefersProducerName covers AC1 (bot display name), AC2
-// (user producer name), AC5 (open_bot_id passthrough) and AC3 (id fallback).
-func TestAttachSenderNamesPrefersProducerName(t *testing.T) {
-	i18n := map[string]interface{}{"en_us": "Bot Alpha", "zh_cn": "机器人甲"}
-	messages := []map[string]interface{}{
-		// bot sender with producer-filled sender_name (AC1) + sender_i18n_names + open_bot_id (AC5)
-		{"sender": map[string]interface{}{"sender_type": "app", "id": "cli_bot", "sender_name": "机器人甲", "sender_i18n_names": i18n, "open_bot_id": "ou_bot"}},
-		// user sender with producer-filled sender_name (AC2, unified read)
-		{"sender": map[string]interface{}{"sender_type": "user", "id": "ou_user1", "sender_name": "Producer User"}},
-		// user sender without producer name -> resolved from the shared name cache (nameMap)
-		{"sender": map[string]interface{}{"sender_type": "user", "id": "ou_user2"}},
-		// bot sender without any name -> stays id (AC3)
-		{"sender": map[string]interface{}{"sender_type": "app", "id": "cli_unknown"}},
-	}
-	nameMap := map[string]string{"ou_user2": "Contact User"}
-
-	AttachSenderNames(messages, nameMap)
-
-	s0 := messages[0]["sender"].(map[string]interface{})
-	if s0["name"] != "机器人甲" {
-		t.Fatalf("bot sender name = %#v, want %#v", s0["name"], "机器人甲")
-	}
-	if s0["open_bot_id"] != "ou_bot" {
-		t.Fatalf("bot open_bot_id passthrough = %#v, want %#v", s0["open_bot_id"], "ou_bot")
-	}
-	// sender_name is dropped (duplicate of name); sender_i18n_names is kept.
-	if _, has := s0["sender_name"]; has {
-		t.Fatalf("sender_name should be stripped from output, got %#v", s0["sender_name"])
-	}
-	if _, has := s0["sender_i18n_names"]; !has {
-		t.Fatalf("sender_i18n_names should be preserved in output")
-	}
-	if s := messages[1]["sender"].(map[string]interface{}); s["name"] != "Producer User" {
-		t.Fatalf("user producer name = %#v, want %#v", s["name"], "Producer User")
-	}
-	if s := messages[2]["sender"].(map[string]interface{}); s["name"] != "Contact User" {
-		t.Fatalf("user contact-fallback name = %#v, want %#v", s["name"], "Contact User")
-	}
-	if s := messages[3]["sender"].(map[string]interface{}); s["name"] != nil {
-		t.Fatalf("unresolved bot sender should keep no name (id fallback), got %#v", s["name"])
-	}
-}
-
-// TestSystemMessageNeedsNoName documents that system messages — identified by
-// msg_type=="system", not by any sender id — need no display name: the producer
-// fills none and their sender carries no ou_ id, so they never hit the contact API
-// and are left without a name (no error). An empty sender name is normal here.
-func TestSystemMessageNeedsNoName(t *testing.T) {
-	failIfContactCalled := newBotConvertlibRuntime(t, convertlibRoundTripFunc(func(req *http.Request) (*http.Response, error) {
-		return nil, fmt.Errorf("system message must not trigger any API call: %s", req.URL.String())
+		users := make([]interface{}, 0, len(userIDs))
+		for _, raw := range userIDs {
+			id, _ := raw.(string)
+			users = append(users, map[string]interface{}{
+				"user_id": id,
+				"name":    "name-" + id,
+			})
+		}
+		return convertlibJSONResponse(200, map[string]interface{}{
+			"code": 0,
+			"data": map[string]interface{}{"users": users},
+		}), nil
 	}))
 
-	messages := []map[string]interface{}{
-		{"msg_type": "system", "sender": map[string]interface{}{"sender_type": "system"}},
-		{"msg_type": "system"}, // system message without a sender object at all
+	missingIDs := make([]string, 25)
+	for i := range missingIDs {
+		missingIDs[i] = fmt.Sprintf("ou_%02d", i)
 	}
+	nameMap := map[string]string{}
+	batchResolveByBasicContact(runtime, missingIDs, nameMap)
 
-	got := ResolveSenderNames(failIfContactCalled, messages, nil)
-	if len(got) != 0 {
-		t.Fatalf("system messages resolved names = %#v, want empty", got)
+	if want := []int{10, 10, 5}; !reflect.DeepEqual(batchSizes, want) {
+		t.Fatalf("batch sizes = %v, want %v", batchSizes, want)
 	}
-
-	AttachSenderNames(messages, got)
-	if s := messages[0]["sender"].(map[string]interface{}); s["name"] != nil {
-		t.Fatalf("system message sender should keep no name, got %#v", s["name"])
+	if len(nameMap) != 25 {
+		t.Fatalf("resolved name count = %d, want 25", len(nameMap))
+	}
+}
+
+func TestResolveSenderNamesAPIFailure(t *testing.T) {
+	runtime := newBotConvertlibRuntime(t, convertlibRoundTripFunc(func(req *http.Request) (*http.Response, error) {
+		switch {
+		case strings.Contains(req.URL.Path, "/open-apis/contact/v3/users/batch"):
+			return nil, fmt.Errorf("contact api failed")
+		default:
+			return nil, fmt.Errorf("unexpected request: %s", req.URL.String())
+		}
+	}))
+
+	got := ResolveSenderNames(runtime, []map[string]interface{}{
+		{"sender": map[string]interface{}{"sender_type": "user", "id": "ou_fail"}},
+	}, map[string]string{})
+	if got["ou_fail"] != "" {
+		t.Fatalf("failed sender resolution = %#v, want empty", got["ou_fail"])
 	}
 }

shortcuts/im/convert_lib/merge.go

@@ -209,10 +209,6 @@ func fetchMergeForwardSubMessages(messageID string, runtime *common.RuntimeConte
 	data, err := runtime.DoAPIJSONTyped(http.MethodGet, mergeForwardMessagesPath(messageID), larkcore.QueryParams{
 		"user_id_type":          []string{"open_id"},
 		"card_msg_content_type": []string{"raw_card_content"},
-		// Opt in to server-side sender names: without it, senders that appear
-		// only inside this merge_forward carry no sender_name and — since there
-		// is no contact/mention fallback — render as their raw id.
-		"with_sender_name": []string{"true"},
 	}, nil)
 	if err != nil {
 		return nil, err

shortcuts/im/convert_lib/merge_test.go

@@ -65,12 +65,6 @@ func TestFetchMergeForwardSubMessages(t *testing.T) {
 		runtime := newBotConvertlibRuntime(t, convertlibRoundTripFunc(func(req *http.Request) (*http.Response, error) {
 			switch {
 			case strings.Contains(req.URL.Path, "/open-apis/im/v1/messages/om_root"):
-				// Sub-item senders that appear only inside the merge_forward
-				// have no name unless we opt into server-side sender names;
-				// there is no contact/mention fallback anymore.
-				if got := req.URL.Query().Get("with_sender_name"); got != "true" {
-					t.Fatalf("with_sender_name = %q, want %q", got, "true")
-				}
 				return convertlibJSONResponse(200, map[string]interface{}{
 					"code": 0,
 					"data": map[string]interface{}{

shortcuts/im/convert_lib/thread.go

@@ -258,10 +258,6 @@ func fetchThreadReplies(runtime *common.RuntimeContext, threadID string, limit i
 		"sort_type":             []string{"ByCreateTimeAsc"},
 		"page_size":             []string{fmt.Sprint(limit)},
 		"card_msg_content_type": []string{"raw_card_content"},
-		// Opt in to server-side sender names: without it, reply senders that
-		// appear only inside this thread carry no sender_name and — since there
-		// is no contact/mention fallback — render as their raw id.
-		"with_sender_name": []string{"true"},
 	}, nil)
 	if err != nil {
 		return nil, false, fmt.Errorf("fetch thread replies for %s: %w", threadID, err) //nolint:forbidigo // best-effort internal thread fetch; never surfaced as a final shortcut error (ExpandThreadReplies is void)

shortcuts/im/convert_lib/thread_test.go

@@ -18,12 +18,6 @@ func TestExpandThreadReplies(t *testing.T) {
 			if req.URL.Query().Get("container_id") != "omt_1" {
 				return nil, fmt.Errorf("unexpected thread lookup: %s", req.URL.String())
 			}
-			// Reply senders that appear only inside the thread have no name
-			// unless we opt into server-side sender names; there is no
-			// contact/mention fallback anymore.
-			if got := req.URL.Query().Get("with_sender_name"); got != "true" {
-				t.Fatalf("with_sender_name = %q, want %q", got, "true")
-			}
 			return convertlibJSONResponse(200, map[string]interface{}{
 				"code": 0,
 				"data": map[string]interface{}{