docs(lark-doc): document poll block xml no-meego

Change-Id: I1f1e3fd17618d29e40f93b00258c8afd92516acf

.github/workflows/ci.yml

@@ -86,10 +86,8 @@ jobs:
         run: echo "QUALITY_GATE_CHANGED_FROM=$(bash scripts/resolve-changed-from.sh)" >> "$GITHUB_ENV"
       - name: Run golangci-lint
         run: go run github.com/golangci/golangci-lint/v2/cmd/golangci-lint@v2.1.6 run --new-from-rev="$QUALITY_GATE_CHANGED_FROM"
-      - name: Run source-contract lint guards (lintcheck)
+      - name: Run errs/ lint guards (lintcheck)
         run: go run -C lint . --changed-from "$QUALITY_GATE_CHANGED_FROM" ..
-      - name: Run lint module tests
-        run: go test -C lint ./... -count=1
 
   script-test:
     needs: fast-gate

CHANGELOG.md

@@ -2,77 +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
-
-- **drive**: Strengthen lark-drive high-risk write operations and read-only recognition boundaries. (#1801)
-- **slides**: add slides chart demo reference
-
-### Bug Fixes
-
-- register and consume --json shorthand for custom-format shortcuts (#1737)
-- **drive**: abort push on parent sibling limit (#1813)
-
-### Documentation
-
-- require native charts in slide planning
-- register knowledge organize workflow (#1828)
-
-## [v1.0.67] - 2026-07-08
-
-### Features
-
-- **mail**: add message modify and trash shortcuts (#1567)
-- support whiteboard file inputs in docs XML (#1784)
-- **vc**: refine meeting-events output and reaction forwarding (#1674)
-- **affordance**: usage guidance for shortcuts and per-command skills (#1793)
-
-### Bug Fixes
-
-- accept opaque wiki node tokens (#1789)
-- **apps**: make db --environment optional, auto-select branch server-side (#1735)
-- preserve original filename in multipart file upload (#1767)
-
-### Documentation
-
-- restore one-time authorization guidance in lark-apps skill (#1794)
-
-### Misc
-
-- e2e: harden CLI E2E retry, cleanup, and domain selection (#1709)
-
 ## [v1.0.66] - 2026-07-07
 
 ### Features
@@ -1469,9 +1398,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
 [v1.0.65]: https://github.com/larksuite/cli/releases/tag/v1.0.65
 [v1.0.64]: https://github.com/larksuite/cli/releases/tag/v1.0.64

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/build.go

@@ -25,10 +25,8 @@ import (
 	"github.com/larksuite/cli/internal/build"
 	"github.com/larksuite/cli/internal/cmdpolicy"
 	"github.com/larksuite/cli/internal/cmdutil"
-	"github.com/larksuite/cli/internal/core"
 	"github.com/larksuite/cli/internal/hook"
 	"github.com/larksuite/cli/internal/keychain"
-	"github.com/larksuite/cli/internal/registry"
 	"github.com/larksuite/cli/shortcuts"
 	"github.com/spf13/cobra"
 )
@@ -44,18 +42,6 @@ type buildConfig struct {
 	skipStrictMode bool
 	skipService    bool
 	serviceCatalog *apicatalog.Catalog
-	startupBrand   core.LarkBrand
-}
-
-// WithStartupBrand initializes the API registry with the given brand before
-// any command registration touches the runtime catalog. Without it the
-// registry's sync.Once locks onto the Feishu default at first catalog access,
-// long before the lazily-resolved config brand is known — see
-// ResolveStartupBrand for the caller-side resolution.
-func WithStartupBrand(brand core.LarkBrand) BuildOption {
-	return func(c *buildConfig) {
-		c.startupBrand = brand
-	}
 }
 
 // WithIO sets the IO streams for the CLI by wrapping raw reader/writers.
@@ -168,12 +154,6 @@ func buildInternal(ctx context.Context, inv cmdutil.InvocationContext, opts ...B
 		cfg.streams = cmdutil.SystemIO()
 	}
 
-	// Initialize the registry brand before anything touches the runtime
-	// catalog (its sync.Once would otherwise lock onto the Feishu default).
-	if cfg.startupBrand != "" {
-		registry.InitWithBrand(cfg.startupBrand)
-	}
-
 	f := cmdutil.NewDefault(cfg.streams, inv)
 	if cfg.keychain != nil {
 		f.Keychain = cfg.keychain

cmd/config/bind_test.go

@@ -916,6 +916,25 @@ func TestReadDotenv_ValueWithEquals(t *testing.T) {
 	}
 }
 
+func TestNormalizeBrand(t *testing.T) {
+	tests := []struct {
+		input string
+		want  string
+	}{
+		{"", "feishu"},
+		{"feishu", "feishu"},
+		{"lark", "lark"},
+		{"LARK", "lark"},
+		{" lark ", "lark"},
+		{"Lark", "lark"},
+	}
+	for _, tt := range tests {
+		if got := normalizeBrand(tt.input); got != tt.want {
+			t.Errorf("normalizeBrand(%q) = %q, want %q", tt.input, got, tt.want)
+		}
+	}
+}
+
 func TestResolveOpenClawConfigPath_Overrides(t *testing.T) {
 	t.Run("OPENCLAW_CONFIG_PATH wins", func(t *testing.T) {
 		custom := filepath.Join(t.TempDir(), "custom.json")

cmd/config/binder.go

@@ -205,7 +205,7 @@ func (b *openclawBinder) Build(appID string) (*core.AppConfig, error) {
 	return &core.AppConfig{
 		AppId:     selected.AppID,
 		AppSecret: stored,
-		Brand:     core.ParseBrand(selected.Brand),
+		Brand:     core.LarkBrand(normalizeBrand(selected.Brand)),
 	}, nil
 }
 
@@ -261,7 +261,7 @@ func (b *hermesBinder) Build(appID string) (*core.AppConfig, error) {
 	return &core.AppConfig{
 		AppId:     appID,
 		AppSecret: stored,
-		Brand:     core.ParseBrand(b.envMap["FEISHU_DOMAIN"]),
+		Brand:     core.LarkBrand(normalizeBrand(b.envMap["FEISHU_DOMAIN"])),
 	}, nil
 }
 
@@ -326,7 +326,7 @@ func (b *larkChannelBinder) Build(appID string) (*core.AppConfig, error) {
 	return &core.AppConfig{
 		AppId:     appID,
 		AppSecret: stored,
-		Brand:     core.ParseBrand(b.cfg.Accounts.App.Tenant),
+		Brand:     core.LarkBrand(normalizeBrand(b.cfg.Accounts.App.Tenant)),
 	}, nil
 }
 
@@ -350,6 +350,16 @@ func sourceDisplayName(source string) string {
 	}
 }
 
+// normalizeBrand applies .strip().lower() and defaults to "feishu".
+// Aligns with Hermes gateway/platforms/feishu.py:1119 behavior.
+func normalizeBrand(raw string) string {
+	s := strings.TrimSpace(strings.ToLower(raw))
+	if s == "" {
+		return "feishu"
+	}
+	return s
+}
+
 // resolveHermesEnvPath returns the path to Hermes's .env file.
 // Respects HERMES_HOME override; defaults to ~/.hermes/.env.
 //

cmd/config/init_interactive.go

@@ -5,9 +5,7 @@ package config
 
 import (
 	"context"
-	"errors"
 	"fmt"
-	"net"
 
 	"github.com/charmbracelet/huh"
 	"github.com/larksuite/cli/internal/build"
@@ -182,9 +180,9 @@ func runCreateAppFlow(ctx context.Context, f *cmdutil.Factory, brandOverride cor
 	// Use the shared proxy-plugin-aware transport so registration traffic is not
 	// a bypass of proxy plugin mode.
 	httpClient := transport.NewHTTPClient(0)
-	authResp, err := larkauth.RequestAppRegistration(ctx, httpClient, larkBrand, f.IOStreams.ErrOut)
+	authResp, err := larkauth.RequestAppRegistration(httpClient, larkBrand, f.IOStreams.ErrOut)
 	if err != nil {
-		return nil, classifyRegistrationBeginError(err)
+		return nil, errs.NewConfigError(errs.SubtypeInvalidClient, "app registration failed: %v", err).WithCause(err)
 	}
 
 	// Step 2: Build and display verification URL + QR code
@@ -210,17 +208,33 @@ func runCreateAppFlow(ctx context.Context, f *cmdutil.Factory, brandOverride cor
 		fmt.Fprintf(f.IOStreams.ErrOut, "  %s\n\n", verificationURL)
 		fmt.Fprintf(f.IOStreams.ErrOut, "%s\n", msg.WaitingForScanNonTTY)
 	}
-	// Step 4: Poll for credentials (brand discovery lives in internal/auth);
-	// this layer only classifies the terminal error and saves the result.
-	result, finalBrand, err := larkauth.RegisterAppWithDiscovery(ctx, httpClient, authResp, f.IOStreams.ErrOut)
+	result, err := larkauth.PollAppRegistration(ctx, httpClient, core.BrandFeishu, authResp.DeviceCode, authResp.Interval, authResp.ExpiresIn, f.IOStreams.ErrOut)
 	if err != nil {
-		return nil, classifyRegistrationError(err)
+		return nil, errs.NewAuthenticationError(errs.SubtypeUnknown, "%v", err).WithCause(err)
+	}
+
+	// Step 4: Handle Lark brand special case
+	// If tenant_brand=lark and no client_secret, retry with lark brand endpoint
+	if result.ClientSecret == "" && result.UserInfo != nil && result.UserInfo.TenantBrand == "lark" {
+		// fmt.Fprintf(f.IOStreams.ErrOut, "%s\n", msg.DetectedLarkTenant)
+		result, err = larkauth.PollAppRegistration(ctx, httpClient, core.BrandLark, authResp.DeviceCode, authResp.Interval, authResp.ExpiresIn, f.IOStreams.ErrOut)
+		if err != nil {
+			return nil, errs.NewNetworkError(errs.SubtypeNetworkTransport, "lark endpoint retry failed: %v", err).WithCause(err)
+		}
 	}
 
 	if result.ClientID == "" || result.ClientSecret == "" {
 		return nil, errs.NewConfigError(errs.SubtypeInvalidClient, "app registration succeeded but missing client_id or client_secret")
 	}
 
+	// Determine final brand from response
+	finalBrand := larkBrand
+	if result.UserInfo != nil && result.UserInfo.TenantBrand == "lark" {
+		finalBrand = core.BrandLark
+	} else if result.UserInfo != nil && result.UserInfo.TenantBrand == "feishu" {
+		finalBrand = core.BrandFeishu
+	}
+
 	fmt.Fprintln(f.IOStreams.ErrOut)
 	output.PrintSuccess(f.IOStreams.ErrOut, fmt.Sprintf(msg.AppCreated, result.ClientID))
 
@@ -231,40 +245,3 @@ func runCreateAppFlow(ctx context.Context, f *cmdutil.Factory, brandOverride cor
 		AppSecret: result.ClientSecret,
 	}, nil
 }
-
-// classifyRegistrationBeginError keeps transport/cancellation failures out of
-// the invalid-client category: the begin request sends no app credentials.
-func classifyRegistrationBeginError(err error) error {
-	switch {
-	case errors.Is(err, context.Canceled):
-		return errs.NewAuthenticationError(errs.SubtypeUnknown, "app registration cancelled").WithCause(err)
-	case errors.Is(err, context.DeadlineExceeded):
-		return errs.NewNetworkError(errs.SubtypeNetworkTimeout, "app registration begin timed out: %v", err).WithCause(err)
-	}
-	var netErr net.Error
-	if errors.As(err, &netErr) {
-		subtype := errs.SubtypeNetworkTransport
-		if netErr.Timeout() {
-			subtype = errs.SubtypeNetworkTimeout
-		}
-		return errs.NewNetworkError(subtype, "app registration begin failed: %v", err).WithCause(err)
-	}
-	return errs.NewAPIError(errs.SubtypeUnknown, "app registration begin failed: %v", err).WithCause(err)
-}
-
-// classifyRegistrationError maps registration terminal outcomes to typed
-// errors, preserving causes.
-func classifyRegistrationError(err error) error {
-	switch {
-	case errors.Is(err, larkauth.ErrRegistrationDenied):
-		return errs.NewAuthenticationError(errs.SubtypeUnknown, "%v", err).
-			WithHint("re-run `lark-cli config init --new` and approve the authorization request").
-			WithCause(err)
-	case errors.Is(err, larkauth.ErrRegistrationExpired), errors.Is(err, larkauth.ErrRegistrationTimedOut):
-		return errs.NewAuthenticationError(errs.SubtypeTokenExpired, "%v", err).
-			WithHint("re-run `lark-cli config init --new` and complete the scan before the code expires").
-			WithCause(err)
-	default:
-		return errs.NewAuthenticationError(errs.SubtypeUnknown, "app registration failed: %v", err).WithCause(err)
-	}
-}

cmd/config/init_interactive_test.go

@@ -1,70 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package config
-
-import (
-	"context"
-	"errors"
-	"net"
-	"testing"
-
-	"github.com/larksuite/cli/errs"
-	larkauth "github.com/larksuite/cli/internal/auth"
-)
-
-func assertRegistrationProblem(t *testing.T, got, cause error, category errs.Category, subtype errs.Subtype) *errs.Problem {
-	t.Helper()
-	p, ok := errs.ProblemOf(got)
-	if !ok {
-		t.Fatalf("error %T is not typed: %v", got, got)
-	}
-	if p.Category != category || p.Subtype != subtype {
-		t.Errorf("problem = (%q, %q), want (%q, %q)", p.Category, p.Subtype, category, subtype)
-	}
-	if !errors.Is(got, cause) {
-		t.Errorf("error %v does not preserve cause %v", got, cause)
-	}
-	return p
-}
-
-func TestClassifyRegistrationBeginError(t *testing.T) {
-	tests := []struct {
-		name     string
-		err      error
-		category errs.Category
-		subtype  errs.Subtype
-	}{
-		{"cancelled", context.Canceled, errs.CategoryAuthentication, errs.SubtypeUnknown},
-		{"deadline", context.DeadlineExceeded, errs.CategoryNetwork, errs.SubtypeNetworkTimeout},
-		{"transport", &net.DNSError{Err: "lookup failed", Name: "accounts.example"}, errs.CategoryNetwork, errs.SubtypeNetworkTransport},
-		{"response", errors.New("response not JSON"), errs.CategoryAPI, errs.SubtypeUnknown},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			assertRegistrationProblem(t, classifyRegistrationBeginError(tt.err), tt.err, tt.category, tt.subtype)
-		})
-	}
-}
-
-func TestClassifyRegistrationError(t *testing.T) {
-	tests := []struct {
-		name    string
-		err     error
-		subtype errs.Subtype
-		hint    bool
-	}{
-		{"denied", larkauth.ErrRegistrationDenied, errs.SubtypeUnknown, true},
-		{"expired", larkauth.ErrRegistrationExpired, errs.SubtypeTokenExpired, true},
-		{"timed-out", larkauth.ErrRegistrationTimedOut, errs.SubtypeTokenExpired, true},
-		{"cancelled", context.Canceled, errs.SubtypeUnknown, false},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			p := assertRegistrationProblem(t, classifyRegistrationError(tt.err), tt.err, errs.CategoryAuthentication, tt.subtype)
-			if (p.Hint != "") != tt.hint {
-				t.Errorf("hint = %q, want non-empty=%v", p.Hint, tt.hint)
-			}
-		})
-	}
-}

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

@@ -107,7 +107,6 @@ func Execute() int {
 		ctx, inv,
 		WithIO(os.Stdin, os.Stdout, os.Stderr),
 		HideProfile(isSingleAppMode()),
-		WithStartupBrand(ResolveStartupBrand(inv.Profile)),
 	)
 
 	// --- Notices (non-blocking) ---

cmd/startup_brand.go

@@ -1,28 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package cmd
-
-import (
-	"os"
-
-	"github.com/larksuite/cli/internal/core"
-	"github.com/larksuite/cli/internal/envvars"
-)
-
-// ResolveStartupBrand resolves the brand before the command tree is built, so
-// the registry's remote metadata overlay uses the configured brand from the
-// first catalog access. It mirrors the credential chain's brand precedence —
-// environment, then the active profile's raw config entry — without touching
-// the keychain (no secrets are needed to know the brand).
-func ResolveStartupBrand(profile string) core.LarkBrand {
-	if raw := os.Getenv(envvars.CliBrand); raw != "" {
-		return core.ParseBrand(raw)
-	}
-	if cfg, err := core.LoadMultiAppConfig(); err == nil {
-		if app := cfg.CurrentAppConfig(profile); app != nil {
-			return core.ParseBrand(string(app.Brand))
-		}
-	}
-	return core.BrandFeishu
-}

cmd/startup_brand_test.go

@@ -1,87 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package cmd
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/larksuite/cli/internal/cmdutil"
-	"github.com/larksuite/cli/internal/core"
-	"github.com/larksuite/cli/internal/registry"
-)
-
-func TestResolveStartupBrand_Precedence(t *testing.T) {
-	tmp := t.TempDir()
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", tmp)
-	t.Setenv("LARKSUITE_CLI_BRAND", "")
-	os.Unsetenv("LARKSUITE_CLI_BRAND")
-
-	// No config at all → default brand.
-	if got := ResolveStartupBrand(""); got != core.BrandFeishu {
-		t.Errorf("empty state brand = %q, want feishu", got)
-	}
-
-	// Raw config supplies the active profile's brand — no keychain involved.
-	raw := `{"currentApp":"feishu-app","apps":[` +
-		`{"name":"feishu-app","appId":"cli_f","appSecret":"test-secret","brand":"feishu","users":[]},` +
-		`{"name":"lark-prof","appId":"cli_l","appSecret":"test-secret","brand":"LARK","users":[]}]}`
-	if err := os.WriteFile(filepath.Join(tmp, "config.json"), []byte(raw), 0600); err != nil {
-		t.Fatal(err)
-	}
-	if got := ResolveStartupBrand(""); got != core.BrandFeishu {
-		t.Errorf("default profile brand = %q, want feishu", got)
-	}
-	if got := ResolveStartupBrand("lark-prof"); got != core.BrandLark {
-		t.Errorf("lark profile brand = %q, want lark (normalized)", got)
-	}
-
-	// Environment wins over the config file.
-	t.Setenv("LARKSUITE_CLI_BRAND", "lark")
-	if got := ResolveStartupBrand(""); got != core.BrandLark {
-		t.Errorf("env brand = %q, want lark", got)
-	}
-}
-
-// TestStartupBrandReachesRegistry_RealStartupOrder proves the fix for the
-// production startup sequence: building the command tree locks the registry's
-// sync.Once, so the brand must be injected before the first catalog access.
-// It runs in a subprocess because the registry is process-global.
-func TestStartupBrandReachesRegistry_RealStartupOrder(t *testing.T) {
-	if os.Getenv("GO_TEST_STARTUP_BRAND_HELPER") == "1" {
-		// Helper: replicate Execute()'s build wiring with a lark config.
-		buildInternal(
-			context.Background(), cmdutil.InvocationContext{},
-			WithIO(strings.NewReader(""), os.Stdout, os.Stderr),
-			WithStartupBrand(ResolveStartupBrand("")),
-		)
-		fmt.Printf("CONFIGURED_BRAND=%s\n", registry.ConfiguredBrand())
-		os.Exit(0)
-	}
-
-	tmp := t.TempDir()
-	raw := `{"apps":[{"appId":"cli_l","appSecret":"test-secret","brand":"lark","users":[]}]}`
-	if err := os.WriteFile(filepath.Join(tmp, "config.json"), []byte(raw), 0600); err != nil {
-		t.Fatal(err)
-	}
-
-	cmd := exec.Command(os.Args[0], "-test.run", "TestStartupBrandReachesRegistry_RealStartupOrder")
-	cmd.Env = append(os.Environ(),
-		"GO_TEST_STARTUP_BRAND_HELPER=1",
-		"LARKSUITE_CLI_CONFIG_DIR="+tmp,
-		"LARKSUITE_CLI_REMOTE_META=off", // no network during the subprocess build
-	)
-	out, err := cmd.CombinedOutput()
-	if err != nil {
-		t.Fatalf("subprocess failed: %v\n%s", err, out)
-	}
-	if !strings.Contains(string(out), "CONFIGURED_BRAND=lark") {
-		t.Errorf("registry brand after real startup order = %s, want lark", out)
-	}
-}

cmd/update/update.go

@@ -5,7 +5,6 @@ package cmdupdate
 
 import (
 	"fmt"
-	stdio "io"
 	"runtime"
 	"strings"
 
@@ -14,7 +13,6 @@ import (
 	"github.com/larksuite/cli/errs"
 	"github.com/larksuite/cli/internal/build"
 	"github.com/larksuite/cli/internal/cmdutil"
-	"github.com/larksuite/cli/internal/core"
 	"github.com/larksuite/cli/internal/output"
 	"github.com/larksuite/cli/internal/selfupdate"
 	"github.com/larksuite/cli/internal/skillscheck"
@@ -127,15 +125,13 @@ func updateRun(opts *UpdateOptions) error {
 	io := opts.Factory.IOStreams
 	cur := currentVersion()
 	updater := newUpdater()
-	// Brand only steers skills sync. updateRun skips that resolution in --check,
-	// where the Updater's zero-value brand retains the Feishu default.
+
 	if !opts.Check {
-		updater.Brand = resolveSkillsBrand(opts.Factory, io.ErrOut)
 		updater.CleanupStaleFiles()
 	}
 	output.PendingNotice = nil
 
-	// 1. Fetch latest version.
+	// 1. Fetch latest version
 	latest, err := fetchLatest()
 	if err != nil {
 		return reportError(opts, io, "network",
@@ -157,7 +153,7 @@ func updateRun(opts *UpdateOptions) error {
 		return reportAlreadyUpToDate(opts, io, cur, latest, skillsResult, opts.Check)
 	}
 
-	// 4. Detect installation method.
+	// 4. Detect installation method
 	detect := updater.DetectInstallMethod()
 
 	// 5. --check
@@ -172,22 +168,6 @@ func updateRun(opts *UpdateOptions) error {
 	return doAutoUpdate(opts, io, cur, latest, detect, updater)
 }
 
-// resolveSkillsBrand returns the skills-source brand: resolved config first,
-// then the active profile's raw config entry (the brand is not a secret; a
-// locked keychain must not flip the source), then the default with a notice.
-func resolveSkillsBrand(f *cmdutil.Factory, errOut stdio.Writer) core.LarkBrand {
-	if cfg, err := f.Config(); err == nil && cfg != nil {
-		return core.ParseBrand(string(cfg.Brand))
-	}
-	if raw, err := core.LoadMultiAppConfig(); err == nil {
-		if app := raw.CurrentAppConfig(f.Invocation.Profile); app != nil {
-			return core.ParseBrand(string(app.Brand))
-		}
-	}
-	fmt.Fprintf(errOut, "note: could not resolve the configured brand; syncing skills from the default source\n")
-	return core.BrandFeishu
-}
-
 // --- Output helpers ---
 
 // reportError emits the failure on the requested surface: JSON mode prints the

cmd/update/update_test.go

@@ -9,9 +9,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"os"
 	"os/exec"
-	"path/filepath"
 	"strings"
 	"testing"
 	"time"
@@ -1733,64 +1731,3 @@ func containsString(values []string, target string) bool {
 	}
 	return false
 }
-
-func TestResolveSkillsBrand_LayeredFallback(t *testing.T) {
-	// Layer 1: resolved config wins.
-	var errBuf bytes.Buffer
-	f := &cmdutil.Factory{Config: func() (*core.CliConfig, error) {
-		return &core.CliConfig{Brand: core.LarkBrand(" LARK ")}, nil
-	}}
-	if got := resolveSkillsBrand(f, &errBuf); got != core.BrandLark {
-		t.Errorf("resolved-config brand = %q, want lark", got)
-	}
-
-	// Layer 2: credential resolution fails, raw config file still supplies the
-	// brand (a locked keychain must not flip a Lark profile to Feishu).
-	tmp := t.TempDir()
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", tmp)
-	raw := `{"apps":[{"appId":"cli_x","appSecret":"test-secret","brand":"lark","users":[]}]}`
-	if err := os.WriteFile(filepath.Join(tmp, "config.json"), []byte(raw), 0600); err != nil {
-		t.Fatal(err)
-	}
-	f = &cmdutil.Factory{Config: func() (*core.CliConfig, error) { return nil, errors.New("keychain locked") }}
-	errBuf.Reset()
-	if got := resolveSkillsBrand(f, &errBuf); got != core.BrandLark {
-		t.Errorf("raw-config brand = %q, want lark", got)
-	}
-	if errBuf.Len() != 0 {
-		t.Errorf("unexpected notice when raw config supplied the brand: %q", errBuf.String())
-	}
-
-	// Layer 3: nothing readable → default brand with a notice.
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	errBuf.Reset()
-	if got := resolveSkillsBrand(f, &errBuf); got != core.BrandFeishu {
-		t.Errorf("fallback brand = %q, want feishu", got)
-	}
-	if !strings.Contains(errBuf.String(), "could not resolve the configured brand") {
-		t.Errorf("expected fallback notice, got %q", errBuf.String())
-	}
-}
-
-// The raw-config fallback must read the active profile, not the default one.
-func TestResolveSkillsBrand_RespectsActiveProfile(t *testing.T) {
-	tmp := t.TempDir()
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", tmp)
-	raw := `{"currentApp":"feishu-app","apps":[` +
-		`{"name":"feishu-app","appId":"cli_f","appSecret":"test-secret","brand":"feishu","users":[]},` +
-		`{"name":"lark-prof","appId":"cli_l","appSecret":"test-secret","brand":"lark","users":[]}]}`
-	if err := os.WriteFile(filepath.Join(tmp, "config.json"), []byte(raw), 0600); err != nil {
-		t.Fatal(err)
-	}
-	f := &cmdutil.Factory{
-		Invocation: cmdutil.InvocationContext{Profile: "lark-prof"},
-		Config:     func() (*core.CliConfig, error) { return nil, errors.New("keychain locked") },
-	}
-	var errBuf bytes.Buffer
-	if got := resolveSkillsBrand(f, &errBuf); got != core.BrandLark {
-		t.Errorf("brand = %q, want lark (the active profile's brand)", got)
-	}
-	if errBuf.Len() != 0 {
-		t.Errorf("unexpected notice: %q", errBuf.String())
-	}
-}

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/credential/env/env.go

@@ -9,7 +9,6 @@ import (
 	"os"
 
 	"github.com/larksuite/cli/extension/credential"
-	"github.com/larksuite/cli/internal/core"
 	"github.com/larksuite/cli/internal/envvars"
 )
 
@@ -42,7 +41,10 @@ func (p *Provider) ResolveAccount(ctx context.Context) (*credential.Account, err
 			Reason:   envvars.CliAppID + " is set but no app secret or access token is available",
 		}
 	}
-	brand := credential.Brand(core.ParseBrand(os.Getenv(envvars.CliBrand)))
+	brand := credential.Brand(os.Getenv(envvars.CliBrand))
+	if brand == "" {
+		brand = credential.BrandFeishu
+	}
 	acct := &credential.Account{AppID: appID, AppSecret: appSecret, Brand: brand}
 
 	switch id := credential.Identity(os.Getenv(envvars.CliDefaultAs)); id {

extension/credential/env/env_test.go

@@ -22,13 +22,13 @@ func TestProvider_Name(t *testing.T) {
 func TestResolveAccount_BothSet(t *testing.T) {
 	t.Setenv(envvars.CliAppID, "cli_test")
 	t.Setenv(envvars.CliAppSecret, "secret_test")
-	t.Setenv(envvars.CliBrand, " LARK ")
+	t.Setenv(envvars.CliBrand, "feishu")
 
 	acct, err := (&Provider{}).ResolveAccount(context.Background())
 	if err != nil {
 		t.Fatal(err)
 	}
-	if acct.AppID != "cli_test" || acct.AppSecret != "secret_test" || acct.Brand != "lark" {
+	if acct.AppID != "cli_test" || acct.AppSecret != "secret_test" || acct.Brand != "feishu" {
 		t.Errorf("unexpected: %+v", acct)
 	}
 }

extension/credential/sidecar/provider.go

@@ -16,7 +16,6 @@ import (
 	"os"
 
 	"github.com/larksuite/cli/extension/credential"
-	"github.com/larksuite/cli/internal/core"
 	"github.com/larksuite/cli/internal/envvars"
 	"github.com/larksuite/cli/sidecar"
 )
@@ -59,7 +58,10 @@ func (p *Provider) ResolveAccount(ctx context.Context) (*credential.Account, err
 		}
 	}
 
-	brand := credential.Brand(core.ParseBrand(os.Getenv(envvars.CliBrand)))
+	brand := credential.Brand(os.Getenv(envvars.CliBrand))
+	if brand == "" {
+		brand = credential.BrandFeishu
+	}
 
 	acct := &credential.Account{
 		AppID:     appID,

extension/credential/sidecar/provider_test.go

@@ -56,7 +56,7 @@ func TestResolveAccount_Active(t *testing.T) {
 	setEnv(t, envvars.CliAuthProxy, "http://127.0.0.1:16384")
 	setEnv(t, envvars.CliProxyKey, "test-key")
 	setEnv(t, envvars.CliAppID, "cli_test123")
-	setEnv(t, envvars.CliBrand, " LARK ")
+	setEnv(t, envvars.CliBrand, "lark")
 	unsetEnv(t, envvars.CliDefaultAs)
 	unsetEnv(t, envvars.CliStrictMode)
 

internal/auth/app_registration.go

@@ -6,7 +6,6 @@ package auth
 import (
 	"context"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"io"
 	"net/http"
@@ -17,46 +16,6 @@ import (
 	"github.com/larksuite/cli/internal/core"
 )
 
-// Terminal registration outcomes, exposed for typed classification by callers.
-var (
-	ErrRegistrationDenied   = errors.New("app registration denied by user")
-	ErrRegistrationExpired  = errors.New("device code expired, please try again")
-	ErrRegistrationTimedOut = errors.New("app registration timed out, please try again")
-)
-
-// Protocol defaults, mirroring the official SDK registration flow.
-const (
-	registrationBootstrapBrand = core.BrandFeishu
-	defaultPollIntervalSeconds = 5
-	defaultExpireInSeconds     = 600
-	beginRequestTimeout        = 30 * time.Second
-	maxPollIntervalSeconds     = 60
-)
-
-// normalizedInterval clamps a non-positive poll interval to the protocol default.
-func normalizedInterval(v int) int {
-	if v <= 0 {
-		return defaultPollIntervalSeconds
-	}
-	return v
-}
-
-// normalizedExpireIn clamps a non-positive expiry budget to the protocol default.
-func normalizedExpireIn(v int) int {
-	if v <= 0 {
-		return defaultExpireInSeconds
-	}
-	return v
-}
-
-// registrationContextError maps a done context to its terminal reason, keeping the cause.
-func registrationContextError(ctx context.Context) error {
-	if errors.Is(ctx.Err(), context.DeadlineExceeded) {
-		return fmt.Errorf("%w: %w", ErrRegistrationTimedOut, ctx.Err())
-	}
-	return fmt.Errorf("app registration cancelled: %w", ctx.Err())
-}
-
 // AppRegistrationResponse is the response from the app registration begin endpoint.
 type AppRegistrationResponse struct {
 	DeviceCode              string
@@ -80,24 +39,15 @@ type AppRegUserInfo struct {
 	TenantBrand string // "feishu" or "lark"
 }
 
-// appRegistrationEndpoint returns the brand's accounts registration endpoint.
-func appRegistrationEndpoint(brand core.LarkBrand) string {
-	return core.ResolveEndpoints(brand).Accounts + PathAppRegistration
-}
-
-// RequestAppRegistration initiates the device flow. The registration protocol
-// always bootstraps on Feishu; brand selects the user-facing verification host.
-// The request is bounded by ctx and a begin timeout.
-func RequestAppRegistration(ctx context.Context, httpClient *http.Client, brand core.LarkBrand, errOut io.Writer) (*AppRegistrationResponse, error) {
+// RequestAppRegistration initiates the app registration device flow.
+func RequestAppRegistration(httpClient *http.Client, brand core.LarkBrand, errOut io.Writer) (*AppRegistrationResponse, error) {
 	if errOut == nil {
 		errOut = io.Discard
 	}
 
-	ctx, cancel := context.WithTimeout(ctx, beginRequestTimeout)
-	defer cancel()
-
 	ep := core.ResolveEndpoints(brand)
-	endpoint := appRegistrationEndpoint(registrationBootstrapBrand)
+	regEp := core.ResolveEndpoints(core.BrandFeishu) // registration begin always uses feishu
+	endpoint := regEp.Accounts + PathAppRegistration
 
 	form := url.Values{}
 	form.Set("action", "begin")
@@ -105,7 +55,7 @@ func RequestAppRegistration(ctx context.Context, httpClient *http.Client, brand
 	form.Set("auth_method", "client_secret")
 	form.Set("request_user_info", "open_id tenant_brand")
 
-	req, err := http.NewRequestWithContext(ctx, "POST", endpoint, strings.NewReader(form.Encode()))
+	req, err := http.NewRequest("POST", endpoint, strings.NewReader(form.Encode()))
 	if err != nil {
 		return nil, err
 	}
@@ -120,7 +70,7 @@ func RequestAppRegistration(ctx context.Context, httpClient *http.Client, brand
 
 	body, err := io.ReadAll(resp.Body)
 	if err != nil {
-		return nil, fmt.Errorf("app registration failed: read body: %w", err)
+		return nil, fmt.Errorf("app registration failed: read body: %v", err)
 	}
 
 	var data map[string]interface{}
@@ -140,26 +90,15 @@ func RequestAppRegistration(ctx context.Context, httpClient *http.Client, brand
 		return nil, fmt.Errorf("app registration failed: %s", msg)
 	}
 
-	// The protocol field is expire_in; accept the legacy expires_in spelling,
-	// then normalize to protocol defaults.
-	expiresIn := getInt(data, "expire_in", 0)
-	if expiresIn <= 0 {
-		expiresIn = getInt(data, "expires_in", 0)
-	}
-	expiresIn = normalizedExpireIn(expiresIn)
-	interval := normalizedInterval(getInt(data, "interval", 0))
-
-	deviceCode := getStr(data, "device_code")
-	if deviceCode == "" {
-		return nil, fmt.Errorf("app registration failed: response missing device_code")
-	}
+	expiresIn := getInt(data, "expires_in", 300)
+	interval := getInt(data, "interval", 5)
 
 	userCode := getStr(data, "user_code")
 	verificationUri := getStr(data, "verification_uri")
 	verificationUriComplete := fmt.Sprintf("%s/page/cli?user_code=%s", ep.Open, userCode)
 
 	return &AppRegistrationResponse{
-		DeviceCode:              deviceCode,
+		DeviceCode:              getStr(data, "device_code"),
 		UserCode:                getStr(data, "user_code"),
 		VerificationUri:         verificationUri,
 		VerificationUriComplete: verificationUriComplete,
@@ -179,97 +118,72 @@ func BuildVerificationURL(baseURL, cliVersion string) string {
 		"&from=cli"
 }
 
-// pollOnce performs one ctx-bound poll request and decodes the payload.
-func pollOnce(ctx context.Context, httpClient *http.Client, brand core.LarkBrand, deviceCode string) (map[string]interface{}, error) {
-	form := url.Values{}
-	form.Set("action", "poll")
-	form.Set("device_code", deviceCode)
-
-	req, err := http.NewRequestWithContext(ctx, "POST", appRegistrationEndpoint(brand), strings.NewReader(form.Encode()))
-	if err != nil {
-		return nil, fmt.Errorf("poll request: %w", err)
-	}
-	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-
-	resp, err := httpClient.Do(req)
-	if err != nil {
-		return nil, fmt.Errorf("poll network error: %w", err)
-	}
-	defer resp.Body.Close()
-	logHTTPResponse(resp)
-
-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return nil, fmt.Errorf("poll read error: %w", err)
-	}
-	var data map[string]interface{}
-	if err := json.Unmarshal(body, &data); err != nil {
-		return nil, fmt.Errorf("poll parse error: %w", err)
-	}
-	return data, nil
-}
-
-// RegisterAppWithDiscovery polls for credentials, mirroring the official SDK
-// flow: the first poll and the (at most one) cross-brand switch are immediate,
-// non-error responses without complete credentials keep polling, and one
-// deadline from the begin expiry bounds all waits and in-flight requests.
-// The returned brand is the one the credentials were issued on.
-func RegisterAppWithDiscovery(ctx context.Context, httpClient *http.Client, resp *AppRegistrationResponse, errOut io.Writer) (*AppRegistrationResult, core.LarkBrand, error) {
+// PollAppRegistration polls the app registration endpoint until the app is created or the flow times out.
+// If the result has ClientSecret == "" and UserInfo.TenantBrand == "lark", the caller should
+// retry with BrandLark to get the secret from accounts.larksuite.com.
+func PollAppRegistration(ctx context.Context, httpClient *http.Client, brand core.LarkBrand, deviceCode string, interval, expiresIn int, errOut io.Writer) (*AppRegistrationResult, error) {
 	if errOut == nil {
 		errOut = io.Discard
 	}
 
-	// Interval and expiry arrive normalized from begin-response parsing
-	// (normalizedInterval floors them there); the loop trusts them as-is.
-	interval := resp.Interval
-	ctx, cancel := context.WithDeadline(ctx,
-		time.Now().Add(time.Duration(resp.ExpiresIn)*time.Second))
-	defer cancel()
+	const maxPollInterval = 60
+	const maxPollAttempts = 200
 
-	currentBrand := registrationBootstrapBrand
-	effectiveBrand := currentBrand
-	switched := false
-	waitBeforePoll := false
+	ep := core.ResolveEndpoints(brand)
+	endpoint := ep.Accounts + PathAppRegistration
+	deadline := time.Now().Add(time.Duration(expiresIn) * time.Second)
+	currentInterval := interval
+	attempts := 0
 
-	for {
-		if waitBeforePoll {
-			select {
-			case <-time.After(time.Duration(interval) * time.Second):
-			case <-ctx.Done():
-				return nil, effectiveBrand, registrationContextError(ctx)
-			}
-		}
-		waitBeforePoll = true
+	for time.Now().Before(deadline) && attempts < maxPollAttempts {
+		attempts++
 		if ctx.Err() != nil {
-			return nil, effectiveBrand, registrationContextError(ctx)
+			return nil, fmt.Errorf("polling was cancelled")
 		}
 
-		data, err := pollOnce(ctx, httpClient, currentBrand, resp.DeviceCode)
+		select {
+		case <-time.After(time.Duration(currentInterval) * time.Second):
+		case <-ctx.Done():
+			return nil, fmt.Errorf("polling was cancelled")
+		}
+
+		form := url.Values{}
+		form.Set("action", "poll")
+		form.Set("device_code", deviceCode)
+
+		req, err := http.NewRequest("POST", endpoint, strings.NewReader(form.Encode()))
 		if err != nil {
-			fmt.Fprintf(errOut, "[lark-cli] [WARN] app-registration: %v\n", err)
-			interval = minInt(interval+1, maxPollIntervalSeconds)
+			continue
+		}
+		req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+
+		resp, err := httpClient.Do(req)
+		if err != nil {
+			fmt.Fprintf(errOut, "[lark-cli] [WARN] app-registration: poll network error: %v\n", err)
+			currentInterval = minInt(currentInterval+1, maxPollInterval)
+			continue
+		}
+		logHTTPResponse(resp)
+
+		body, err := io.ReadAll(resp.Body)
+		resp.Body.Close()
+		if err != nil {
+			fmt.Fprintf(errOut, "[lark-cli] [WARN] app-registration: poll read error: %v\n", err)
+			currentInterval = minInt(currentInterval+1, maxPollInterval)
 			continue
 		}
 
-		// A cross-brand tenant report switches the polled domain (once,
-		// immediately) regardless of the accompanying status — the signal can
-		// arrive alongside authorization_pending, mirroring the official SDK.
-		if !switched {
-			if userInfoRaw, ok := data["user_info"].(map[string]interface{}); ok {
-				if tb := getStr(userInfoRaw, "tenant_brand"); tb != "" {
-					if actual := core.ParseBrand(tb); actual != currentBrand {
-						currentBrand = actual
-						effectiveBrand = actual
-						switched = true
-						waitBeforePoll = false
-						continue
-					}
-				}
-			}
+		var data map[string]interface{}
+		if err := json.Unmarshal(body, &data); err != nil {
+			fmt.Fprintf(errOut, "[lark-cli] [WARN] app-registration: poll parse error: %v\n", err)
+			currentInterval = minInt(currentInterval+1, maxPollInterval)
+			continue
 		}
 
 		errStr := getStr(data, "error")
-		if errStr == "" {
+
+		// Success: client_id present
+		if errStr == "" && getStr(data, "client_id") != "" {
 			result := &AppRegistrationResult{
 				ClientID:     getStr(data, "client_id"),
 				ClientSecret: getStr(data, "client_secret"),
@@ -280,37 +194,34 @@ func RegisterAppWithDiscovery(ctx context.Context, httpClient *http.Client, resp
 					TenantBrand: getStr(userInfoRaw, "tenant_brand"),
 				}
 			}
-
-			if result.ClientID != "" && result.ClientSecret != "" {
-				// The issuing domain is authoritative; a contradictory final
-				// tenant report is a protocol violation, not a brand override.
-				if result.UserInfo != nil && result.UserInfo.TenantBrand != "" &&
-					core.ParseBrand(result.UserInfo.TenantBrand) != effectiveBrand {
-					return nil, effectiveBrand, fmt.Errorf("app registration returned credentials with a contradictory tenant brand %q", result.UserInfo.TenantBrand)
-				}
-				return result, effectiveBrand, nil
-			}
-			// Incomplete credentials without an error: keep polling.
-			continue
+			return result, nil
 		}
 
 		switch errStr {
 		case "authorization_pending":
 			continue
 		case "slow_down":
-			interval = minInt(interval+5, maxPollIntervalSeconds)
-			fmt.Fprintf(errOut, "[lark-cli] app-registration: slow_down, interval increased to %ds\n", interval)
+			currentInterval = minInt(currentInterval+5, maxPollInterval)
+			fmt.Fprintf(errOut, "[lark-cli] app-registration: slow_down, interval increased to %ds\n", currentInterval)
 			continue
 		case "access_denied":
-			return nil, effectiveBrand, ErrRegistrationDenied
+			return nil, fmt.Errorf("app registration denied by user")
 		case "expired_token", "invalid_grant":
-			return nil, effectiveBrand, ErrRegistrationExpired
+			return nil, fmt.Errorf("device code expired, please try again")
 		}
 
 		desc := getStr(data, "error_description")
 		if desc == "" {
 			desc = errStr
 		}
-		return nil, effectiveBrand, fmt.Errorf("app registration failed: %s", desc)
+		if desc == "" {
+			desc = "Unknown error"
+		}
+		return nil, fmt.Errorf("app registration failed: %s", desc)
 	}
+
+	if attempts >= maxPollAttempts {
+		fmt.Fprintf(errOut, "[lark-cli] [WARN] app-registration: max poll attempts (%d) reached\n", maxPollAttempts)
+	}
+	return nil, fmt.Errorf("app registration timed out, please try again")
 }

internal/auth/app_registration_test.go

@@ -4,28 +4,11 @@
 package auth
 
 import (
-	"context"
-	"errors"
-	"io"
-	"net/http"
-	"strings"
 	"testing"
-	"time"
 
-	"github.com/larksuite/cli/internal/core"
 	"github.com/smartystreets/goconvey/convey"
 )
 
-// jsonResponse builds a canned registration response (transport fakes reuse
-// roundTripFunc from device_flow_test.go).
-func jsonResponse(body string) *http.Response {
-	return &http.Response{
-		StatusCode: http.StatusOK,
-		Body:       io.NopCloser(strings.NewReader(body)),
-		Header:     make(http.Header),
-	}
-}
-
 // Test_BuildVerificationURL verifies that tracking parameters are correctly appended.
 func Test_BuildVerificationURL(t *testing.T) {
 	t.Run("URL不含问号则添加?分隔符", func(t *testing.T) {
@@ -48,358 +31,3 @@ func Test_BuildVerificationURL(t *testing.T) {
 		})
 	})
 }
-
-func TestAppRegistrationEndpoint(t *testing.T) {
-	cases := []struct {
-		brand core.LarkBrand
-		want  string
-	}{
-		{core.BrandFeishu, "https://accounts.feishu.cn" + PathAppRegistration},
-		{core.BrandLark, "https://accounts.larksuite.com" + PathAppRegistration},
-	}
-	for _, c := range cases {
-		if got := appRegistrationEndpoint(c.brand); got != c.want {
-			t.Errorf("brand %q: endpoint = %q, want %q", c.brand, got, c.want)
-		}
-	}
-}
-
-func TestRequestAppRegistration_UsesFeishuBootstrapAndConfiguredVerificationBrand(t *testing.T) {
-	cases := []struct {
-		brand            core.LarkBrand
-		verificationHost string
-	}{
-		{core.BrandFeishu, "open.feishu.cn"},
-		{core.BrandLark, "open.larksuite.com"},
-	}
-	for _, c := range cases {
-		t.Run(string(c.brand), func(t *testing.T) {
-			client := &http.Client{Transport: roundTripFunc(func(r *http.Request) (*http.Response, error) {
-				if got, want := r.URL.Host, "accounts.feishu.cn"; got != want {
-					t.Errorf("begin host = %q, want bootstrap host %q", got, want)
-				}
-				return jsonResponse(`{"device_code":"d","user_code":"TEST-CODE","expire_in":60,"interval":5}`), nil
-			})}
-			resp, err := RequestAppRegistration(context.Background(), client, c.brand, io.Discard)
-			if err != nil {
-				t.Fatalf("RequestAppRegistration(%q) error = %v", c.brand, err)
-			}
-			if !strings.HasPrefix(resp.VerificationUriComplete, "https://"+c.verificationHost+"/page/cli?") {
-				t.Errorf("verification URL = %q, want host %q", resp.VerificationUriComplete, c.verificationHost)
-			}
-		})
-	}
-}
-
-// Full Lark routing contract: Lark selects the Lark verification page, while
-// registration bootstraps on Feishu and switches only after the tenant signal.
-// The Lark credential response omits user_info, so the effective domain must
-// still determine the saved brand.
-func TestRegisterAppWithDiscovery_LarkFlowUsesProtocolBootstrap(t *testing.T) {
-	var calls []string
-	client := &http.Client{Transport: roundTripFunc(func(r *http.Request) (*http.Response, error) {
-		if err := r.ParseForm(); err != nil {
-			t.Fatalf("parse form: %v", err)
-		}
-		action := r.Form.Get("action")
-		calls = append(calls, action+"@"+r.URL.Host)
-		if action == "begin" {
-			return jsonResponse(`{"device_code":"device","user_code":"TEST-CODE","expire_in":60,"interval":0}`), nil
-		}
-		switch r.URL.Host {
-		case "accounts.feishu.cn":
-			return jsonResponse(`{"user_info":{"open_id":"ou_x","tenant_brand":"lark"}}`), nil
-		case "accounts.larksuite.com":
-			return jsonResponse(`{"client_id":"cli_x","client_secret":"test-secret"}`), nil
-		}
-		t.Errorf("unexpected host polled: %s", r.URL.Host)
-		return jsonResponse(`{}`), nil
-	})}
-	resp, err := RequestAppRegistration(context.Background(), client, core.BrandLark, io.Discard)
-	if err != nil {
-		t.Fatalf("RequestAppRegistration error = %v", err)
-	}
-	if got, want := resp.VerificationUriComplete, "https://open.larksuite.com/page/cli?user_code=TEST-CODE"; got != want {
-		t.Errorf("verification URL = %q, want %q", got, want)
-	}
-
-	result, finalBrand, err := RegisterAppWithDiscovery(context.Background(), client, resp, io.Discard)
-	if err != nil {
-		t.Fatalf("RegisterAppWithDiscovery error = %v, want nil", err)
-	}
-	if finalBrand != core.BrandLark {
-		t.Errorf("finalBrand = %q, want %q (credentials were issued on the lark domain)", finalBrand, core.BrandLark)
-	}
-	if result.ClientID != "cli_x" || result.ClientSecret != "test-secret" {
-		t.Errorf("credentials = (%q, %q), want (cli_x, test-secret)", result.ClientID, result.ClientSecret)
-	}
-	want := []string{"begin@accounts.feishu.cn", "poll@accounts.feishu.cn", "poll@accounts.larksuite.com"}
-	if len(calls) != len(want) {
-		t.Fatalf("calls = %v, want %v", calls, want)
-	}
-	for i := range want {
-		if calls[i] != want[i] {
-			t.Errorf("calls = %v, want %v", calls, want)
-			break
-		}
-	}
-}
-
-// Plain path: the bootstrap domain can return complete Feishu credentials in
-// one poll, even when user_info is absent.
-func TestRegisterAppWithDiscovery_BootstrapBrandSinglePoll(t *testing.T) {
-	polls := 0
-	client := &http.Client{Transport: roundTripFunc(func(r *http.Request) (*http.Response, error) {
-		polls++
-		if got, want := r.URL.Host, "accounts.feishu.cn"; got != want {
-			t.Errorf("poll host = %q, want %q", got, want)
-		}
-		return jsonResponse(`{"client_id":"cli_x","client_secret":"test-secret"}`), nil
-	})}
-	resp := &AppRegistrationResponse{DeviceCode: "device", Interval: 0, ExpiresIn: 5}
-
-	_, finalBrand, err := RegisterAppWithDiscovery(context.Background(), client, resp, io.Discard)
-	if err != nil {
-		t.Fatalf("RegisterAppWithDiscovery error = %v, want nil", err)
-	}
-	if finalBrand != core.BrandFeishu {
-		t.Errorf("finalBrand = %q, want %q", finalBrand, core.BrandFeishu)
-	}
-	if polls != 1 {
-		t.Errorf("polls = %d, want 1", polls)
-	}
-}
-
-// The discovery deadline must cancel in-flight requests: the fake transport
-// hangs until the request context is done.
-func TestRegisterAppWithDiscovery_DeadlineBoundsInFlightRequests(t *testing.T) {
-	client := &http.Client{Transport: roundTripFunc(func(r *http.Request) (*http.Response, error) {
-		<-r.Context().Done()
-		return nil, r.Context().Err()
-	})}
-	resp := &AppRegistrationResponse{DeviceCode: "device", Interval: 0, ExpiresIn: 1}
-
-	start := time.Now()
-	_, _, err := RegisterAppWithDiscovery(context.Background(), client, resp, io.Discard)
-	if err == nil {
-		t.Fatal("expected timeout error, got nil")
-	}
-	if !strings.Contains(err.Error(), "timed out") {
-		t.Errorf("error = %v, want a timed-out terminal reason", err)
-	}
-	if elapsed := time.Since(start); elapsed > 3*time.Second {
-		t.Errorf("discovery not bounded by its deadline: took %v", elapsed)
-	}
-}
-
-// Empty payloads and incomplete same-brand responses are not terminal.
-func TestRegisterAppWithDiscovery_PollsUntilCredentials(t *testing.T) {
-	responses := []string{
-		`{}`,
-		`{"client_id":"cli_x","user_info":{"open_id":"ou_x","tenant_brand":"feishu"}}`,
-		`{"client_id":"cli_x","client_secret":"test-secret","user_info":{"open_id":"ou_x","tenant_brand":"feishu"}}`,
-	}
-	polls := 0
-	client := &http.Client{Transport: roundTripFunc(func(r *http.Request) (*http.Response, error) {
-		body := responses[polls]
-		polls++
-		return jsonResponse(body), nil
-	})}
-	resp := &AppRegistrationResponse{DeviceCode: "device", Interval: 0, ExpiresIn: 5}
-
-	result, finalBrand, err := RegisterAppWithDiscovery(context.Background(), client, resp, io.Discard)
-	if err != nil {
-		t.Fatalf("RegisterAppWithDiscovery error = %v, want nil", err)
-	}
-	if polls != 3 {
-		t.Errorf("polls = %d, want 3", polls)
-	}
-	if result.ClientSecret != "test-secret" || finalBrand != core.BrandFeishu {
-		t.Errorf("result = (%q, %q), want (test-secret, feishu)", result.ClientSecret, finalBrand)
-	}
-}
-
-// Neither the first poll nor the cross-brand switch waits out the interval
-// (a 5s interval would blow the elapsed bound).
-func TestRegisterAppWithDiscovery_ImmediateFirstPollAndSwitch(t *testing.T) {
-	var polledHosts []string
-	client := &http.Client{Transport: roundTripFunc(func(r *http.Request) (*http.Response, error) {
-		polledHosts = append(polledHosts, r.URL.Host)
-		if r.URL.Host == "accounts.feishu.cn" {
-			return jsonResponse(`{"user_info":{"open_id":"ou_x","tenant_brand":"lark"}}`), nil
-		}
-		return jsonResponse(`{"client_id":"cli_x","client_secret":"test-secret"}`), nil
-	})}
-	resp := &AppRegistrationResponse{DeviceCode: "device", Interval: 5, ExpiresIn: 60}
-
-	start := time.Now()
-	result, finalBrand, err := RegisterAppWithDiscovery(context.Background(), client, resp, io.Discard)
-	if err != nil {
-		t.Fatalf("RegisterAppWithDiscovery error = %v, want nil", err)
-	}
-	if elapsed := time.Since(start); elapsed > 2*time.Second {
-		t.Errorf("discovery waited an interval somewhere: took %v", elapsed)
-	}
-	if finalBrand != core.BrandLark || result.ClientSecret != "test-secret" {
-		t.Errorf("result = (%q, %q), want (test-secret, lark)", result.ClientSecret, finalBrand)
-	}
-	want := []string{"accounts.feishu.cn", "accounts.larksuite.com"}
-	if len(polledHosts) != 2 || polledHosts[0] != want[0] || polledHosts[1] != want[1] {
-		t.Errorf("polled hosts = %v, want %v", polledHosts, want)
-	}
-}
-
-// Denial and expiry map to sentinels; cancellation preserves its cause.
-func TestRegisterAppWithDiscovery_TerminalSentinels(t *testing.T) {
-	deny := &http.Client{Transport: roundTripFunc(func(r *http.Request) (*http.Response, error) {
-		return jsonResponse(`{"error":"access_denied"}`), nil
-	})}
-	resp := &AppRegistrationResponse{DeviceCode: "device", Interval: 0, ExpiresIn: 5}
-	_, _, err := RegisterAppWithDiscovery(context.Background(), deny, resp, io.Discard)
-	if !errors.Is(err, ErrRegistrationDenied) {
-		t.Errorf("denied err = %v, want ErrRegistrationDenied", err)
-	}
-
-	expired := &http.Client{Transport: roundTripFunc(func(r *http.Request) (*http.Response, error) {
-		return jsonResponse(`{"error":"expired_token"}`), nil
-	})}
-	_, _, err = RegisterAppWithDiscovery(context.Background(), expired, resp, io.Discard)
-	if !errors.Is(err, ErrRegistrationExpired) {
-		t.Errorf("expired err = %v, want ErrRegistrationExpired", err)
-	}
-
-	cancelledCtx, cancel := context.WithCancel(context.Background())
-	cancel()
-	_, _, err = RegisterAppWithDiscovery(cancelledCtx, deny, resp, io.Discard)
-	if !errors.Is(err, context.Canceled) {
-		t.Errorf("cancelled err = %v, want a context.Canceled cause", err)
-	}
-}
-
-// Begin parsing: expire_in (legacy expires_in fallback), normalization, and
-// required device_code.
-func TestRequestAppRegistration_ProtocolFields(t *testing.T) {
-	serve := func(body string) *http.Client {
-		return &http.Client{Transport: roundTripFunc(func(r *http.Request) (*http.Response, error) {
-			return jsonResponse(body), nil
-		})}
-	}
-
-	resp, err := RequestAppRegistration(context.Background(),
-		serve(`{"device_code":"d","expire_in":60,"interval":3}`), core.BrandFeishu, io.Discard)
-	if err != nil {
-		t.Fatalf("begin error = %v", err)
-	}
-	if resp.ExpiresIn != 60 || resp.Interval != 3 {
-		t.Errorf("parsed (expire=%d, interval=%d), want (60, 3)", resp.ExpiresIn, resp.Interval)
-	}
-
-	resp, err = RequestAppRegistration(context.Background(),
-		serve(`{"device_code":"d","expires_in":45}`), core.BrandFeishu, io.Discard)
-	if err != nil {
-		t.Fatalf("legacy begin error = %v", err)
-	}
-	if resp.ExpiresIn != 45 || resp.Interval != 5 {
-		t.Errorf("legacy parsed (expire=%d, interval=%d), want (45, 5 — normalized default)", resp.ExpiresIn, resp.Interval)
-	}
-
-	resp, err = RequestAppRegistration(context.Background(),
-		serve(`{"device_code":"d","interval":0}`), core.BrandFeishu, io.Discard)
-	if err != nil {
-		t.Fatalf("defaults begin error = %v", err)
-	}
-	if resp.ExpiresIn != 600 || resp.Interval != 5 {
-		t.Errorf("defaults parsed (expire=%d, interval=%d), want (600, 5)", resp.ExpiresIn, resp.Interval)
-	}
-
-	if _, err := RequestAppRegistration(context.Background(),
-		serve(`{"interval":5}`), core.BrandFeishu, io.Discard); err == nil {
-		t.Error("missing device_code: expected error, got nil")
-	}
-}
-
-// A tenant signal arriving alongside authorization_pending must still switch
-// the polled domain (the official SDK checks the signal before the error).
-func TestRegisterAppWithDiscovery_PendingWithTenantSignalSwitches(t *testing.T) {
-	var polledHosts []string
-	client := &http.Client{Transport: roundTripFunc(func(r *http.Request) (*http.Response, error) {
-		polledHosts = append(polledHosts, r.URL.Host)
-		if r.URL.Host == "accounts.feishu.cn" {
-			return jsonResponse(`{"error":"authorization_pending","user_info":{"tenant_brand":"lark"}}`), nil
-		}
-		return jsonResponse(`{"client_id":"cli_x","client_secret":"test-secret"}`), nil
-	})}
-	resp := &AppRegistrationResponse{DeviceCode: "device", Interval: 0, ExpiresIn: 5}
-
-	result, finalBrand, err := RegisterAppWithDiscovery(context.Background(), client, resp, io.Discard)
-	if err != nil {
-		t.Fatalf("RegisterAppWithDiscovery error = %v, want nil", err)
-	}
-	if finalBrand != core.BrandLark || result.ClientSecret != "test-secret" {
-		t.Errorf("result = (%q, %q), want (test-secret, lark)", result.ClientSecret, finalBrand)
-	}
-	want := []string{"accounts.feishu.cn", "accounts.larksuite.com"}
-	if len(polledHosts) != 2 || polledHosts[0] != want[0] || polledHosts[1] != want[1] {
-		t.Errorf("polled hosts = %v, want %v", polledHosts, want)
-	}
-}
-
-// Polling has no attempt cap: only the expiry budget terminates the loop.
-func TestRegisterAppWithDiscovery_NoAttemptCap(t *testing.T) {
-	polls := 0
-	client := &http.Client{Transport: roundTripFunc(func(r *http.Request) (*http.Response, error) {
-		polls++
-		if polls <= 250 {
-			return jsonResponse(`{"error":"authorization_pending"}`), nil
-		}
-		return jsonResponse(`{"client_id":"cli_x","client_secret":"test-secret"}`), nil
-	})}
-	resp := &AppRegistrationResponse{DeviceCode: "device", Interval: 0, ExpiresIn: 30}
-
-	result, _, err := RegisterAppWithDiscovery(context.Background(), client, resp, io.Discard)
-	if err != nil {
-		t.Fatalf("RegisterAppWithDiscovery error = %v, want nil (no attempts cap)", err)
-	}
-	if polls != 251 || result.ClientSecret != "test-secret" {
-		t.Errorf("polls = %d (want 251), secret = %q", polls, result.ClientSecret)
-	}
-}
-
-// A final tenant report contradicting the issuing domain is a protocol
-// violation, not a brand override: the saved brand must never diverge from
-// the domain that issued the credentials.
-func TestRegisterAppWithDiscovery_ContradictoryFinalBrandFails(t *testing.T) {
-	client := &http.Client{Transport: roundTripFunc(func(r *http.Request) (*http.Response, error) {
-		if r.URL.Host == "accounts.feishu.cn" {
-			return jsonResponse(`{"error":"authorization_pending","user_info":{"tenant_brand":"lark"}}`), nil
-		}
-		// The lark domain issues credentials but reports a feishu tenant.
-		return jsonResponse(`{"client_id":"cli_x","client_secret":"test-secret","user_info":{"tenant_brand":"feishu"}}`), nil
-	})}
-	resp := &AppRegistrationResponse{DeviceCode: "device", Interval: 0, ExpiresIn: 5}
-
-	_, _, err := RegisterAppWithDiscovery(context.Background(), client, resp, io.Discard)
-	if err == nil || !strings.Contains(err.Error(), "contradictory tenant brand") {
-		t.Errorf("err = %v, want contradictory-tenant-brand protocol error", err)
-	}
-}
-
-// A cancelled body read during begin must keep its context cause so the
-// command layer classifies it as a cancellation, not an API failure.
-func TestRequestAppRegistration_BodyReadCancelKeepsCause(t *testing.T) {
-	client := &http.Client{Transport: roundTripFunc(func(r *http.Request) (*http.Response, error) {
-		return &http.Response{
-			StatusCode: http.StatusOK,
-			Body:       io.NopCloser(&errReader{err: context.Canceled}),
-			Header:     make(http.Header),
-		}, nil
-	})}
-	_, err := RequestAppRegistration(context.Background(), client, core.BrandFeishu, io.Discard)
-	if !errors.Is(err, context.Canceled) {
-		t.Errorf("err = %v, want a context.Canceled cause", err)
-	}
-}
-
-type errReader struct{ err error }
-
-func (r *errReader) Read([]byte) (int, error) { return 0, r.err }

internal/core/config.go

@@ -268,7 +268,7 @@ func ResolveConfigFromMulti(raw *MultiAppConfig, kc keychain.KeychainAccess, pro
 		ProfileName: app.ProfileName(),
 		AppID:       app.AppId,
 		AppSecret:   secret,
-		Brand:       ParseBrand(string(app.Brand)),
+		Brand:       app.Brand,
 		Lang:        app.Lang,
 		DefaultAs:   app.DefaultAs,
 	}

internal/core/config_test.go

@@ -230,20 +230,3 @@ func TestCliConfig_CanBot(t *testing.T) {
 		})
 	}
 }
-
-// Runtime configs must never carry raw brand casing: the config ingress
-// normalizes it, so downstream equality checks see canonical values.
-func TestResolveConfigFromMulti_NormalizesBrand(t *testing.T) {
-	multi := &MultiAppConfig{Apps: []AppConfig{{
-		AppId:     "cli_x",
-		AppSecret: PlainSecret("test-secret"),
-		Brand:     LarkBrand(" LARK "),
-	}}}
-	cfg, err := ResolveConfigFromMulti(multi, nil, "")
-	if err != nil {
-		t.Fatalf("ResolveConfigFromMulti error = %v", err)
-	}
-	if cfg.Brand != BrandLark {
-		t.Errorf("Brand = %q, want %q (normalized at ingress)", cfg.Brand, BrandLark)
-	}
-}

internal/core/types.go

@@ -3,11 +3,9 @@
 
 package core
 
-import "strings"
-
 // LarkBrand represents the Lark platform brand.
 // "feishu" targets China-mainland, "lark" targets international.
-// ParseBrand and ResolveEndpoints map unrecognized values to BrandFeishu.
+// Any other string is treated as a custom base URL.
 type LarkBrand string
 
 const (
@@ -15,10 +13,10 @@ const (
 	BrandLark   LarkBrand = "lark"
 )
 
-// ParseBrand normalizes a brand string (case-insensitive, whitespace-tolerant);
-// anything other than "lark" normalizes to BrandFeishu.
+// ParseBrand normalizes a brand string to a LarkBrand constant.
+// Unrecognized values default to BrandFeishu.
 func ParseBrand(value string) LarkBrand {
-	if strings.ToLower(strings.TrimSpace(value)) == "lark" {
+	if value == "lark" {
 		return BrandLark
 	}
 	return BrandFeishu
@@ -38,10 +36,9 @@ type Endpoints struct {
 	AppLink  string // e.g. "https://applink.feishu.cn"
 }
 
-// ResolveEndpoints resolves endpoint URLs for the brand, normalizing its
-// input so stored values with unusual casing still resolve correctly.
+// ResolveEndpoints resolves endpoint URLs based on brand.
 func ResolveEndpoints(brand LarkBrand) Endpoints {
-	switch ParseBrand(string(brand)) {
+	switch brand {
 	case BrandLark:
 		return Endpoints{
 			Open:     "https://open.larksuite.com",

internal/core/types_test.go

@@ -57,37 +57,3 @@ func TestResolveOpenBaseURL(t *testing.T) {
 		t.Errorf("ResolveOpenBaseURL(lark) = %q", got)
 	}
 }
-
-func TestParseBrand(t *testing.T) {
-	cases := []struct {
-		in   string
-		want LarkBrand
-	}{
-		{"", BrandFeishu},
-		{"feishu", BrandFeishu},
-		{"lark", BrandLark},
-		{"LARK", BrandLark},
-		{" lark ", BrandLark},
-		{"Lark", BrandLark},
-		{"xyz", BrandFeishu},
-	}
-	for _, c := range cases {
-		if got := ParseBrand(c.in); got != c.want {
-			t.Errorf("ParseBrand(%q) = %q, want %q", c.in, got, c.want)
-		}
-	}
-}
-
-// TestResolveEndpoints_NormalizesBrand locks the boundary invariant: the
-// resolver normalizes its brand input, so historical config values with
-// unusual casing or whitespace still resolve to their intended endpoints.
-func TestResolveEndpoints_NormalizesBrand(t *testing.T) {
-	for _, raw := range []string{"LARK", " lark ", "Lark"} {
-		if got := ResolveEndpoints(LarkBrand(raw)).Open; got != "https://open.larksuite.com" {
-			t.Errorf("ResolveEndpoints(%q).Open = %q, want the lark endpoint", raw, got)
-		}
-	}
-	if got := ResolveEndpoints(LarkBrand("unexpected")).Open; got != "https://open.feishu.cn" {
-		t.Errorf("ResolveEndpoints(unexpected).Open = %q, want the feishu default", got)
-	}
-}

internal/credential/types.go

@@ -72,8 +72,7 @@ func AccountFromCliConfig(cfg *core.CliConfig) *Account {
 	}
 }
 
-// ToCliConfig copies the credential-layer account into the downstream config
-// shape, normalizing the brand so runtime consumers never see raw casing.
+// ToCliConfig copies the credential-layer account into the downstream config shape.
 func (a *Account) ToCliConfig() *core.CliConfig {
 	if a == nil {
 		return nil
@@ -82,7 +81,7 @@ func (a *Account) ToCliConfig() *core.CliConfig {
 		ProfileName:         a.ProfileName,
 		AppID:               a.AppID,
 		AppSecret:           normalizeAccountAppSecret(a.AppSecret),
-		Brand:               core.ParseBrand(string(a.Brand)),
+		Brand:               a.Brand,
 		DefaultAs:           a.DefaultAs,
 		UserOpenId:          a.UserOpenId,
 		UserName:            a.UserName,

internal/credential/types_test.go

@@ -130,11 +130,3 @@ func TestRuntimeAppSecret_TokenOnlyUsesPlaceholder(t *testing.T) {
 		t.Fatalf("RuntimeAppSecret(real) = %q, want %q", got, "secret-1")
 	}
 }
-
-// The credential-layer ingress normalizes brand casing for all runtime consumers.
-func TestToCliConfig_NormalizesBrand(t *testing.T) {
-	acct := &Account{AppID: "cli_x", Brand: " LARK "}
-	if got := acct.ToCliConfig().Brand; got != core.BrandLark {
-		t.Errorf("Brand = %q, want %q", got, core.BrandLark)
-	}
-}

internal/errclass/classify_test.go

@@ -113,7 +113,6 @@ func TestBuildAPIError_ExitCodeMatrix(t *testing.T) {
 		{"230027 user_not_authorized", 230027, errs.CategoryAuthorization, errs.SubtypeUserUnauthorized, 3, "PermissionError"},
 		{"1470403 task_permission_denied", 1470403, errs.CategoryAuthorization, errs.SubtypePermissionDenied, 3, "PermissionError"},
 		{"1470400 task_invalid_params", 1470400, errs.CategoryAPI, errs.SubtypeInvalidParameters, 1, "APIError"},
-		{"1062507 drive_parent_sibling_limit", 1062507, errs.CategoryAPI, errs.SubtypeQuotaExceeded, 1, "APIError"},
 		{"99991400 rate_limit", 99991400, errs.CategoryAPI, errs.SubtypeRateLimit, 1, "APIError"},
 		{"99991661 token_missing", 99991661, errs.CategoryAuthentication, errs.SubtypeTokenMissing, 3, "AuthenticationError"},
 		{"21000 challenge_required", 21000, errs.CategoryPolicy, errs.Subtype("challenge_required"), 6, "SecurityPolicyError"},

internal/errclass/codemeta_drive.go

@@ -17,7 +17,6 @@ var driveCodeMeta = map[int]CodeMeta{
 	1061043:   {Category: errs.CategoryAPI, Subtype: errs.SubtypeQuotaExceeded},                // file size beyond limit
 	1061044:   {Category: errs.CategoryAPI, Subtype: errs.SubtypeNotFound},                     // parent folder does not exist (upload)
 	1061101:   {Category: errs.CategoryAPI, Subtype: errs.SubtypeQuotaExceeded},                // file quota exceeded
-	1062507:   {Category: errs.CategoryAPI, Subtype: errs.SubtypeQuotaExceeded},                // parent folder child count limit exceeded
 	1062009:   {Category: errs.CategoryAPI, Subtype: errs.SubtypeInvalidParameters},            // actual size inconsistent with declared size
 	1063001:   {Category: errs.CategoryAPI, Subtype: errs.SubtypeInvalidParameters},            // secure label invalid parameter
 	1063002:   {Category: errs.CategoryAuthorization, Subtype: errs.SubtypePermissionDenied},   // secure label permission denied

internal/qualitygate/cmd/semantic-review/main_test.go

@@ -9,15 +9,12 @@ import (
 	"path/filepath"
 	"strings"
 	"testing"
-	"time"
 
 	"github.com/larksuite/cli/internal/qualitygate/facts"
 	"github.com/larksuite/cli/internal/qualitygate/semantic"
 )
 
 func TestRunLoadsPolicyAndWaivers(t *testing.T) {
-	freezeNow(t, time.Date(2026, 6, 12, 0, 0, 0, 0, time.UTC))
-
 	repo := t.TempDir()
 	writeSemanticConfig(t, repo, `{
 	  "schema_version": 1,
@@ -68,8 +65,6 @@ func TestRunLoadsPolicyAndWaivers(t *testing.T) {
 }
 
 func TestRunLoadsWaiversFromOverrideFile(t *testing.T) {
-	freezeNow(t, time.Date(2026, 6, 12, 0, 0, 0, 0, time.UTC))
-
 	repo := t.TempDir()
 	writeSemanticConfig(t, repo, `{
 	  "schema_version": 1,
@@ -375,13 +370,6 @@ func writeSemanticConfig(t *testing.T, repo, policy, models, waivers string) {
 	}
 }
 
-func freezeNow(t *testing.T, fixed time.Time) {
-	t.Helper()
-	original := now
-	now = func() time.Time { return fixed }
-	t.Cleanup(func() { now = original })
-}
-
 func readDecision(t *testing.T, path string) semantic.Decision {
 	t.Helper()
 	data, err := os.ReadFile(path)

internal/registry/loader.go

@@ -69,12 +69,6 @@ func Init() {
 	InitWithBrand(core.BrandFeishu)
 }
 
-// ConfiguredBrand reports the brand the registry was initialized with
-// (empty before initialization). Diagnostics and startup-order tests use it.
-func ConfiguredBrand() core.LarkBrand {
-	return configuredBrand
-}
-
 // InitWithBrand initializes the registry by loading embedded data and optionally
 // overlaying cached remote data. The brand determines which remote API host to use.
 // It is safe to call multiple times (sync.Once).

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.go

@@ -75,7 +75,13 @@ func remoteMetaURL(version string) string {
 	if testMetaURL != "" {
 		return testMetaURL
 	}
-	base := core.ResolveEndpoints(configuredBrand).Open + "/api/tools/open/api_definition"
+	var base string
+	switch configuredBrand {
+	case core.BrandLark:
+		base = "https://open.larksuite.com/api/tools/open/api_definition"
+	default:
+		base = "https://open.feishu.cn/api/tools/open/api_definition"
+	}
 	q := "protocol=meta&client_version=" + url.QueryEscape(build.Version)
 	if version != "" {
 		q += "&data_version=" + url.QueryEscape(version)

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/selfupdate/updater.go

@@ -16,7 +16,6 @@ import (
 	"strings"
 	"time"
 
-	"github.com/larksuite/cli/internal/core"
 	"github.com/larksuite/cli/internal/transport"
 	"github.com/larksuite/cli/internal/vfs"
 )
@@ -50,9 +49,7 @@ const (
 
 var (
 	skillsIndexFetchTimeout = 10 * time.Second
-	// officialSkillsIndexURL overrides the brand-derived skills index URL in
-	// tests; empty in production.
-	officialSkillsIndexURL = ""
+	officialSkillsIndexURL  = "https://open.feishu.cn/.well-known/skills/index.json"
 )
 
 // DetectResult holds installation detection results.
@@ -104,9 +101,6 @@ func (r *NpmResult) CombinedOutput() string {
 // Override DetectOverride / NpmInstallOverride / SkillsCommandOverride / VerifyOverride
 // / RestoreAvailableOverride for testing.
 type Updater struct {
-	// Brand selects the skills index/source endpoints (zero value = feishu).
-	Brand core.LarkBrand
-
 	DetectOverride           func() DetectResult
 	NpmInstallOverride       func(version string) *NpmResult
 	PnpmInstallOverride      func(version string) *NpmResult
@@ -135,19 +129,6 @@ type Updater struct {
 // New creates an Updater with default (real) behavior.
 func New() *Updater { return &Updater{} }
 
-// skillsIndexURL returns the brand's well-known skills index URL.
-func (u *Updater) skillsIndexURL() string {
-	if officialSkillsIndexURL != "" {
-		return officialSkillsIndexURL
-	}
-	return core.ResolveEndpoints(u.Brand).Open + "/.well-known/skills/index.json"
-}
-
-// skillsSource returns the brand's skills source host for `npx skills add`.
-func (u *Updater) skillsSource() string {
-	return core.ResolveEndpoints(u.Brand).Open
-}
-
 // DetectInstallMethod determines how the CLI was installed and whether the
 // owning package manager is available for auto-update.
 func (u *Updater) DetectInstallMethod() DetectResult {
@@ -277,7 +258,7 @@ func (u *Updater) ListOfficialSkillsIndex() *NpmResult {
 	ctx, cancel := context.WithTimeout(context.Background(), skillsIndexFetchTimeout)
 	defer cancel()
 
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, u.skillsIndexURL(), nil)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, officialSkillsIndexURL, nil)
 	if err != nil {
 		r.Err = err
 		return r
@@ -316,7 +297,7 @@ func (u *Updater) ListOfficialSkillsIndex() *NpmResult {
 }
 
 func (u *Updater) ListOfficialSkills() *NpmResult {
-	r := u.runSkillsListOfficial(u.skillsSource())
+	r := u.runSkillsListOfficial("https://open.feishu.cn")
 	if r.Err != nil {
 		r = u.runSkillsListOfficial("larksuite/cli")
 	}
@@ -332,7 +313,7 @@ func (u *Updater) ListGlobalSkillsJSON() *NpmResult {
 }
 
 func (u *Updater) InstallSkill(nameList []string) *NpmResult {
-	r := u.runSkillsInstall(u.skillsSource(), nameList)
+	r := u.runSkillsInstall("https://open.feishu.cn", nameList)
 	if r.Err != nil {
 		r = u.runSkillsInstall("larksuite/cli", nameList)
 	}
@@ -340,7 +321,7 @@ func (u *Updater) InstallSkill(nameList []string) *NpmResult {
 }
 
 func (u *Updater) InstallAllSkills() *NpmResult {
-	r := u.runSkillsAdd(u.skillsSource())
+	r := u.runSkillsAdd("https://open.feishu.cn")
 	if r.Err != nil {
 		r = u.runSkillsAdd("larksuite/cli")
 	}

internal/selfupdate/updater_test.go

@@ -17,7 +17,6 @@ import (
 	"testing"
 	"time"
 
-	"github.com/larksuite/cli/internal/core"
 	"github.com/larksuite/cli/internal/vfs"
 )
 
@@ -516,23 +515,3 @@ func TestDetectInstallMethod_Caches(t *testing.T) {
 		t.Errorf("expected cached pnpm result to be returned, got %+v", got)
 	}
 }
-
-func TestSkillsBrandHosts(t *testing.T) {
-	cases := []struct {
-		brand      core.LarkBrand
-		wantIndex  string
-		wantSource string
-	}{
-		{core.BrandFeishu, "https://open.feishu.cn/.well-known/skills/index.json", "https://open.feishu.cn"},
-		{core.BrandLark, "https://open.larksuite.com/.well-known/skills/index.json", "https://open.larksuite.com"},
-	}
-	for _, c := range cases {
-		u := &Updater{Brand: c.brand}
-		if got := u.skillsIndexURL(); got != c.wantIndex {
-			t.Errorf("brand %q: skillsIndexURL = %q, want %q", c.brand, got, c.wantIndex)
-		}
-		if got := u.skillsSource(); got != c.wantSource {
-			t.Errorf("brand %q: skillsSource = %q, want %q", c.brand, got, c.wantSource)
-		}
-	}
-}

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)

lint/README.md

@@ -30,42 +30,8 @@ lint/
     ├── rule_subtype_classifier.go
     ├── rule_typed_error_completeness.go
     └── *_test.go
-└── domaincontract/     # endpoint domain contract: no hardcoded resolver hosts
-    ├── scan.go         # ScanRepo(root) ([]lintapi.Violation, error)  ← public entry
-    └── scan_test.go
 ```
 
-## Endpoint domain contract (`domaincontract`)
-
-`domaincontract` is a syntax-level regression guard for the resolver-owned
-Open, Accounts, MCP, and AppLink hosts used by the Go CLI. In production `.go`
-files it rejects:
-
-- string literals containing a resolver-owned host FQDN
-  (`{open,accounts,mcp,applink}.{feishu.cn,larksuite.com}`), and
-- direct references to the SDK base-URL globals (`FeishuBaseUrl` / `LarkBaseUrl`)
-  selected off an import of the SDK root package, which pick a host without
-  going through the resolver. Unrelated identifiers sharing the name are not
-  flagged.
-
-Host literals are permitted only inside the resolver's `ResolveEndpoints`
-function body (`internal/core/types.go`) and in this rule's own host list
-(`lint/domaincontract/scan.go`); a helper elsewhere in the resolver file
-returning a hardcoded host is still rejected. Comments and `_test.go` files
-are not scanned. Literals are unquoted before matching (escape sequences
-cannot hide a host) and match case-insensitively, and dot-imports of the SDK
-root package are rejected outright (they would hide the globals from this
-parse-level guard). The forbidden-host list is bound to the resolver source by
-`TestForbiddenHostsMatchResolver`, so adding a resolver domain without updating
-the guard fails the lint module's tests.
-
-This is not a general outbound-URL or data-flow analyzer. It does not inspect
-non-Go assets, hosts assembled from string fragments, SDK constructor option
-flow, or previously unknown Feishu/Lark hosts. The literal rule and code review
-remain the backstop for those cases.
-
-To add or change an outbound endpoint, edit the resolver — never hardcode a host.
-
 ## Running
 
 ```bash
@@ -76,7 +42,7 @@ go run -C lint . ..
 `-C lint` switches Go's working directory to `lint/`; the `..` argument
 is the repo root to scan (relative to `lint/`).
 
-CI: `.github/workflows/ci.yml` step `Run source-contract lint guards (lintcheck)`.
+CI: `.github/workflows/ci.yml` step `Run errs/ lint guards (lintcheck)`.
 
 Exit codes follow `lint/main.go`:
 

lint/domaincontract/enforce_test.go

@@ -1,45 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package domaincontract
-
-import (
-	"errors"
-	"os"
-	"os/exec"
-	"strings"
-	"testing"
-)
-
-// TestLintcheckExitCode proves the guard gates CI end to end: a violating
-// fixture must make the lintcheck binary exit 1, and a clean tree exit 0.
-func TestLintcheckExitCode(t *testing.T) {
-	if testing.Short() {
-		t.Skip("compiles the lintcheck binary")
-	}
-	dirty := t.TempDir()
-	writeFile(t, dirty, "internal/x/x.go", "package x\n\nvar h = \"https://open.feishu.cn\"\n")
-
-	run := func(dir string) (string, error) {
-		cmd := exec.Command("go", "run", "..", dir)
-		cmd.Dir = "." // lint/domaincontract — `..` is the lintcheck main package
-		cmd.Env = os.Environ()
-		out, err := cmd.CombinedOutput()
-		return string(out), err
-	}
-
-	out, err := run(dirty)
-	if err == nil || !strings.Contains(out, "no-hardcoded-endpoint") {
-		t.Fatalf("violating fixture: err=%v out=%s (want exit 1 with a no-hardcoded-endpoint REJECT)", err, out)
-	}
-	var exitErr *exec.ExitError
-	if !errors.As(err, &exitErr) || exitErr.ExitCode() != 1 {
-		t.Fatalf("violating fixture exit = %v, want 1", err)
-	}
-
-	clean := t.TempDir()
-	writeFile(t, clean, "internal/x/x.go", "package x\n\nvar ok = 1\n")
-	if out, err := run(clean); err != nil {
-		t.Fatalf("clean fixture: err=%v out=%s (want exit 0)", err, out)
-	}
-}

lint/domaincontract/scan.go

@@ -1,190 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-// Package domaincontract guards the Go CLI against direct reuse of the current
-// resolver-owned host FQDNs outside core.ResolveEndpoints.
-package domaincontract
-
-import (
-	"go/ast"
-	"go/parser"
-	"go/token"
-	"io/fs"
-	"path/filepath"
-	"strconv"
-	"strings"
-
-	"github.com/larksuite/cli/lint/lintapi"
-)
-
-// forbiddenHosts are the resolver-owned FQDNs. They may only appear as string
-// literals in the allowlisted resolver source.
-var forbiddenHosts = []string{
-	"open.feishu.cn", "accounts.feishu.cn", "mcp.feishu.cn", "applink.feishu.cn",
-	"open.larksuite.com", "accounts.larksuite.com", "mcp.larksuite.com", "applink.larksuite.com",
-}
-
-// forbiddenIdents are the SDK root package's base-URL globals; referencing
-// them picks a host without the resolver. Matched as selectors on an SDK root
-// import, so unrelated same-name identifiers are not flagged.
-var forbiddenIdents = map[string]bool{
-	"FeishuBaseUrl": true,
-	"LarkBaseUrl":   true,
-}
-
-// sdkModulePrefix identifies imports of the Lark OAPI SDK.
-const sdkModulePrefix = "github.com/larksuite/oapi-sdk-go/"
-
-// sdkImportAliases returns the file's local names for the SDK root package
-// (subpackages do not export the base-URL globals).
-func sdkImportAliases(file *ast.File) map[string]bool {
-	aliases := map[string]bool{}
-	for _, imp := range file.Imports {
-		path, err := strconv.Unquote(imp.Path.Value)
-		if err != nil || !strings.HasPrefix(path, sdkModulePrefix) {
-			continue
-		}
-		if strings.Contains(strings.TrimPrefix(path, sdkModulePrefix), "/") {
-			continue // subpackage, not the root
-		}
-		name := "lark" // the SDK root package's package name
-		if imp.Name != nil {
-			name = imp.Name.Name
-		}
-		aliases[name] = true
-	}
-	return aliases
-}
-
-// allowlist holds the only file allowed to carry the literals wholesale:
-// this rule's own host list. The resolver file is scoped per-function instead
-// (see resolverPath).
-var allowlist = map[string]bool{
-	filepath.FromSlash("lint/domaincontract/scan.go"): true,
-}
-
-// resolverPath is the resolver source; host literals are permitted only
-// inside its ResolveEndpoints function body.
-var resolverPath = filepath.FromSlash("internal/core/types.go")
-
-func skipDir(name string) bool {
-	switch name {
-	case "vendor", "testdata", "node_modules", ".git", ".claude":
-		return true
-	}
-	return false
-}
-
-// ScanRepo walks production .go files under root and flags string literals
-// containing a forbidden resolver host outside the allowlist. Comments and
-// _test.go files are not scanned.
-func ScanRepo(root string) ([]lintapi.Violation, error) {
-	var out []lintapi.Violation
-	err := filepath.WalkDir(root, func(path string, d fs.DirEntry, err error) error {
-		if err != nil {
-			return err
-		}
-		if d.IsDir() {
-			if skipDir(d.Name()) {
-				return filepath.SkipDir
-			}
-			return nil
-		}
-		if !strings.HasSuffix(path, ".go") || strings.HasSuffix(path, "_test.go") {
-			return nil
-		}
-		rel, relErr := filepath.Rel(root, path)
-		if relErr == nil && allowlist[rel] {
-			return nil
-		}
-		fset := token.NewFileSet()
-		file, perr := parser.ParseFile(fset, path, nil, 0)
-		if perr != nil {
-			return nil // unparseable file: not our concern
-		}
-		display := path
-		if relErr == nil {
-			display = rel
-		}
-		var allowedFrom, allowedTo token.Pos
-		if relErr == nil && rel == resolverPath {
-			for _, d := range file.Decls {
-				if fd, ok := d.(*ast.FuncDecl); ok && fd.Recv == nil && fd.Name.Name == "ResolveEndpoints" && fd.Body != nil {
-					allowedFrom, allowedTo = fd.Body.Pos(), fd.Body.End()
-					break
-				}
-			}
-		}
-		inResolverBody := func(p token.Pos) bool {
-			return allowedFrom != token.NoPos && p >= allowedFrom && p <= allowedTo
-		}
-		// Dot-imports of the SDK root would hide its globals from this
-		// parse-level guard, so the import form itself is rejected.
-		for _, imp := range file.Imports {
-			path, uerr := strconv.Unquote(imp.Path.Value)
-			if uerr != nil || imp.Name == nil || imp.Name.Name != "." {
-				continue
-			}
-			if strings.HasPrefix(path, sdkModulePrefix) &&
-				!strings.Contains(strings.TrimPrefix(path, sdkModulePrefix), "/") {
-				pos := fset.Position(imp.Pos())
-				out = append(out, lintapi.Violation{
-					Rule:       "no-hardcoded-endpoint",
-					Action:     lintapi.ActionReject,
-					File:       display,
-					Line:       pos.Line,
-					Message:    "dot-import of the SDK root package defeats the endpoint guard",
-					Suggestion: "import the SDK with a package name",
-				})
-			}
-		}
-		sdkAliases := sdkImportAliases(file)
-		ast.Inspect(file, func(n ast.Node) bool {
-			switch node := n.(type) {
-			case *ast.SelectorExpr:
-				pkg, ok := node.X.(*ast.Ident)
-				if ok && pkg.Obj == nil && forbiddenIdents[node.Sel.Name] && sdkAliases[pkg.Name] {
-					pos := fset.Position(node.Pos())
-					out = append(out, lintapi.Violation{
-						Rule:       "no-hardcoded-endpoint",
-						Action:     lintapi.ActionReject,
-						File:       display,
-						Line:       pos.Line,
-						Message:    "SDK base-URL global " + pkg.Name + "." + node.Sel.Name + " bypasses the resolver — use core.ResolveEndpoints",
-						Suggestion: "derive the host from core.ResolveEndpoints(brand) instead of the SDK global",
-					})
-				}
-			case *ast.BasicLit:
-				if node.Kind != token.STRING {
-					return true
-				}
-				if inResolverBody(node.Pos()) {
-					return true
-				}
-				// Unquote and lowercase so escapes or casing cannot hide a host.
-				value := node.Value
-				if v, err := strconv.Unquote(value); err == nil {
-					value = v
-				}
-				lower := strings.ToLower(value)
-				for _, host := range forbiddenHosts {
-					if strings.Contains(lower, host) {
-						pos := fset.Position(node.Pos())
-						out = append(out, lintapi.Violation{
-							Rule:       "no-hardcoded-endpoint",
-							Action:     lintapi.ActionReject,
-							File:       display,
-							Line:       pos.Line,
-							Message:    "hardcoded resolver host " + host + " — outbound domains must come from core.ResolveEndpoints",
-							Suggestion: "use core.ResolveEndpoints(brand) instead of a literal host",
-						})
-						return true
-					}
-				}
-			}
-			return true
-		})
-		return nil
-	})
-	return out, err
-}

lint/domaincontract/scan_test.go

@@ -1,231 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package domaincontract
-
-import (
-	"go/ast"
-	"go/parser"
-	"go/token"
-	"net/url"
-	"os"
-	"path/filepath"
-	"strconv"
-	"strings"
-	"testing"
-
-	"github.com/larksuite/cli/lint/lintapi"
-)
-
-// requireEnforced pins every violation to the rejecting rule: a regression
-// that downgrades the guard to an advisory action must fail here.
-func requireEnforced(t *testing.T, vs []lintapi.Violation) {
-	t.Helper()
-	for _, v := range vs {
-		if v.Rule != "no-hardcoded-endpoint" || v.Action != lintapi.ActionReject {
-			t.Fatalf("violation not CI-enforced: rule=%q action=%q (%s:%d)", v.Rule, v.Action, v.File, v.Line)
-		}
-	}
-}
-
-func writeFile(t *testing.T, root, rel, content string) {
-	t.Helper()
-	p := filepath.Join(root, rel)
-	if err := os.MkdirAll(filepath.Dir(p), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(p, []byte(content), 0o644); err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestScanRepo(t *testing.T) {
-	root := t.TempDir()
-	// Negative: the resolver may hold the literals inside ResolveEndpoints.
-	writeFile(t, root, "internal/core/types.go", "package core\n\nfunc ResolveEndpoints(b string) string {\n\treturn \"https://open.feishu.cn\"\n}\n")
-	// Negative: non-resolver hosts + a comment reference must not trip the guard.
-	writeFile(t, root, "shortcuts/x/display.go", "package x\n\n// see https://open.feishu.cn/document/foo\nvar h = \"https://www.feishu.cn\"\nvar e = \"https://example.feishu.cn\"\nvar r = \"https://registry.npmjs.org/pkg\"\n")
-	// Negative: _test.go files may assert literals.
-	writeFile(t, root, "internal/y/y_test.go", "package y\n\nvar w = \"https://open.larksuite.com\"\n")
-	// Positive: production literal outside the allowlist.
-	writeFile(t, root, "internal/z/z.go", "package z\n\nvar bad = \"https://accounts.larksuite.com/oauth\"\n")
-
-	vs, err := ScanRepo(root)
-	if err != nil {
-		t.Fatal(err)
-	}
-	requireEnforced(t, vs)
-	if len(vs) != 1 {
-		t.Fatalf("got %d violations, want 1: %+v", len(vs), vs)
-	}
-	if filepath.Base(vs[0].File) != "z.go" {
-		t.Errorf("violation in %q, want z.go", vs[0].File)
-	}
-}
-
-// SDK base-URL globals are rejected only when selected off an SDK root
-// import; same-name identifiers elsewhere pass.
-func TestScanRepoSDKConstants(t *testing.T) {
-	root := t.TempDir()
-	// Positive: default and renamed imports of the SDK root package.
-	writeFile(t, root, "shortcuts/x/ws.go",
-		"package x\n\nimport \"github.com/larksuite/oapi-sdk-go/v3\"\n\nvar d = lark.FeishuBaseUrl\n")
-	writeFile(t, root, "shortcuts/x/ws2.go",
-		"package x\n\nimport sdk \"github.com/larksuite/oapi-sdk-go/v3\"\n\nvar e = sdk.LarkBaseUrl\n")
-	// Negative: test file may reference the globals.
-	writeFile(t, root, "shortcuts/x/ws_test.go",
-		"package x\n\nimport lark \"github.com/larksuite/oapi-sdk-go/v3\"\n\nvar p = lark.LarkBaseUrl\n")
-	// Negative: same-name local identifier without the SDK import.
-	writeFile(t, root, "shortcuts/y/local.go",
-		"package y\n\nvar FeishuBaseUrl = \"local\"\nvar q = FeishuBaseUrl\n")
-	// Negative: same-name symbol from an unrelated package.
-	writeFile(t, root, "shortcuts/z/other.go",
-		"package z\n\nimport other \"example.com/other\"\n\nvar r = other.FeishuBaseUrl\n")
-	// Negative: SDK subpackage import does not export the globals.
-	writeFile(t, root, "shortcuts/w/sub.go",
-		"package w\n\nimport larkws \"github.com/larksuite/oapi-sdk-go/v3/ws\"\n\nvar s = larkws.FeishuBaseUrl\n")
-	// Negative: a local value shadowing the SDK import alias is not the package.
-	writeFile(t, root, "shortcuts/v/shadow.go",
-		"package v\n\nimport lark \"github.com/larksuite/oapi-sdk-go/v3\"\n\ntype endpoint struct { FeishuBaseUrl string }\nvar _ *lark.Client\nfunc local() string { lark := endpoint{}; return lark.FeishuBaseUrl }\n")
-
-	vs, err := ScanRepo(root)
-	if err != nil {
-		t.Fatal(err)
-	}
-	requireEnforced(t, vs)
-	if len(vs) != 2 {
-		t.Fatalf("got %d violations, want 2: %+v", len(vs), vs)
-	}
-	files := map[string]bool{}
-	for _, v := range vs {
-		files[filepath.Base(v.File)] = true
-	}
-	if !files["ws.go"] || !files["ws2.go"] {
-		t.Errorf("violations in %v, want ws.go and ws2.go", files)
-	}
-}
-
-// forbiddenHosts must equal the https hosts in the resolver source, both ways;
-// a resolver domain change without a guard update fails here.
-func TestForbiddenHostsMatchResolver(t *testing.T) {
-	src := filepath.Join("..", "..", "internal", "core", "types.go")
-	fset := token.NewFileSet()
-	file, err := parser.ParseFile(fset, src, nil, 0)
-	if err != nil {
-		t.Fatalf("parse resolver source: %v", err)
-	}
-	// Walk only the receiverless ResolveEndpoints body — the same scope the
-	// production scanner exempts — so unrelated URLs in the file cannot skew
-	// the parity check.
-	var resolverBody ast.Node
-	for _, d := range file.Decls {
-		if fd, ok := d.(*ast.FuncDecl); ok && fd.Recv == nil && fd.Name.Name == "ResolveEndpoints" && fd.Body != nil {
-			resolverBody = fd.Body
-			break
-		}
-	}
-	if resolverBody == nil {
-		t.Fatal("ResolveEndpoints function not found in resolver source")
-	}
-	resolverHosts := map[string]bool{}
-	ast.Inspect(resolverBody, func(n ast.Node) bool {
-		lit, ok := n.(*ast.BasicLit)
-		if !ok || lit.Kind != token.STRING {
-			return true
-		}
-		v, err := strconv.Unquote(lit.Value)
-		if err != nil || !strings.HasPrefix(v, "https://") {
-			return true
-		}
-		// Parse instead of prefix-stripping so a resolver URL that ever gains a
-		// path component still compares by bare host against forbiddenHosts.
-		u, err := url.Parse(v)
-		if err != nil || u.Host == "" {
-			return true
-		}
-		resolverHosts[u.Host] = true
-		return true
-	})
-
-	guardHosts := map[string]bool{}
-	for _, h := range forbiddenHosts {
-		guardHosts[h] = true
-	}
-	for h := range resolverHosts {
-		if !guardHosts[h] {
-			t.Errorf("resolver host %q is not in the guard's forbidden list", h)
-		}
-	}
-	for h := range guardHosts {
-		if !resolverHosts[h] {
-			t.Errorf("guard forbids %q which the resolver does not define", h)
-		}
-	}
-}
-
-// Dot-import rejection and case-insensitive literal matching.
-func TestScanRepoDotImportAndCase(t *testing.T) {
-	root := t.TempDir()
-	// Positive: dot-import of the SDK root package.
-	writeFile(t, root, "shortcuts/a/dot.go",
-		"package a\n\nimport . \"github.com/larksuite/oapi-sdk-go/v3\"\n\nvar d = FeishuBaseUrl\n")
-	// Positive: uppercase host literal.
-	writeFile(t, root, "shortcuts/b/upper.go",
-		"package b\n\nvar u = \"https://OPEN.FEISHU.CN/api\"\n")
-	// Negative: dot-import of an SDK subpackage is out of the globals' scope.
-	writeFile(t, root, "shortcuts/c/sub.go",
-		"package c\n\nimport . \"github.com/larksuite/oapi-sdk-go/v3/ws\"\n\nvar s = 1\n")
-
-	vs, err := ScanRepo(root)
-	if err != nil {
-		t.Fatal(err)
-	}
-	requireEnforced(t, vs)
-	if len(vs) != 2 {
-		t.Fatalf("got %d violations, want 2: %+v", len(vs), vs)
-	}
-	files := map[string]bool{}
-	for _, v := range vs {
-		files[filepath.Base(v.File)] = true
-	}
-	if !files["dot.go"] || !files["upper.go"] {
-		t.Errorf("violations in %v, want dot.go and upper.go", files)
-	}
-}
-
-// The resolver file is scoped per-function: a hardcoded host outside the
-// ResolveEndpoints body is rejected.
-func TestScanRepoResolverFunctionScope(t *testing.T) {
-	root := t.TempDir()
-	writeFile(t, root, "internal/core/types.go",
-		"package core\n\nfunc ResolveEndpoints(b string) string {\n\treturn \"https://open.feishu.cn\"\n}\n\nfunc bypass() string { return \"https://open.feishu.cn\" }\n\ntype localResolver struct{}\nfunc (localResolver) ResolveEndpoints() string { return \"https://open.feishu.cn\" }\n")
-
-	vs, err := ScanRepo(root)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(vs) != 2 {
-		t.Fatalf("got %d violations, want 2 (helper and receiver method): %+v", len(vs), vs)
-	}
-	for _, v := range vs {
-		if filepath.Base(v.File) != "types.go" {
-			t.Errorf("violation in %q, want types.go", v.File)
-		}
-	}
-}
-
-// Escape sequences cannot hide a host: literals are unquoted before matching.
-func TestScanRepoEscapedLiteral(t *testing.T) {
-	root := t.TempDir()
-	writeFile(t, root, "internal/e/e.go",
-		"package e\n\nvar h = \"https://open.feishu\\u002ecn\"\n")
-
-	vs, err := ScanRepo(root)
-	if err != nil {
-		t.Fatal(err)
-	}
-	requireEnforced(t, vs)
-	if len(vs) != 1 {
-		t.Fatalf("got %d violations, want 1: %+v", len(vs), vs)
-	}
-}

lint/main.go

@@ -1,9 +1,10 @@
 // Copyright (c) 2026 Lark Technologies Pte. Ltd.
 // SPDX-License-Identifier: MIT
 
-// Command lintcheck runs repository source-contract guards that golangci-lint
-// cannot express directly. It currently covers typed-error contracts and the
-// resolver-owned endpoint contract.
+// Command lintcheck runs the source-level errs/ contract guards (all four checks).
+// The fifth contract rule (business path must use typed errors) lives in
+// .golangci.yml as a forbidigo entry; the four checks here are AST-level
+// guards that golangci-lint cannot express.
 //
 // lintcheck lives in its own Go module under lint/ so its build-time
 // dependency on golang.org/x/tools/go/packages does not leak into the
@@ -29,7 +30,6 @@ import (
 	"fmt"
 	"os"
 
-	"github.com/larksuite/cli/lint/domaincontract"
 	"github.com/larksuite/cli/lint/errscontract"
 	"github.com/larksuite/cli/lint/lintapi"
 )
@@ -43,9 +43,6 @@ type scanner struct {
 
 var scanners = []scanner{
 	{name: "errscontract", fn: errscontract.ScanRepoWithOptions},
-	{name: "domaincontract", fn: func(root string, _ errscontract.ScanOptions) ([]lintapi.Violation, error) {
-		return domaincontract.ScanRepo(root)
-	}},
 }
 
 func main() {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@larksuite/cli",
-  "version": "1.0.69",
+  "version": "1.0.66",
   "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,132 +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 got struct {
-		Description string `json:"description"`
-		API         []struct {
-			Desc   string `json:"desc"`
-			Method string `json:"method"`
-		} `json:"api"`
-	}
-	if err := json.Unmarshal(stdout.Bytes(), &got); err != nil {
-		t.Fatalf("json: %v", err)
-	}
-	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,144 +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 got struct {
-		Description string `json:"description"`
-		API         []struct {
-			Desc   string `json:"desc"`
-			Method string `json:"method"`
-		} `json:"api"`
-	}
-	if err := json.Unmarshal(stdout.Bytes(), &got); err != nil {
-		t.Fatalf("json: %v", err)
-	}
-	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 got struct {
-		API []struct {
-			Desc string `json:"desc"`
-			URL  string `json:"url"`
-		} `json:"api"`
-	}
-	if err := json.Unmarshal(stdout.Bytes(), &got); err != nil {
-		t.Fatalf("json: %v", err)
-	}
-	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_create.go

@@ -9,7 +9,6 @@ import (
 	"io"
 	"strings"
 
-	"github.com/larksuite/cli/internal/envvars"
 	"github.com/larksuite/cli/shortcuts/common"
 )
 
@@ -62,7 +61,6 @@ func buildAppsCreateBody(rctx *common.RuntimeContext) map[string]interface{} {
 	// --app-type is constrained to the lowercase enum (html / full_stack) by the
 	// flag's Enum, so send it through verbatim. Legacy uppercase compatibility is
 	// a server concern and is intentionally not surfaced by the CLI.
-	agent := envvars.AgentName()
 	body := map[string]interface{}{
 		"name":     strings.TrimSpace(rctx.Str("name")),
 		"app_type": rctx.Str("app-type"),
@@ -73,8 +71,5 @@ func buildAppsCreateBody(rctx *common.RuntimeContext) map[string]interface{} {
 	if icon := strings.TrimSpace(rctx.Str("icon-url")); icon != "" {
 		body["icon_url"] = icon
 	}
-	if agent != "" {
-		body["source_agent"] = agent
-	}
 	return body
 }

shortcuts/apps/apps_create_test.go

@@ -273,93 +273,3 @@ func TestAppsCreate_FullstackDryRun(t *testing.T) {
 		t.Fatalf("dry-run should not contain message: %s", got)
 	}
 }
-
-func TestAppsCreate_WithAgentEnvVar(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_AGENT_NAME", "doubao")
-	factory, stdout, reg := newAppsExecuteFactory(t)
-	stub := &httpmock.Stub{
-		Method: "POST",
-		URL:    "/open-apis/spark/v1/apps",
-		Body: map[string]interface{}{
-			"code": 0,
-			"data": map[string]interface{}{
-				"app": map[string]interface{}{"app_id": "app_d", "name": "Demo"},
-			},
-		},
-	}
-	reg.Register(stub)
-
-	if err := runAppsShortcut(t, AppsCreate,
-		[]string{"+create", "--name", "Demo", "--app-type", "html", "--as", "user"},
-		factory, stdout); err != nil {
-		t.Fatalf("execute err=%v", err)
-	}
-
-	var sent map[string]interface{}
-	if err := json.Unmarshal(stub.CapturedBody, &sent); err != nil {
-		t.Fatalf("decode body: %v", err)
-	}
-	if sent["source_agent"] != "doubao" {
-		t.Fatalf("body.source_agent = %v, want doubao", sent["source_agent"])
-	}
-}
-
-func TestAppsCreate_WithoutAgentEnvVar(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_AGENT_NAME", "")
-	factory, stdout, reg := newAppsExecuteFactory(t)
-	stub := &httpmock.Stub{
-		Method: "POST",
-		URL:    "/open-apis/spark/v1/apps",
-		Body: map[string]interface{}{
-			"code": 0,
-			"data": map[string]interface{}{
-				"app": map[string]interface{}{"app_id": "app_d", "name": "Demo"},
-			},
-		},
-	}
-	reg.Register(stub)
-
-	if err := runAppsShortcut(t, AppsCreate,
-		[]string{"+create", "--name", "Demo", "--app-type", "html", "--as", "user"},
-		factory, stdout); err != nil {
-		t.Fatalf("execute err=%v", err)
-	}
-
-	var sent map[string]interface{}
-	if err := json.Unmarshal(stub.CapturedBody, &sent); err != nil {
-		t.Fatalf("decode body: %v", err)
-	}
-	if _, present := sent["source_agent"]; present {
-		t.Fatalf("source_agent should not be present when env var is empty: %v", sent)
-	}
-}
-
-func TestAppsCreate_AgentEnvVarNotSet(t *testing.T) {
-	t.Setenv("LARKSUITE_CLI_AGENT_NAME", "")
-	factory, stdout, reg := newAppsExecuteFactory(t)
-	stub := &httpmock.Stub{
-		Method: "POST",
-		URL:    "/open-apis/spark/v1/apps",
-		Body: map[string]interface{}{
-			"code": 0,
-			"data": map[string]interface{}{
-				"app": map[string]interface{}{"app_id": "app_d", "name": "Demo"},
-			},
-		},
-	}
-	reg.Register(stub)
-
-	if err := runAppsShortcut(t, AppsCreate,
-		[]string{"+create", "--name", "Demo", "--app-type", "html", "--as", "user"},
-		factory, stdout); err != nil {
-		t.Fatalf("execute err=%v", err)
-	}
-
-	var sent map[string]interface{}
-	if err := json.Unmarshal(stub.CapturedBody, &sent); err != nil {
-		t.Fatalf("decode body: %v", err)
-	}
-	if _, present := sent["source_agent"]; present {
-		t.Fatalf("source_agent should not be present when env var is unset: %v", sent)
-	}
-}

shortcuts/apps/apps_errors.go

@@ -44,9 +44,8 @@ func appsExternalToolError(err error, format string, args ...any) *errs.Internal
 	return errs.NewInternalError(errs.SubtypeExternalTool, format, args...).WithCause(err)
 }
 
-// appsSubprocessEnvelopeError classifies a malformed or unexpected response
-// structure as internal/invalid_response. Used for subprocess envelopes
-// (+git-credential-init / +env-pull) and server responses (e.g. pre_release).
+// appsSubprocessEnvelopeError classifies a malformed or failed envelope from a
+// lark-cli subprocess (+git-credential-init / +env-pull) as internal/invalid_response.
 func appsSubprocessEnvelopeError(format string, args ...any) *errs.InternalError {
 	return errs.NewInternalError(errs.SubtypeInvalidResponse, format, args...)
 }

shortcuts/apps/apps_get.go

@@ -1,67 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package apps
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"strings"
-
-	"github.com/larksuite/cli/internal/validate"
-	"github.com/larksuite/cli/shortcuts/common"
-)
-
-// AppsGet fetches a single app's detail by app ID.
-var AppsGet = common.Shortcut{
-	Service:     appsService,
-	Command:     "+get",
-	Description: "Get a single app's detail by app ID (returns app_type, name, description, publish status, etc.)",
-	Risk:        "read",
-	Tips: []string{
-		"Example: lark-cli apps +get --app-id <app_id>",
-		"Example: lark-cli apps +get --app-id <app_id> --dry-run",
-		"Tip: extract app type with --jq '.data.app.app_type'",
-	},
-	Scopes:    []string{"spark:app:read"},
-	AuthTypes: []string{"user"},
-	HasFormat: true,
-	Flags: []common.Flag{
-		{Name: "app-id", Desc: "app ID", Required: true},
-	},
-	Validate: func(ctx context.Context, rctx *common.RuntimeContext) error {
-		if strings.TrimSpace(rctx.Str("app-id")) == "" {
-			return appsValidationParamError("--app-id", "--app-id is required")
-		}
-		return nil
-	},
-	DryRun: func(ctx context.Context, rctx *common.RuntimeContext) *common.DryRunAPI {
-		appID := strings.TrimSpace(rctx.Str("app-id"))
-		return common.NewDryRunAPI().
-			GET(fmt.Sprintf("%s/apps/%s", apiBasePath, validate.EncodePathSegment(appID))).
-			Desc("Get app detail (returns app_id, app_type, name, description, icon_url, created_at, updated_at, is_published)")
-	},
-	Execute: func(ctx context.Context, rctx *common.RuntimeContext) error {
-		appID := strings.TrimSpace(rctx.Str("app-id"))
-		data, err := rctx.CallAPITyped("GET", fmt.Sprintf("%s/apps/%s", apiBasePath, validate.EncodePathSegment(appID)), nil, nil)
-		if err != nil {
-			return withAppsHint(err, appIDListHint)
-		}
-		rctx.OutFormat(data, nil, func(w io.Writer) {
-			app, _ := data["app"].(map[string]interface{})
-			if app == nil {
-				return
-			}
-			fmt.Fprintf(w, "app_id: %v\n", app["app_id"])
-			fmt.Fprintf(w, "app_type: %v\n", app["app_type"])
-			fmt.Fprintf(w, "name: %v\n", app["name"])
-			if desc, ok := app["description"].(string); ok && desc != "" {
-				fmt.Fprintf(w, "description: %s\n", desc)
-			}
-			fmt.Fprintf(w, "is_published: %v\n", app["is_published"])
-			fmt.Fprintf(w, "updated_at: %v\n", app["updated_at"])
-		})
-		return nil
-	},
-}

shortcuts/apps/apps_get_test.go

@@ -1,109 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package apps
-
-import (
-	"strings"
-	"testing"
-
-	"github.com/larksuite/cli/internal/httpmock"
-)
-
-func TestAppsGet_Success(t *testing.T) {
-	factory, stdout, reg := newAppsExecuteFactory(t)
-	reg.Register(&httpmock.Stub{
-		Method: "GET",
-		URL:    "/open-apis/spark/v1/apps/app_test",
-		Body: map[string]interface{}{
-			"code": 0,
-			"data": map[string]interface{}{
-				"app": map[string]interface{}{
-					"app_id":       "app_test",
-					"app_type":     "html",
-					"name":         "TestApp",
-					"description":  "A test application",
-					"icon_url":     "https://example.com/icon.svg",
-					"is_published": true,
-					"created_at":   "2026-05-18T10:00:00Z",
-					"updated_at":   "2026-06-01T12:00:00Z",
-				},
-			},
-		},
-	})
-
-	if err := runAppsShortcut(t, AppsGet,
-		[]string{"+get", "--app-id", "app_test", "--as", "user"},
-		factory, stdout); err != nil {
-		t.Fatalf("execute err=%v", err)
-	}
-	got := stdout.String()
-	if !strings.Contains(got, "app_test") {
-		t.Fatalf("stdout missing app_id: %s", got)
-	}
-	if !strings.Contains(got, "html") {
-		t.Fatalf("stdout missing app_type: %s", got)
-	}
-}
-
-func TestAppsGet_RequiresAppID(t *testing.T) {
-	factory, stdout, _ := newAppsExecuteFactory(t)
-	err := runAppsShortcut(t, AppsGet,
-		[]string{"+get", "--as", "user"}, factory, stdout)
-	if err == nil || !strings.Contains(err.Error(), "app-id") {
-		t.Fatalf("expected app-id required error, got %v", err)
-	}
-}
-
-func TestAppsGet_EmptyAppID(t *testing.T) {
-	factory, stdout, _ := newAppsExecuteFactory(t)
-	err := runAppsShortcut(t, AppsGet,
-		[]string{"+get", "--app-id", "", "--as", "user"}, factory, stdout)
-	requireAppsValidationProblem(t, err)
-}
-
-func TestAppsGet_DryRun(t *testing.T) {
-	factory, stdout, _ := newAppsExecuteFactory(t)
-	if err := runAppsShortcut(t, AppsGet,
-		[]string{"+get", "--app-id", "app_test", "--dry-run", "--as", "user"},
-		factory, stdout); err != nil {
-		t.Fatalf("dry-run err=%v", err)
-	}
-	got := stdout.String()
-	if !strings.Contains(got, "/open-apis/spark/v1/apps/app_test") {
-		t.Fatalf("dry-run missing API path: %s", got)
-	}
-}
-
-func TestAppsGet_PrettyOutput(t *testing.T) {
-	factory, stdout, reg := newAppsExecuteFactory(t)
-	reg.Register(&httpmock.Stub{
-		Method: "GET",
-		URL:    "/open-apis/spark/v1/apps/app_test",
-		Body: map[string]interface{}{
-			"code": 0,
-			"data": map[string]interface{}{
-				"app": map[string]interface{}{
-					"app_id":       "app_test",
-					"app_type":     "html",
-					"name":         "PrettyApp",
-					"description":  "A pretty test app",
-					"is_published": true,
-					"updated_at":   "2026-06-01T12:00:00Z",
-				},
-			},
-		},
-	})
-
-	if err := runAppsShortcut(t, AppsGet,
-		[]string{"+get", "--app-id", "app_test", "--format", "pretty", "--as", "user"},
-		factory, stdout); err != nil {
-		t.Fatalf("execute err=%v", err)
-	}
-	got := stdout.String()
-	for _, want := range []string{"app_id:", "app_type:", "name:", "is_published:"} {
-		if !strings.Contains(got, want) {
-			t.Fatalf("pretty output missing %q: %s", want, got)
-		}
-	}
-}

shortcuts/apps/apps_html_publish.go

@@ -4,32 +4,29 @@
 package apps
 
 import (
-	"bytes"
 	"context"
 	"fmt"
 	"io"
-	"net/http"
 	"path/filepath"
 	"strings"
 
-	"github.com/larksuite/cli/errs"
 	"github.com/larksuite/cli/extension/fileio"
 	"github.com/larksuite/cli/internal/client"
 	"github.com/larksuite/cli/internal/validate"
 	"github.com/larksuite/cli/shortcuts/common"
 )
 
-// AppsHTMLPublish packs --path as tar.gz and publishes an HTML app.
+// AppsHTMLPublish packs --path as tar.gz and uploads + publishes via one multipart POST.
 var AppsHTMLPublish = common.Shortcut{
 	Service:     appsService,
 	Command:     "+html-publish",
-	Description: "Publish HTML to an app (returns url or release_id depending on app type)",
+	Description: "Publish HTML to an app (single multipart POST returns the access URL)",
 	Risk:        "write",
 	Tips: []string{
 		"Example: lark-cli apps +html-publish --app-id <app_id> --path ./dist",
 		"Example: lark-cli apps +html-publish --app-id <app_id> --path ./site --dry-run",
 	},
-	Scopes:    []string{"spark:app:write", "spark:app:read"},
+	Scopes:    []string{"spark:app:write"},
 	AuthTypes: []string{"user"},
 	HasFormat: true,
 	Flags: []common.Flag{
@@ -73,7 +70,7 @@ var AppsHTMLPublish = common.Shortcut{
 		appID := strings.TrimSpace(rctx.Str("app-id"))
 		path := strings.TrimSpace(rctx.Str("path"))
 		dry := common.NewDryRunAPI()
-		dry.Desc("Pack tar.gz and publish HTML app (actual API path determined at runtime by app type; returns url or release_id)")
+		dry.Desc("Upload tar.gz + publish HTML (multipart, returns url)")
 		dry.POST(fmt.Sprintf("%s/apps/%s/upload_and_release_html_code", apiBasePath, validate.EncodePathSegment(appID))).
 			Set("content_type", "multipart/form-data")
 
@@ -122,17 +119,8 @@ var AppsHTMLPublish = common.Shortcut{
 			AppID: strings.TrimSpace(rctx.Str("app-id")),
 			Path:  strings.TrimSpace(rctx.Str("path")),
 		}
-
-		appType := queryAppType(ctx, rctx, spec.AppID)
-
-		var out map[string]interface{}
-		var err error
-		if appType == "modern_html" {
-			out, err = runHTMLPublishTOS(ctx, rctx, spec)
-		} else {
-			client := appsHTMLPublishAPI{runtime: rctx}
-			out, err = runHTMLPublish(ctx, rctx.FileIO(), client, spec)
-		}
+		client := appsHTMLPublishAPI{runtime: rctx}
+		out, err := runHTMLPublish(ctx, rctx.FileIO(), client, spec)
 		if err != nil {
 			return err
 		}
@@ -140,9 +128,6 @@ var AppsHTMLPublish = common.Shortcut{
 			if url, ok := out["url"].(string); ok && url != "" {
 				fmt.Fprintf(w, "url: %s\n", url)
 			}
-			if rid, ok := out["release_id"].(string); ok && rid != "" {
-				fmt.Fprintf(w, "release_id: %s\n", rid)
-			}
 		})
 		return nil
 	},
@@ -229,11 +214,8 @@ func ensureIndexHTML(candidates []htmlPublishCandidate) error {
 		WithHint("index.html is the app entrypoint; for a directory put index.html at the root, or pass a single file named index.html")
 }
 
-// prepareHTMLPublishTarball validates candidates under path and builds a
-// tar.gz payload ready for upload. Shared by runHTMLPublish and
-// runHTMLPublishTOS.
-func prepareHTMLPublishTarball(fio fileio.FileIO, path string) (*htmlPublishTarball, error) {
-	candidates, err := walkHTMLPublishCandidates(fio, path)
+func runHTMLPublish(ctx context.Context, fio fileio.FileIO, publisher appsHTMLPublishClient, spec appsHTMLPublishSpec) (map[string]interface{}, error) {
+	candidates, err := walkHTMLPublishCandidates(fio, spec.Path)
 	if err != nil {
 		return nil, err
 	}
@@ -256,19 +238,12 @@ func prepareHTMLPublishTarball(fio fileio.FileIO, path string) (*htmlPublishTarb
 	if err != nil {
 		return nil, err
 	}
+
 	if tarball.Size > maxHTMLPublishTarballBytes {
 		return nil, appsValidationParamError("--path",
 			"packed tar.gz size %d bytes exceeds %d bytes limit", tarball.Size, maxHTMLPublishTarballBytes).
 			WithHint("reduce --path contents, remove unrelated large files, then retry")
 	}
-	return tarball, nil
-}
-
-func runHTMLPublish(ctx context.Context, fio fileio.FileIO, publisher appsHTMLPublishClient, spec appsHTMLPublishSpec) (map[string]interface{}, error) {
-	tarball, err := prepareHTMLPublishTarball(fio, spec.Path)
-	if err != nil {
-		return nil, err
-	}
 
 	resp, err := publisher.HTMLPublish(ctx, spec.AppID, tarball)
 	if err != nil {
@@ -281,74 +256,3 @@ func runHTMLPublish(ctx context.Context, fio fileio.FileIO, publisher appsHTMLPu
 	}
 	return out, nil
 }
-
-// runHTMLPublishTOS handles the modern_html publish path: validate → tar.gz →
-// call pre_release to get TOS upload URL → upload tar.gz to TOS → return
-// tos_path for +release-create --tos-path.
-func runHTMLPublishTOS(ctx context.Context, rctx *common.RuntimeContext, spec appsHTMLPublishSpec) (map[string]interface{}, error) {
-	tarball, err := prepareHTMLPublishTarball(rctx.FileIO(), spec.Path)
-	if err != nil {
-		return nil, err
-	}
-
-	// Step 1: call pre_release to get TOS upload URL and tos_path.
-	preReleasePath := fmt.Sprintf("%s/apps/%s/pre_release", apiBasePath, validate.EncodePathSegment(spec.AppID))
-	preData, err := rctx.CallAPITyped("GET", preReleasePath, nil, nil)
-	if err != nil {
-		return nil, err
-	}
-	kvs, _ := preData["kvs"].([]interface{})
-	if len(kvs) == 0 {
-		return nil, appsSubprocessEnvelopeError("pre_release returned no kvs")
-	}
-	kvm := make(map[string]string, len(kvs))
-	for _, item := range kvs {
-		kv, _ := item.(map[string]interface{})
-		if kv == nil {
-			continue
-		}
-		k, _ := kv["key"].(string)
-		v, _ := kv["value"].(string)
-		if k != "" {
-			kvm[k] = v
-		}
-	}
-	uploadURL := kvm["upload_url"]
-	tosPath := kvm["tos_path"]
-	if uploadURL == "" || tosPath == "" {
-		return nil, appsSubprocessEnvelopeError("pre_release kvs missing upload_url or tos_path")
-	}
-
-	// Step 2: upload tar.gz to TOS via presigned URL (bypasses Lark gateway).
-	//nolint:forbidigo // presigned TOS upload bypasses the Lark gateway — raw http is required; not a Lark API call, so RuntimeContext.DoAPI does not apply.
-	req, err := http.NewRequestWithContext(ctx, http.MethodPut, uploadURL, bytes.NewReader(tarball.Body))
-	if err != nil {
-		return nil, errs.NewNetworkError(errs.SubtypeNetworkTransport, "build TOS upload request").WithCause(err)
-	}
-	req.ContentLength = tarball.Size
-	req.Header.Set("Content-Type", "application/gzip")
-	resp, err := newFileTransferClient().Do(req) //nolint:forbidigo // presigned TOS upload, see above.
-	if err != nil {
-		return nil, errs.NewNetworkError(errs.SubtypeNetworkTransport, "TOS upload failed").WithCause(err).WithRetryable()
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode >= 400 {
-		if resp.StatusCode >= 500 {
-			return nil, errs.NewNetworkError(errs.SubtypeNetworkServer, "TOS upload failed: HTTP %d", resp.StatusCode).WithRetryable()
-		}
-		return nil, errs.NewNetworkError(errs.SubtypeNetworkTransport, "TOS upload failed: HTTP %d", resp.StatusCode)
-	}
-
-	// Step 3: call release-create with tos_path to trigger deployment.
-	releasePath := fmt.Sprintf(releaseCreatePath, validate.EncodePathSegment(spec.AppID))
-	releaseData, err := rctx.CallAPITyped("POST", releasePath, nil, map[string]interface{}{
-		"tos_path": tosPath,
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	return map[string]interface{}{
-		"release_id": common.GetString(releaseData, "release_id"),
-	}, nil
-}

shortcuts/apps/apps_html_publish_test.go

@@ -6,21 +6,10 @@ package apps
 import (
 	"context"
 	"errors"
-	"net/http"
-	"net/http/httptest"
 	"os"
 	"path/filepath"
 	"strings"
 	"testing"
-
-	"github.com/spf13/cobra"
-
-	"github.com/larksuite/cli/errs"
-	"github.com/larksuite/cli/extension/fileio"
-	"github.com/larksuite/cli/internal/cmdutil"
-	"github.com/larksuite/cli/internal/core"
-	"github.com/larksuite/cli/internal/httpmock"
-	"github.com/larksuite/cli/shortcuts/common"
 )
 
 type fakeAppsHTMLPublishClient struct {
@@ -64,7 +53,7 @@ func TestRunHTMLPublish_HappyPath(t *testing.T) {
 }
 
 func TestRunHTMLPublish_OnlyURLInEnvelope(t *testing.T) {
-	// Pin 概要设计 §5.3 不变量 4 "同步语义不会变成异步" (legacy html path only):
+	// Pin 概要设计 §5.3 不变量 4 "同步语义不会变成异步":
 	// envelope 只含 url，未来若有人加 status / release_id 字段会被这个测试拦截。
 	site := writeAppsSampleSite(t)
 	fake := &fakeAppsHTMLPublishClient{
@@ -593,226 +582,3 @@ func TestRunHTMLPublish_IgnoresOversizeNonHTML(t *testing.T) {
 		t.Fatalf("client should be called; calls=%v", fake.calls)
 	}
 }
-
-// ── runHTMLPublishTOS tests ──
-
-// permissiveFIOProvider wraps permissiveFIO as a fileio.Provider for tests
-// that call runHTMLPublishTOS (which obtains FileIO via rctx.FileIO()).
-type permissiveFIOProvider struct{}
-
-func (permissiveFIOProvider) Name() string                                { return "test-permissive" }
-func (permissiveFIOProvider) ResolveFileIO(context.Context) fileio.FileIO { return permissiveFIO{} }
-
-// newTOSTestRuntime builds a RuntimeContext with httpmock registry and a
-// permissive FileIO provider, ready for runHTMLPublishTOS unit tests.
-func newTOSTestRuntime(t *testing.T) (*common.RuntimeContext, *httpmock.Registry) {
-	t.Helper()
-	t.Setenv("HOME", t.TempDir())
-	t.Setenv("LARKSUITE_CLI_CONFIG_DIR", t.TempDir())
-	cfg := &core.CliConfig{
-		AppID:      "test-app-" + strings.ToLower(t.Name()),
-		AppSecret:  "test-secret",
-		Brand:      core.BrandFeishu,
-		UserOpenId: "ou_test",
-	}
-	factory, _, _, reg := cmdutil.TestFactory(t, cfg)
-	factory.FileIOProvider = permissiveFIOProvider{}
-	rt := common.TestNewRuntimeContextForAPI(
-		context.Background(),
-		&cobra.Command{Use: "+tos-test"},
-		cfg, factory, core.AsUser,
-	)
-	return rt, reg
-}
-
-func TestRunHTMLPublishTOS_Success(t *testing.T) {
-	site := writeAppsSampleSite(t)
-	rt, reg := newTOSTestRuntime(t)
-
-	// Start httptest server to accept the TOS upload.
-	tosServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.Method != http.MethodPut {
-			t.Errorf("TOS upload method = %s, want PUT", r.Method)
-		}
-		if ct := r.Header.Get("Content-Type"); ct != "application/gzip" {
-			t.Errorf("TOS upload Content-Type = %s, want application/gzip", ct)
-		}
-		w.WriteHeader(http.StatusOK)
-	}))
-	defer tosServer.Close()
-
-	// Register pre_release API stub.
-	reg.Register(&httpmock.Stub{
-		Method: "GET",
-		URL:    "/open-apis/spark/v1/apps/app_tos/pre_release",
-		Body: map[string]interface{}{
-			"code": float64(0),
-			"data": map[string]interface{}{
-				"kvs": []interface{}{
-					map[string]interface{}{"key": "upload_url", "value": tosServer.URL},
-					map[string]interface{}{"key": "tos_path", "value": "tos://bucket/key"},
-				},
-			},
-		},
-	})
-
-	// Register release-create API stub.
-	reg.Register(&httpmock.Stub{
-		Method: "POST",
-		URL:    "/open-apis/spark/v1/apps/app_tos/releases",
-		Body: map[string]interface{}{
-			"code": float64(0),
-			"data": map[string]interface{}{
-				"release_id": "rel_123",
-				"status":     "publishing",
-			},
-		},
-	})
-
-	out, err := runHTMLPublishTOS(context.Background(), rt, appsHTMLPublishSpec{
-		AppID: "app_tos",
-		Path:  site,
-	})
-	if err != nil {
-		t.Fatalf("err=%v", err)
-	}
-	if out["release_id"] != "rel_123" {
-		t.Fatalf("release_id=%v, want rel_123", out["release_id"])
-	}
-}
-
-func TestRunHTMLPublishTOS_MissingIndexHTML(t *testing.T) {
-	dir := t.TempDir()
-	// Create a file that is NOT named index.html.
-	if err := os.WriteFile(filepath.Join(dir, "foo.html"), []byte("<html></html>"), 0o644); err != nil {
-		t.Fatalf("write: %v", err)
-	}
-
-	rt, _ := newTOSTestRuntime(t)
-	_, err := runHTMLPublishTOS(context.Background(), rt, appsHTMLPublishSpec{
-		AppID: "app_tos",
-		Path:  dir,
-	})
-	if err == nil {
-		t.Fatalf("expected error for missing index.html")
-	}
-	if !strings.Contains(err.Error(), "index.html") {
-		t.Fatalf("error should mention index.html, got: %v", err)
-	}
-}
-
-func TestRunHTMLPublishTOS_PreReleaseError(t *testing.T) {
-	site := writeAppsSampleSite(t)
-	rt, reg := newTOSTestRuntime(t)
-
-	// Register pre_release API stub that returns an error code.
-	reg.Register(&httpmock.Stub{
-		Method: "GET",
-		URL:    "/open-apis/spark/v1/apps/app_tos/pre_release",
-		Body: map[string]interface{}{
-			"code": float64(99999),
-			"msg":  "internal server error",
-		},
-	})
-
-	_, err := runHTMLPublishTOS(context.Background(), rt, appsHTMLPublishSpec{
-		AppID: "app_tos",
-		Path:  site,
-	})
-	if err == nil {
-		t.Fatalf("expected error from pre_release API failure")
-	}
-}
-
-func TestRunHTMLPublishTOS_MissingParams(t *testing.T) {
-	site := writeAppsSampleSite(t)
-	rt, reg := newTOSTestRuntime(t)
-
-	// Register pre_release API stub that returns empty kvs list.
-	reg.Register(&httpmock.Stub{
-		Method: "GET",
-		URL:    "/open-apis/spark/v1/apps/app_tos/pre_release",
-		Body: map[string]interface{}{
-			"code": float64(0),
-			"data": map[string]interface{}{
-				"kvs": []interface{}{},
-			},
-		},
-	})
-
-	_, err := runHTMLPublishTOS(context.Background(), rt, appsHTMLPublishSpec{
-		AppID: "app_tos",
-		Path:  site,
-	})
-	if err == nil {
-		t.Fatalf("expected error for empty kvs")
-	}
-	problem := requireAppsProblem(t, err, errs.CategoryInternal)
-	if !strings.Contains(problem.Message, "no kvs") {
-		t.Fatalf("error should mention 'no kvs', got: %q", problem.Message)
-	}
-}
-
-func TestRunHTMLPublishTOS_MissingParamsObject(t *testing.T) {
-	site := writeAppsSampleSite(t)
-	rt, reg := newTOSTestRuntime(t)
-
-	// Register pre_release API stub that returns no kvs key at all.
-	reg.Register(&httpmock.Stub{
-		Method: "GET",
-		URL:    "/open-apis/spark/v1/apps/app_tos/pre_release",
-		Body: map[string]interface{}{
-			"code": float64(0),
-			"data": map[string]interface{}{},
-		},
-	})
-
-	_, err := runHTMLPublishTOS(context.Background(), rt, appsHTMLPublishSpec{
-		AppID: "app_tos",
-		Path:  site,
-	})
-	if err == nil {
-		t.Fatalf("expected error for missing kvs")
-	}
-	problem := requireAppsProblem(t, err, errs.CategoryInternal)
-	if !strings.Contains(problem.Message, "no kvs") {
-		t.Fatalf("error should mention 'no kvs', got: %q", problem.Message)
-	}
-}
-
-func TestRunHTMLPublishTOS_UploadFails(t *testing.T) {
-	site := writeAppsSampleSite(t)
-	rt, reg := newTOSTestRuntime(t)
-
-	// Start httptest server that returns 500.
-	tosServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
-		w.WriteHeader(http.StatusInternalServerError)
-	}))
-	defer tosServer.Close()
-
-	reg.Register(&httpmock.Stub{
-		Method: "GET",
-		URL:    "/open-apis/spark/v1/apps/app_tos/pre_release",
-		Body: map[string]interface{}{
-			"code": float64(0),
-			"data": map[string]interface{}{
-				"kvs": []interface{}{
-					map[string]interface{}{"key": "upload_url", "value": tosServer.URL},
-					map[string]interface{}{"key": "tos_path", "value": "tos://bucket/key"},
-				},
-			},
-		},
-	})
-
-	_, err := runHTMLPublishTOS(context.Background(), rt, appsHTMLPublishSpec{
-		AppID: "app_tos",
-		Path:  site,
-	})
-	if err == nil {
-		t.Fatalf("expected error from TOS upload failure")
-	}
-	problem := requireAppsProblem(t, err, errs.CategoryNetwork)
-	if !strings.Contains(problem.Message, "500") {
-		t.Fatalf("error should mention HTTP 500, got: %q", problem.Message)
-	}
-}

shortcuts/apps/apps_init.go

@@ -11,7 +11,6 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
-
 	"strings"
 	"unicode"
 
@@ -40,57 +39,16 @@ const (
 
 const (
 	miaodaCLIPkg    = "@lark-apaas/miaoda-cli@latest"
-	npmRegistry     = "https://registry.npmmirror.com"
+	defaultTemplate = "nestjs-react-fullstack"
 	metaRelPath     = ".spark/meta.json"
 	steeringRelPath = ".agent/skills/steering"
 	seedReadme      = "README.md"
 )
 
-// Fallback committer identity written to the cloned repo's LOCAL git config when
-// no user.name/user.email is resolvable (from local, global, or system config).
-// The scaffold's `git commit` would otherwise fail with "please tell me who you
-// are"; an existing identity (e.g. the developer's global config) is respected.
-const (
-	defaultGitUserName  = "lark-cli-bot"
-	defaultGitUserEmail = "lark-cli-bot@miaoda.com"
-)
-
 // initRunner is the commandRunner used by +init. Package-level so unit tests
 // can swap in a fakeCommandRunner. Production uses execCommandRunner.
 var initRunner commandRunner = execCommandRunner{}
 
-// appTypePolicy captures the per-app-type control points +init toggles, keeping
-// each knob out of the inline `appType == "..."` checks that would otherwise be
-// scattered through the flow. Add a field here (and set it in appTypePolicies)
-// for each new control point rather than threading another type comparison
-// through appsInitExecute.
-type appTypePolicy struct {
-	// skipInstall passes --skip-install to `npx ... app init`, so scaffolding
-	// runs no dependency install.
-	skipInstall bool
-	// skipEnvPull skips the post-init `+env-pull` step, on both the fresh-init
-	// tail and the already-initialized refresh path.
-	skipEnvPull bool
-	// skipSkillsSync skips the conditional `npx ... skills sync --local` step on
-	// the non-empty (`app sync`) scaffold path.
-	skipSkillsSync bool
-}
-
-// appTypePolicies maps an app_type to its +init control strategy. Types absent
-// from the map get the zero-value policy (install runs, env is pulled, skills
-// are synced).
-var appTypePolicies = map[string]appTypePolicy{
-	// modern_html is a static HTML site: no dependencies to install, no startup
-	// env vars to pull, and no steering skills to sync.
-	"modern_html": {skipInstall: true, skipEnvPull: true, skipSkillsSync: true},
-}
-
-// policyForAppType returns the +init control strategy for appType. Unlisted
-// types (including "") get the zero-value policy.
-func policyForAppType(appType string) appTypePolicy {
-	return appTypePolicies[appType]
-}
-
 // AppsInit initializes an app's code and local development environment.
 var AppsInit = common.Shortcut{
 	Service:     appsService,
@@ -101,15 +59,13 @@ var AppsInit = common.Shortcut{
 		"Example: lark-cli apps +init --app-id <app_id> --dir <dir>",
 		"Example: lark-cli apps +init --app-id <app_id> --dir <dir> --dry-run",
 	},
-	// +init calls queryAppType (GET /apps/{id}) which requires spark:app:read;
-	// the scope is declared as conditional since the call is non-fatal.
-	// The git credential subprocess enforces its own scopes independently.
-	// Explicit []string{} (not nil) per the convention enforced by
-	// TestAllShortcutsScopesNotNil.
-	Scopes:            []string{},
-	ConditionalScopes: []string{"spark:app:read"},
-	AuthTypes:         []string{"user"},
-	HasFormat:         true,
+	// +init makes no direct lark API calls (it shells out to the
+	// +git-credential-init subprocess, which enforces its own scopes), so it
+	// declares no scopes of its own. Explicit []string{} (not nil) per the
+	// convention enforced by TestAllShortcutsScopesNotNil.
+	Scopes:    []string{},
+	AuthTypes: []string{"user"},
+	HasFormat: true,
 	Flags: []common.Flag{
 		// NOTE: --app-id is intentionally NOT Required:true. The framework maps
 		// Required:true to cobra's MarkFlagRequired, whose error is plain-text
@@ -119,28 +75,24 @@ var AppsInit = common.Shortcut{
 		// check lives in Validate (typed validation error -> exit 2).
 		{Name: "app-id", Desc: "app ID"},
 		{Name: "dir", Desc: "clone target directory; absolute or relative path (default ./<app-id>)"},
-		{Name: "source-path", Desc: "path to existing source files (e.g. HTML output from an agent) to incorporate into the initialized project"},
+		{Name: "template", Desc: "code-init template for an empty repo; optional — if omitted, derived from the app's tech stack"},
 	},
 	Validate: func(ctx context.Context, rctx *common.RuntimeContext) error {
 		if strings.TrimSpace(rctx.Str("app-id")) == "" {
 			return appsValidationParamError("--app-id", "--app-id is required")
 		}
-		if sp := strings.TrimSpace(rctx.Str("source-path")); sp != "" {
-			if err := charcheck.RejectControlChars(sp, "--source-path"); err != nil {
-				return appsValidationParamError("--source-path", "%v", err).WithCause(err)
-			}
-		}
 		return nil
 	},
 	DryRun: func(ctx context.Context, rctx *common.RuntimeContext) *common.DryRunAPI {
 		appID := strings.TrimSpace(rctx.Str("app-id"))
+		template := resolveTemplate(rctx, appID)
 		dry := common.NewDryRunAPI().
 			Desc("Initialize app code (credential-init, clone, checkout, npx code-init, optional commit/push)").
 			Set("credential_init", fmt.Sprintf("apps +git-credential-init --app-id %s --format json", appID)).
 			Set("checkout", "git checkout "+defaultInitBranch).
-			Set("scaffold", fmt.Sprintf("empty repo: npx -y --prefer-online %s app init --app-type <appType> --app-id %s; non-empty: npx -y --prefer-online %s app sync + .spark/meta.json app_id patch + conditional skills sync --local", miaodaCLIPkg, appID, miaodaCLIPkg)).
+			Set("scaffold", fmt.Sprintf("empty repo: npx -y --prefer-online %s app init --template %s --app-id %s; non-empty: npx -y --prefer-online %s app sync + .spark/meta.json app_id patch + conditional skills sync --local", miaodaCLIPkg, template, appID, miaodaCLIPkg)).
 			Set("commit_push", "conditional: git add -A + commit + push origin "+defaultInitBranch+" when the working tree has changes").
-			Set("template", "derived from queryAppType (fallback: full_stack)").
+			Set("template", template).
 			Set("env_pull", fmt.Sprintf("apps +env-pull --app-id %s --project-path <clone_path> --format json (after successful init)", appID))
 		dir, err := resolveTargetPath(rctx, appID)
 		if err != nil {
@@ -170,6 +122,20 @@ func defaultCloneDir(appID string) string {
 	return filepath.Join(".", appID)
 }
 
+// resolveTemplate returns the scaffold template for an empty-repo `app init`.
+// An explicit --template wins. When omitted, it should be derived from the
+// app's tech stack.
+// TODO(apps-init): look up the app by appID via the apps API (e.g. `apps +list`
+// or a get-app endpoint), read its tech stack, and map tech-stack -> template
+// through a (future) enum. Until that lands, fall back to defaultTemplate.
+func resolveTemplate(rctx *common.RuntimeContext, appID string) string {
+	if t := strings.TrimSpace(rctx.Str("template")); t != "" {
+		return t
+	}
+	// TODO(apps-init): derive from app tech stack (apps API + enum mapping).
+	return defaultTemplate
+}
+
 // initLogf writes a one-line progress message to stderr. stdout stays reserved
 // for the structured JSON envelope, so progress never pollutes it. Callers must
 // never pass a raw repository_url (it may embed a token) — pass step names,
@@ -328,34 +294,6 @@ func ensureMetaAppID(dir, appID string) error {
 	return nil
 }
 
-// ensureGitIdentity guarantees the cloned repo has a committer identity so the
-// scaffold's `git commit` cannot fail with "please tell me who you are". It sets
-// the repo-LOCAL user.name/user.email to the lark-cli-bot defaults ONLY when
-// each is not already resolvable from local/global/system config, so a
-// developer's existing identity is never overwritten. Each key is handled
-// independently (a machine with only user.name set still gets a default email).
-func ensureGitIdentity(ctx context.Context, dir string) error {
-	if err := ensureGitConfigValue(ctx, dir, "user.name", defaultGitUserName); err != nil {
-		return err
-	}
-	return ensureGitConfigValue(ctx, dir, "user.email", defaultGitUserEmail)
-}
-
-// ensureGitConfigValue sets <key>=fallback in the repo-local git config when key
-// resolves to no value. `git config --get` exits non-zero (or prints nothing)
-// when the key is unset at every scope; any resolved value (including one
-// inherited from global/system) is left untouched.
-func ensureGitConfigValue(ctx context.Context, dir, key, fallback string) error {
-	stdout, _, err := initRunner.Run(ctx, dir, "git", "config", "--get", key)
-	if err == nil && strings.TrimSpace(stdout) != "" {
-		return nil // already configured at some scope — respect it
-	}
-	if _, stderr, e := initRunner.Run(ctx, dir, "git", "config", key, fallback); e != nil {
-		return appsExternalToolError(e, "git config %s failed: %s", key, gitErr(stderr, e))
-	}
-	return nil
-}
-
 // hasSteeringSkills reports whether <dir>/.agent/skills/steering exists as a dir.
 func hasSteeringSkills(dir string) bool {
 	info, err := os.Stat(filepath.Join(dir, steeringRelPath)) //nolint:forbidigo // shortcuts cannot import internal/vfs (depguard rule shortcuts-no-vfs); path is under the validated clone dir, and FileIO.Stat rejects absolute paths.
@@ -388,54 +326,34 @@ func isEmptyRepo(ctx context.Context, dir string) (bool, error) {
 // runScaffold runs the npx scaffolding step inside the cloned repo (cwd=dir).
 // Empty repo -> `app init`; non-empty -> `app sync` + meta app_id patch +
 // conditional `skills sync`. Returns "init" or "upgrade".
-func runScaffold(ctx context.Context, dir, appID, appType, sourcePath string) (string, error) {
+func runScaffold(ctx context.Context, dir, appID, template string) (string, error) {
 	empty, err := isEmptyRepo(ctx, dir)
 	if err != nil {
 		return "", err
 	}
 	if empty {
-		args := scaffoldInitArgs(appType, appID, sourcePath)
-		if _, stderr, err := initRunner.Run(ctx, dir, "npx", args...); err != nil {
+		// isEmptyRepo treats a repo with no tracked files — or only the backend's
+		// seed README.md — as empty. If other seed files (e.g. .gitignore) can
+		// appear, extend isEmptyRepo's allow-list accordingly.
+		if _, stderr, err := initRunner.Run(ctx, dir, "npx", "-y", "--prefer-online", miaodaCLIPkg, "app", "init", "--template", template, "--app-id", appID); err != nil {
 			return "", appsExternalToolError(err, "npx app init failed: %s", gitErr(stderr, err))
 		}
 		return scaffoldKindInit, nil
 	}
-	if _, stderr, err := initRunner.Run(ctx, dir, "npx", "-y", "--prefer-online", "--registry", npmRegistry, miaodaCLIPkg, "app", "sync"); err != nil {
+	if _, stderr, err := initRunner.Run(ctx, dir, "npx", "-y", "--prefer-online", miaodaCLIPkg, "app", "sync"); err != nil {
 		return "", appsExternalToolError(err, "npx app sync failed: %s", gitErr(stderr, err))
 	}
 	if err := ensureMetaAppID(dir, appID); err != nil {
 		return "", err
 	}
-	if !policyForAppType(appType).skipSkillsSync && !hasSteeringSkills(dir) {
-		if _, stderr, err := initRunner.Run(ctx, dir, "npx", "-y", "--prefer-online", "--registry", npmRegistry, miaodaCLIPkg, "skills", "sync", "--local"); err != nil {
+	if !hasSteeringSkills(dir) {
+		if _, stderr, err := initRunner.Run(ctx, dir, "npx", "-y", "--prefer-online", miaodaCLIPkg, "skills", "sync", "--local"); err != nil {
 			return "", appsExternalToolError(err, "npx skills sync failed: %s", gitErr(stderr, err))
 		}
 	}
 	return scaffoldKindUpgrade, nil
 }
 
-// scaffoldInitArgs builds the npx argument list for `app init`.
-// appType from queryAppType is passed as --app-type; falls back to "full_stack"
-// when empty. sourcePath is appended as --source-path when non-empty.
-// --skip-install is appended per the app_type's policy (see appTypePolicy):
-// types whose policy sets skipInstall (e.g. modern_html) skip the dependency
-// install; others run it as usual.
-func scaffoldInitArgs(appType, appID, sourcePath string) []string {
-	base := []string{"-y", "--prefer-online", "--registry", npmRegistry, miaodaCLIPkg, "app", "init"}
-	at := appType
-	if at == "" {
-		at = "full_stack"
-	}
-	base = append(base, "--app-type", at, "--app-id", appID)
-	if sourcePath != "" {
-		base = append(base, "--source-path", sourcePath)
-	}
-	if policyForAppType(appType).skipInstall {
-		base = append(base, "--skip-install")
-	}
-	return base
-}
-
 // parseRepoURLFromEnvelope extracts data.repository_url from a lark-cli JSON
 // envelope ({"ok":true,"data":{"repository_url":"..."}}). The field name
 // matches the contract emitted by `apps +git-credential-init`.
@@ -527,9 +445,6 @@ func appsInitExecute(ctx context.Context, rctx *common.RuntimeContext) error {
 		return err
 	}
 
-	appType := queryAppType(ctx, rctx, appID)
-	policy := policyForAppType(appType)
-
 	// Already-initialized short-circuit: a dir containing .spark/meta.json is an
 	// initialized app repo -> skip clone/scaffold/commit, but still refresh
 	// the local env so a re-run picks up the latest startup env vars.
@@ -542,19 +457,6 @@ func appsInitExecute(ctx context.Context, rctx *common.RuntimeContext) error {
 			"committed":  false,
 			"pushed":     false,
 		}
-		if appType != "" {
-			out["app_type"] = appType
-		}
-		if policy.skipEnvPull {
-			out["env_pulled"] = false
-			out["env_pull_skipped"] = true
-			out["message"] = "Repository already initialized. You can start developing."
-			rctx.OutFormat(out, nil, func(w io.Writer) {
-				fmt.Fprintf(w, "✓ Already initialized at %s\n", dir)
-				fmt.Fprintln(w, "仓库已初始化完成，可以开始开发了。")
-			})
-			return nil
-		}
 		initLogf(rctx, "Pulling local environment variables...")
 		envFile, envPullErr := pullEnv(ctx, rctx, appID, dir)
 		envPulled := envPullErr == ""
@@ -612,21 +514,8 @@ func appsInitExecute(ctx context.Context, rctx *common.RuntimeContext) error {
 		return appsExternalToolError(err, "git checkout %s failed: %s", defaultInitBranch, gitErr(stderr, err))
 	}
 
-	// Ensure a committer identity exists before the scaffold commit; only sets
-	// repo-local defaults when none is configured (existing identity is kept).
-	if err := ensureGitIdentity(ctx, dir); err != nil {
-		return err
-	}
-
 	initLogf(rctx, "Initializing app code (running miaoda-cli)...")
-	sourcePath := strings.TrimSpace(rctx.Str("source-path"))
-	if sourcePath != "" {
-		sourcePath, err = filepath.Abs(sourcePath) //nolint:forbidigo // shortcuts cannot import internal/vfs (depguard rule shortcuts-no-vfs); sourcePath is control-char-validated in Validate.
-		if err != nil {
-			return appsValidationParamError("--source-path", "--source-path cannot be resolved: %v", err)
-		}
-	}
-	scaffold, err := runScaffold(ctx, dir, appID, appType, sourcePath)
+	scaffold, err := runScaffold(ctx, dir, appID, resolveTemplate(rctx, appID))
 	if err != nil {
 		return err
 	}
@@ -641,6 +530,15 @@ func appsInitExecute(ctx context.Context, rctx *common.RuntimeContext) error {
 		initLogf(rctx, "Working tree clean — skipped commit/push")
 	}
 
+	initLogf(rctx, "Pulling local environment variables...")
+	envFile, envPullErr := pullEnv(ctx, rctx, appID, dir)
+	envPulled := envPullErr == ""
+	if envPulled {
+		initLogf(rctx, "Local environment written to %s", envFile)
+	} else {
+		initLogf(rctx, "Could not pull local env vars: %s", envPullErr)
+	}
+
 	out := map[string]interface{}{
 		"app_id":         appID,
 		"repository_url": redactURLCredentials(repoURL),
@@ -649,38 +547,21 @@ func appsInitExecute(ctx context.Context, rctx *common.RuntimeContext) error {
 		"scaffold":       scaffold,
 		"committed":      committed,
 		"pushed":         pushed,
+		"env_pulled":     envPulled,
 		"message":        "Repository initialized. You can start developing.",
 	}
-	if appType != "" {
-		out["app_type"] = appType
-	}
-
-	if policy.skipEnvPull {
-		out["env_pulled"] = false
-		out["env_pull_skipped"] = true
+	if envPulled {
+		out["env_file"] = envFile
 	} else {
-		initLogf(rctx, "Pulling local environment variables...")
-		envFile, envPullErr := pullEnv(ctx, rctx, appID, dir)
-		envPulled := envPullErr == ""
-		out["env_pulled"] = envPulled
-		if envPulled {
-			initLogf(rctx, "Local environment written to %s", envFile)
-			out["env_file"] = envFile
-		} else {
-			initLogf(rctx, "Could not pull local env vars: %s", envPullErr)
-			out["env_pull_error"] = envPullErr
-			out["message"] = fmt.Sprintf("Repository initialized. Could not pull local env vars automatically — run `lark-cli apps +env-pull --app-id %s` to retry.", appID)
-		}
+		out["env_pull_error"] = envPullErr
+		out["message"] = fmt.Sprintf("Repository initialized. Could not pull local env vars automatically — run `lark-cli apps +env-pull --app-id %s` to retry.", appID)
 	}
-
 	rctx.OutFormat(out, nil, func(w io.Writer) {
 		fmt.Fprintf(w, "✓ Repository initialized at %s\n", dir)
 		fmt.Fprintf(w, "  branch: %s\n  scaffold: %s\n", defaultInitBranch, scaffold)
-		if policy.skipEnvPull {
-			fmt.Fprintln(w, "  (env pull skipped)")
-		} else if envPulled, _ := out["env_pulled"].(bool); envPulled {
-			fmt.Fprintf(w, "✓ Local environment written to %s\n", out["env_file"])
-		} else if envPullErr, ok := out["env_pull_error"].(string); ok {
+		if envPulled {
+			fmt.Fprintf(w, "✓ Local environment written to %s\n", envFile)
+		} else {
 			fmt.Fprintf(w, "⚠ Could not pull local env vars: %s\n", envPullErr)
 			fmt.Fprintf(w, "  run `lark-cli apps +env-pull --app-id %s` to retry\n", appID)
 		}

shortcuts/apps/apps_init_test.go

@@ -20,20 +20,46 @@ import (
 	"github.com/larksuite/cli/errs"
 	"github.com/larksuite/cli/internal/cmdutil"
 	"github.com/larksuite/cli/internal/core"
-	"github.com/larksuite/cli/internal/httpmock"
 	"github.com/larksuite/cli/shortcuts/common"
 )
 
 // testRuntimeWithDir builds a *common.RuntimeContext whose backing cobra command
-// has a string flag "dir" (=dirFlag) registered, mirroring how +init reads it
-// at runtime via rctx.Str.
+// has string flags "dir" (=dirFlag) and "template" (=defaultTemplate) registered,
+// mirroring how +init reads them at runtime via rctx.Str.
 func testRuntimeWithDir(t *testing.T, dirFlag string) *common.RuntimeContext {
 	t.Helper()
 	cmd := &cobra.Command{Use: "init"}
 	cmd.Flags().String("dir", dirFlag, "")
+	cmd.Flags().String("template", defaultTemplate, "")
 	return common.TestNewRuntimeContext(cmd, nil)
 }
 
+// testRuntimeWithTemplate builds a *common.RuntimeContext with "dir" and
+// "template" string flags registered, mirroring +init's runtime flag set. The
+// template flag is registered with an empty default (matching the real flag,
+// which no longer carries Default: defaultTemplate); pass tpl="" to model an
+// omitted --template and a non-empty tpl to model an explicit one.
+func testRuntimeWithTemplate(t *testing.T, dirFlag, tpl string) *common.RuntimeContext {
+	t.Helper()
+	cmd := &cobra.Command{Use: "init"}
+	cmd.Flags().String("dir", dirFlag, "")
+	cmd.Flags().String("template", tpl, "")
+	return common.TestNewRuntimeContext(cmd, nil)
+}
+
+func TestResolveTemplate(t *testing.T) {
+	if got := resolveTemplate(testRuntimeWithTemplate(t, "", "foo"), "app_x"); got != "foo" {
+		t.Errorf("explicit --template = %q, want foo", got)
+	}
+	if got := resolveTemplate(testRuntimeWithTemplate(t, "", ""), "app_x"); got != defaultTemplate {
+		t.Errorf("omitted --template = %q, want fallback %q", got, defaultTemplate)
+	}
+	// Whitespace-only --template is treated as omitted -> fallback.
+	if got := resolveTemplate(testRuntimeWithTemplate(t, "", "   "), "app_x"); got != defaultTemplate {
+		t.Errorf("whitespace --template = %q, want fallback %q", got, defaultTemplate)
+	}
+}
+
 func TestResolveTargetPath(t *testing.T) {
 	got, err := resolveTargetPath(testRuntimeWithDir(t, ""), "app_x")
 	if err != nil {
@@ -235,12 +261,12 @@ func TestRunScaffold_EmptyRepo(t *testing.T) {
 		t.Run("ls="+ls, func(t *testing.T) {
 			f := &fakeCommandRunner{results: map[string]fakeCallResult{"git ls-files": {stdout: ls}}}
 			withFakeRunner(t, f)
-			kind, err := runScaffold(context.Background(), t.TempDir(), "app_x", "", "")
+			kind, err := runScaffold(context.Background(), t.TempDir(), "app_x", "nestjs-react-fullstack")
 			if err != nil || kind != "init" {
 				t.Fatalf("ls=%q kind=%q err=%v, want init", ls, kind, err)
 			}
 			c := findCall(f.calls, "npx", "-y")
-			if c == nil || !containsAll(c, "-y", "--prefer-online", miaodaCLIPkg, "app", "init", "--app-type", "full_stack", "--app-id", "app_x") {
+			if c == nil || !containsAll(c, "-y", "--prefer-online", miaodaCLIPkg, "app", "init", "--template", "nestjs-react-fullstack", "--app-id", "app_x") {
 				t.Errorf("app init not invoked with expected args: %v", f.calls)
 			}
 			if c != nil && containsAll(c, "--local") {
@@ -254,7 +280,7 @@ func TestRunScaffold_NonEmpty_SyncsWhenNoSteering(t *testing.T) {
 	dir := t.TempDir() // no steering dir, no meta.json
 	f := &fakeCommandRunner{results: map[string]fakeCallResult{"git ls-files": {stdout: "src/x.ts\n"}}}
 	withFakeRunner(t, f)
-	kind, err := runScaffold(context.Background(), dir, "app_x", "", "")
+	kind, err := runScaffold(context.Background(), dir, "app_x", "nestjs-react-fullstack")
 	if err != nil || kind != "upgrade" {
 		t.Fatalf("kind=%q err=%v, want upgrade", kind, err)
 	}
@@ -268,24 +294,12 @@ func TestRunScaffold_NonEmpty_SyncsWhenNoSteering(t *testing.T) {
 	}
 }
 
-func TestRunScaffold_NonEmpty_ModernHTML_SkipsSyncEvenWithoutSteering(t *testing.T) {
-	dir := t.TempDir() // no steering dir → sync would run for non-modern_html
-	f := &fakeCommandRunner{results: map[string]fakeCallResult{"git ls-files": {stdout: "src/x.ts\n"}}}
-	withFakeRunner(t, f)
-	if _, err := runScaffold(context.Background(), dir, "app_x", "modern_html", ""); err != nil {
-		t.Fatal(err)
-	}
-	if findCallArg(f.calls, "npx", "skills", "sync") != nil {
-		t.Error("skills sync must be skipped for modern_html regardless of steering dir")
-	}
-}
-
 func TestRunScaffold_NonEmpty_SkipsSyncWhenSteeringExists(t *testing.T) {
 	dir := t.TempDir()
 	os.MkdirAll(filepath.Join(dir, steeringRelPath), 0o755)
 	f := &fakeCommandRunner{results: map[string]fakeCallResult{"git ls-files": {stdout: "src/x.ts\n"}}}
 	withFakeRunner(t, f)
-	if _, err := runScaffold(context.Background(), dir, "app_x", "", ""); err != nil {
+	if _, err := runScaffold(context.Background(), dir, "app_x", "nestjs-react-fullstack"); err != nil {
 		t.Fatal(err)
 	}
 	if findCallArg(f.calls, "npx", "skills", "sync") != nil {
@@ -299,7 +313,7 @@ func TestRunScaffold_AppInitFailure(t *testing.T) {
 		"npx -y":       {stderr: "boom", err: errors.New("exit 1")},
 	}}
 	withFakeRunner(t, f)
-	if _, err := runScaffold(context.Background(), t.TempDir(), "app_x", "", ""); err == nil {
+	if _, err := runScaffold(context.Background(), t.TempDir(), "app_x", "nestjs-react-fullstack"); err == nil {
 		t.Error("app init failure must propagate")
 	}
 }
@@ -328,13 +342,13 @@ func TestAppsInit_EmptyRepo_EndToEnd(t *testing.T) {
 	if _, ok := data["npx_skipped"]; ok {
 		t.Error("npx_skipped must be removed")
 	}
-	// appType is empty, so scaffoldInitArgs falls back to "full_stack"
-	// and `app init` must still receive --app-type full_stack.
+	// --template is omitted here, so resolveTemplate falls back to
+	// defaultTemplate and `app init` must still receive --template nestjs-react-fullstack.
 	c := findCall(f.calls, "npx", "-y")
 	if c == nil {
 		t.Error("npx scaffold not invoked")
-	} else if !containsAll(c, "-y", "--prefer-online", miaodaCLIPkg, "app", "init", "--app-type", "full_stack", "--app-id", "app_x") {
-		t.Errorf("app init missing expected --app-type fallback args: %v", c)
+	} else if !containsAll(c, "-y", "--prefer-online", miaodaCLIPkg, "app", "init", "--template", defaultTemplate, "--app-id", "app_x") {
+		t.Errorf("app init missing expected --template fallback args: %v", c)
 	} else if containsAll(c, "--local") {
 		t.Errorf("app init must NOT carry --local: %v", c)
 	}
@@ -737,6 +751,22 @@ func newAppsExecuteFactoryWithStderr(t *testing.T) (*cmdutil.Factory, *bytes.Buf
 }
 
 func TestAppsInit_Req1_Wording(t *testing.T) {
+	var tmpl *common.Flag
+	for i := range AppsInit.Flags {
+		if AppsInit.Flags[i].Name == "template" {
+			tmpl = &AppsInit.Flags[i]
+		}
+	}
+	if tmpl == nil {
+		t.Fatal("--template flag missing")
+	}
+	if strings.Contains(strings.ToLower(tmpl.Desc), "scaffold") {
+		t.Errorf("--template Desc still mentions scaffold: %q", tmpl.Desc)
+	}
+	if !strings.Contains(strings.ToLower(tmpl.Desc), "code-init") {
+		t.Errorf("--template Desc should use code-init wording: %q", tmpl.Desc)
+	}
+
 	// 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.
@@ -757,8 +787,9 @@ func TestAppsInit_Req1_Wording(t *testing.T) {
 		t.Error("dry-run must keep machine-contract key `scaffold`")
 	} else if !strings.Contains(scaffold, "skills sync --local") {
 		t.Errorf("dry-run scaffold string must show --local on skills sync: %q", scaffold)
-	} else if strings.Contains(scaffold, "app sync --local") {
-		t.Errorf("dry-run scaffold string must NOT show --local on app sync: %q", scaffold)
+	} else if strings.Contains(scaffold, "app init --template nestjs-react-fullstack --app-id app_x --local") ||
+		strings.Contains(scaffold, "app sync --local") {
+		t.Errorf("dry-run scaffold string must NOT show --local on app init / app sync: %q", scaffold)
 	}
 
 	f := &fakeCommandRunner{results: map[string]fakeCallResult{
@@ -1219,7 +1250,7 @@ func TestRunScaffold_NonEmpty_SyncFailure(t *testing.T) {
 		"git ls-files": {stdout: "src/x.ts\n"},
 		"npx -y":       {err: errors.New("sync boom")},
 	}})
-	if _, err := runScaffold(context.Background(), t.TempDir(), "app_x", "", ""); err == nil {
+	if _, err := runScaffold(context.Background(), t.TempDir(), "app_x", "tpl"); err == nil {
 		t.Error("npx app sync failure must surface as an error")
 	}
 }
@@ -1599,7 +1630,7 @@ func TestRunScaffold_SubprocessFailureIsExternalTool(t *testing.T) {
 		"git ls-files": {stderr: "fatal: not a git repository", err: cause},
 	}}
 	withFakeRunner(t, f)
-	_, err := runScaffold(context.Background(), t.TempDir(), "app_x", "", "")
+	_, err := runScaffold(context.Background(), t.TempDir(), "app_x", "nestjs-react-fullstack")
 	if err == nil {
 		t.Fatalf("expected error from failing git subprocess")
 	}
@@ -1614,368 +1645,3 @@ func TestRunScaffold_SubprocessFailureIsExternalTool(t *testing.T) {
 		t.Fatalf("cause chain not preserved: %v", err)
 	}
 }
-
-func TestRunScaffold_HtmlPassesTemplate(t *testing.T) {
-	f := &fakeCommandRunner{results: map[string]fakeCallResult{"git ls-files": {stdout: ""}}}
-	withFakeRunner(t, f)
-	kind, err := runScaffold(context.Background(), t.TempDir(), "app_x", "html", "")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if kind != scaffoldKindInit {
-		t.Errorf("kind = %q, want %q", kind, scaffoldKindInit)
-	}
-	c := findCall(f.calls, "npx", "-y")
-	if c == nil {
-		t.Fatal("npx not called")
-	}
-	if !containsAll(c, "--app-type", "html") {
-		t.Errorf("expected --app-type html in args: %v", c)
-	}
-}
-
-func TestRunScaffold_ModernHtmlPassesTemplate(t *testing.T) {
-	f := &fakeCommandRunner{results: map[string]fakeCallResult{"git ls-files": {stdout: ""}}}
-	withFakeRunner(t, f)
-	kind, err := runScaffold(context.Background(), t.TempDir(), "app_x", "modern_html", "")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if kind != scaffoldKindInit {
-		t.Errorf("kind = %q, want %q", kind, scaffoldKindInit)
-	}
-	c := findCall(f.calls, "npx", "-y")
-	if c == nil {
-		t.Fatal("npx not called")
-	}
-	if !containsAll(c, "--app-type", "modern_html") {
-		t.Errorf("expected --app-type modern_html in args: %v", c)
-	}
-}
-
-func TestRunScaffold_EmptyAppTypeFallback(t *testing.T) {
-	f := &fakeCommandRunner{results: map[string]fakeCallResult{"git ls-files": {stdout: ""}}}
-	withFakeRunner(t, f)
-	kind, err := runScaffold(context.Background(), t.TempDir(), "app_x", "", "")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if kind != scaffoldKindInit {
-		t.Errorf("kind = %q, want %q", kind, scaffoldKindInit)
-	}
-	c := findCall(f.calls, "npx", "-y")
-	if c == nil {
-		t.Fatal("npx not called")
-	}
-	if !containsAll(c, "--app-type", "full_stack") {
-		t.Errorf("expected --app-type full_stack in args: %v", c)
-	}
-}
-
-func TestRunScaffold_FullStackPassesTemplate(t *testing.T) {
-	f := &fakeCommandRunner{results: map[string]fakeCallResult{"git ls-files": {stdout: ""}}}
-	withFakeRunner(t, f)
-	kind, err := runScaffold(context.Background(), t.TempDir(), "app_x", "full_stack", "")
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if kind != scaffoldKindInit {
-		t.Errorf("kind = %q, want %q", kind, scaffoldKindInit)
-	}
-	c := findCall(f.calls, "npx", "-y")
-	if c == nil {
-		t.Fatal("npx not called")
-	}
-	if !containsAll(c, "--app-type", "full_stack") {
-		t.Errorf("expected --app-type full_stack in args: %v", c)
-	}
-}
-
-func TestScaffoldInitArgs_WithAppType(t *testing.T) {
-	args := scaffoldInitArgs("modern_html", "app_x", "")
-	if !containsAll(args, "--app-type", "modern_html", "--app-id", "app_x") {
-		t.Errorf("expected --app-type modern_html --app-id app_x, got %v", args)
-	}
-	// modern_html skips dependency install.
-	if !containsAll(args, "--skip-install") {
-		t.Errorf("expected --skip-install for modern_html, got %v", args)
-	}
-	for _, a := range args {
-		if a == "--source-path" {
-			t.Errorf("--source-path must not appear when sourcePath is empty: %v", args)
-		}
-	}
-}
-
-func TestPolicyForAppType(t *testing.T) {
-	// modern_html decouples all control points: skip install, env-pull, skills sync.
-	if p := policyForAppType("modern_html"); !p.skipInstall || !p.skipEnvPull || !p.skipSkillsSync {
-		t.Errorf("modern_html policy = %+v, want all skip flags set", p)
-	}
-	// Unlisted types (including "") get the zero-value policy: everything runs.
-	for _, at := range []string{"full_stack", "", "backend"} {
-		if p := policyForAppType(at); p.skipInstall || p.skipEnvPull || p.skipSkillsSync {
-			t.Errorf("policy for %q = %+v, want zero value", at, p)
-		}
-	}
-}
-
-func TestScaffoldInitArgs_SkipInstallOnlyForModernHTML(t *testing.T) {
-	// Non-modern_html types run the install step (no --skip-install).
-	for _, at := range []string{"full_stack", "", "backend"} {
-		args := scaffoldInitArgs(at, "app_x", "")
-		for _, a := range args {
-			if a == "--skip-install" {
-				t.Errorf("--skip-install must not appear for app-type %q: %v", at, args)
-			}
-		}
-	}
-}
-
-func TestScaffoldInitArgs_EmptyFallback(t *testing.T) {
-	args := scaffoldInitArgs("", "app_x", "")
-	if !containsAll(args, "--app-type", "full_stack", "--app-id", "app_x") {
-		t.Errorf("expected --app-type full_stack fallback, got %v", args)
-	}
-}
-
-func TestScaffoldInitArgs_WithSourcePath(t *testing.T) {
-	args := scaffoldInitArgs("modern_html", "app_x", "/path/to/src")
-	if !containsAll(args, "--app-type", "modern_html", "--app-id", "app_x", "--source-path", "/path/to/src") {
-		t.Errorf("expected --source-path /path/to/src, got %v", args)
-	}
-}
-
-// configSetValue finds a `git config <key> <value>` SET call (not a `--get`)
-// in the recorded fake calls and returns its value.
-func configSetValue(calls [][]string, key string) (string, bool) {
-	for _, c := range calls {
-		if len(c) >= 5 && c[1] == "git" && c[2] == "config" && c[3] == key {
-			return c[4], true
-		}
-	}
-	return "", false
-}
-
-func TestEnsureGitIdentity_SetsDefaultsWhenUnset(t *testing.T) {
-	f := &fakeCommandRunner{} // no "git config" result → `--get` returns empty stdout
-	withFakeRunner(t, f)
-	if err := ensureGitIdentity(context.Background(), "/repo"); err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if v, ok := configSetValue(f.calls, "user.name"); !ok || v != defaultGitUserName {
-		t.Errorf("user.name set = (%q,%v), want %q", v, ok, defaultGitUserName)
-	}
-	if v, ok := configSetValue(f.calls, "user.email"); !ok || v != defaultGitUserEmail {
-		t.Errorf("user.email set = (%q,%v), want %q", v, ok, defaultGitUserEmail)
-	}
-}
-
-func TestEnsureGitIdentity_RespectsExisting(t *testing.T) {
-	// `git config --get` returns a value → identity resolvable, nothing is set.
-	f := &fakeCommandRunner{results: map[string]fakeCallResult{
-		"git config": {stdout: "Existing Dev\n"},
-	}}
-	withFakeRunner(t, f)
-	if err := ensureGitIdentity(context.Background(), "/repo"); err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-	if _, ok := configSetValue(f.calls, "user.name"); ok {
-		t.Error("user.name must not be overwritten when already configured")
-	}
-	if _, ok := configSetValue(f.calls, "user.email"); ok {
-		t.Error("user.email must not be overwritten when already configured")
-	}
-}
-
-func TestEnsureGitIdentity_SetFailurePropagates(t *testing.T) {
-	f := &fakeCommandRunner{results: map[string]fakeCallResult{
-		"git config": {stderr: "boom", err: errors.New("exit 1")},
-	}}
-	withFakeRunner(t, f)
-	if err := ensureGitIdentity(context.Background(), "/repo"); err == nil {
-		t.Error("expected error when git config set fails")
-	}
-}
-
-func TestAppsInit_WithAppType_FreshClone(t *testing.T) {
-	f := &fakeCommandRunner{results: map[string]fakeCallResult{
-		"credential-init": credInitOK("http://u:t@h/app_typed.git"),
-		"git clone":       {},
-		"git checkout":    {},
-		"git ls-files":    {stdout: ""},
-		"git status":      {stdout: " A src/app.ts\n"},
-	}}
-	withFakeRunner(t, f)
-	factory, stdout, reg := newAppsExecuteFactory(t)
-
-	// Register a meta mock so queryAppType returns "modern_html"
-	reg.Register(&httpmock.Stub{
-		Method: "GET",
-		URL:    "/open-apis/spark/v1/apps/app_typed",
-		Body: map[string]interface{}{
-			"code": float64(0),
-			"data": map[string]interface{}{
-				"app": map[string]interface{}{
-					"app_id":   "app_typed",
-					"app_type": "MODERN_HTML",
-				},
-			},
-		},
-	})
-
-	dir := relCloneDir(t)
-	if err := runAppsShortcut(t, AppsInit, []string{"+init", "--app-id", "app_typed", "--dir", dir, "--as", "user"}, factory, stdout); err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	data := parseEnvelopeData(t, stdout)
-	if data["app_type"] != "modern_html" {
-		t.Errorf("app_type = %v, want modern_html", data["app_type"])
-	}
-	// Verify the scaffold used --app-type modern_html
-	c := findCall(f.calls, "npx", "-y")
-	if c == nil {
-		t.Fatal("npx not called")
-	}
-	if !containsAll(c, "--app-type", "modern_html") {
-		t.Errorf("expected --app-type modern_html, got %v", c)
-	}
-}
-
-func TestAppsInit_ModernHtml_SkipsEnvPull(t *testing.T) {
-	f := &fakeCommandRunner{results: map[string]fakeCallResult{
-		"credential-init": credInitOK("https://git.test/app_mh.git"),
-		"git clone":       {},
-		"git checkout":    {},
-		"git ls-files":    {stdout: ""},
-		"npx -y":          {},
-		"git status":      {stdout: ""},
-	}}
-	withFakeRunner(t, f)
-	factory, stdout, reg := newAppsExecuteFactory(t)
-
-	reg.Register(&httpmock.Stub{
-		Method: "GET",
-		URL:    "/open-apis/spark/v1/apps/app_mh",
-		Body: map[string]interface{}{
-			"code": float64(0),
-			"data": map[string]interface{}{
-				"app": map[string]interface{}{
-					"app_id":   "app_mh",
-					"app_type": "MODERN_HTML",
-				},
-			},
-		},
-	})
-
-	dir := relCloneDir(t)
-	if err := runAppsShortcut(t, AppsInit, []string{"+init", "--app-id", "app_mh", "--dir", dir, "--as", "user"}, factory, stdout); err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	data := parseEnvelopeData(t, stdout)
-	if data["env_pull_skipped"] != true {
-		t.Errorf("env_pull_skipped = %v, want true", data["env_pull_skipped"])
-	}
-	if data["env_pulled"] != false {
-		t.Errorf("env_pulled = %v, want false", data["env_pulled"])
-	}
-	// Verify env-pull was NOT called
-	for _, c := range f.calls {
-		if len(c) >= 3 && c[2] == "apps" && len(c) >= 4 && c[3] == "+env-pull" {
-			t.Fatal("env-pull should not be called for modern_html")
-		}
-	}
-}
-
-func TestAppsInit_AlreadyInitialized_ModernHtml_SkipsEnvPull(t *testing.T) {
-	dir := relCloneDir(t)
-	abs, err := filepath.Abs(dir)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := os.MkdirAll(filepath.Join(abs, ".spark"), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(abs, metaRelPath), []byte(`{"app_id":"app_mh2"}`), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	f := &fakeCommandRunner{}
-	withFakeRunner(t, f)
-	factory, stdout, reg := newAppsExecuteFactory(t)
-
-	reg.Register(&httpmock.Stub{
-		Method: "GET",
-		URL:    "/open-apis/spark/v1/apps/app_mh2",
-		Body: map[string]interface{}{
-			"code": float64(0),
-			"data": map[string]interface{}{
-				"app": map[string]interface{}{
-					"app_id":   "app_mh2",
-					"app_type": "MODERN_HTML",
-				},
-			},
-		},
-	})
-
-	if err := runAppsShortcut(t, AppsInit, []string{"+init", "--app-id", "app_mh2", "--dir", dir, "--as", "user"}, factory, stdout); err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	data := parseEnvelopeData(t, stdout)
-	if data["scaffold"] != "already_initialized" {
-		t.Errorf("scaffold = %v, want already_initialized", data["scaffold"])
-	}
-	if data["env_pull_skipped"] != true {
-		t.Errorf("env_pull_skipped = %v, want true", data["env_pull_skipped"])
-	}
-	if len(f.calls) != 0 {
-		t.Errorf("no commands should be called for already-initialized modern_html, got %v", f.calls)
-	}
-}
-
-func TestAppsInit_WithAppType_AlreadyInitialized(t *testing.T) {
-	dir := relCloneDir(t)
-	abs, err := filepath.Abs(dir)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := os.MkdirAll(filepath.Join(abs, ".spark"), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(abs, metaRelPath), []byte(`{"app_id":"app_typed2"}`), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	envFile := filepath.Join(abs, ".env.local")
-	f := &fakeCommandRunner{results: map[string]fakeCallResult{"env-pull": envPullOK(envFile)}}
-	withFakeRunner(t, f)
-	factory, stdout, reg := newAppsExecuteFactory(t)
-
-	// Register meta mock so queryAppType returns "html"
-	reg.Register(&httpmock.Stub{
-		Method: "GET",
-		URL:    "/open-apis/spark/v1/apps/app_typed2",
-		Body: map[string]interface{}{
-			"code": float64(0),
-			"data": map[string]interface{}{
-				"app": map[string]interface{}{
-					"app_id":   "app_typed2",
-					"app_type": "HTML",
-				},
-			},
-		},
-	})
-
-	if err := runAppsShortcut(t, AppsInit, []string{"+init", "--app-id", "app_typed2", "--dir", dir, "--as", "user"}, factory, stdout); err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	data := parseEnvelopeData(t, stdout)
-	if data["scaffold"] != "already_initialized" {
-		t.Errorf("scaffold = %v, want already_initialized", data["scaffold"])
-	}
-	if data["app_type"] != "html" {
-		t.Errorf("app_type = %v, want html", data["app_type"])
-	}
-}

shortcuts/apps/apps_meta.go

@@ -1,34 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package apps
-
-import (
-	"context"
-	"fmt"
-	"strings"
-
-	"github.com/larksuite/cli/internal/validate"
-	"github.com/larksuite/cli/shortcuts/common"
-)
-
-// queryAppType fetches the app's type string from the server via
-// GET /open-apis/spark/v1/apps/{appID}. The server returns uppercase
-// values ("HTML", "FULL_STACK", "MODERN_HTML"); this function normalizes
-// to lowercase. Returns "" when the API is unavailable or returns an
-// error — callers fall back to legacy behavior.
-func queryAppType(ctx context.Context, rctx *common.RuntimeContext, appID string) string {
-	path := fmt.Sprintf("%s/apps/%s", apiBasePath, validate.EncodePathSegment(appID))
-	data, err := rctx.CallAPITyped("GET", path, nil, nil)
-	if err != nil {
-		fmt.Fprintf(rctx.IO().ErrOut, "→ Could not query app type: %v\n", err)
-		return ""
-	}
-	appRaw, _ := data["app"].(map[string]interface{})
-	if appRaw == nil {
-		fmt.Fprintf(rctx.IO().ErrOut, "→ Could not query app type: response missing app object\n")
-		return ""
-	}
-	appType, _ := appRaw["app_type"].(string)
-	return strings.ToLower(appType)
-}

shortcuts/apps/apps_meta_test.go

@@ -1,148 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package apps
-
-import (
-	"context"
-	"testing"
-
-	"github.com/spf13/cobra"
-
-	"github.com/larksuite/cli/internal/cmdutil"
-	"github.com/larksuite/cli/internal/core"
-	"github.com/larksuite/cli/internal/httpmock"
-	"github.com/larksuite/cli/shortcuts/common"
-)
-
-func newMetaTestRuntime(t *testing.T) (*common.RuntimeContext, *httpmock.Registry) {
-	t.Helper()
-	cfg := &core.CliConfig{Brand: core.BrandFeishu, AppID: "cli_meta_test"}
-	f, _, _, reg := cmdutil.TestFactory(t, cfg)
-	rt := common.TestNewRuntimeContextForAPI(
-		context.Background(),
-		&cobra.Command{Use: "+meta-test"},
-		cfg, f, core.AsUser,
-	)
-	return rt, reg
-}
-
-func TestQueryAppType_Success(t *testing.T) {
-	rt, reg := newMetaTestRuntime(t)
-	reg.Register(&httpmock.Stub{
-		Method: "GET",
-		URL:    "/open-apis/spark/v1/apps/app_test",
-		Body: map[string]interface{}{
-			"code": float64(0),
-			"data": map[string]interface{}{
-				"app": map[string]interface{}{
-					"app_id":   "app_test",
-					"app_type": "MODERN_HTML",
-				},
-			},
-		},
-	})
-
-	result := queryAppType(context.Background(), rt, "app_test")
-	if result != "modern_html" {
-		t.Errorf("queryAppType = %q, want modern_html", result)
-	}
-}
-
-func TestQueryAppType_FullStack(t *testing.T) {
-	rt, reg := newMetaTestRuntime(t)
-	reg.Register(&httpmock.Stub{
-		Method: "GET",
-		URL:    "/open-apis/spark/v1/apps/app_fs",
-		Body: map[string]interface{}{
-			"code": float64(0),
-			"data": map[string]interface{}{
-				"app": map[string]interface{}{
-					"app_id":   "app_fs",
-					"app_type": "FULL_STACK",
-				},
-			},
-		},
-	})
-
-	result := queryAppType(context.Background(), rt, "app_fs")
-	if result != "full_stack" {
-		t.Errorf("queryAppType = %q, want full_stack", result)
-	}
-}
-
-func TestQueryAppType_Html(t *testing.T) {
-	rt, reg := newMetaTestRuntime(t)
-	reg.Register(&httpmock.Stub{
-		Method: "GET",
-		URL:    "/open-apis/spark/v1/apps/app_html",
-		Body: map[string]interface{}{
-			"code": float64(0),
-			"data": map[string]interface{}{
-				"app": map[string]interface{}{
-					"app_id":   "app_html",
-					"app_type": "HTML",
-				},
-			},
-		},
-	})
-
-	result := queryAppType(context.Background(), rt, "app_html")
-	if result != "html" {
-		t.Errorf("queryAppType = %q, want html", result)
-	}
-}
-
-func TestQueryAppType_APIError(t *testing.T) {
-	rt, reg := newMetaTestRuntime(t)
-	reg.Register(&httpmock.Stub{
-		Method: "GET",
-		URL:    "/open-apis/spark/v1/apps/app_bad",
-		Status: 500,
-		Body:   map[string]interface{}{"code": float64(99999), "msg": "internal error"},
-	})
-
-	result := queryAppType(context.Background(), rt, "app_bad")
-	if result != "" {
-		t.Errorf("queryAppType = %q, want empty on error", result)
-	}
-}
-
-func TestQueryAppType_MissingAppObject(t *testing.T) {
-	rt, reg := newMetaTestRuntime(t)
-	reg.Register(&httpmock.Stub{
-		Method: "GET",
-		URL:    "/open-apis/spark/v1/apps/app_no",
-		Body: map[string]interface{}{
-			"code": float64(0),
-			"data": map[string]interface{}{},
-		},
-	})
-
-	result := queryAppType(context.Background(), rt, "app_no")
-	if result != "" {
-		t.Errorf("queryAppType = %q, want empty when app object missing", result)
-	}
-}
-
-func TestQueryAppType_EmptyAppType(t *testing.T) {
-	rt, reg := newMetaTestRuntime(t)
-	reg.Register(&httpmock.Stub{
-		Method: "GET",
-		URL:    "/open-apis/spark/v1/apps/app_empty",
-		Body: map[string]interface{}{
-			"code": float64(0),
-			"data": map[string]interface{}{
-				"app": map[string]interface{}{
-					"app_id":   "app_empty",
-					"app_type": "",
-				},
-			},
-		},
-	})
-
-	result := queryAppType(context.Background(), rt, "app_empty")
-	if result != "" {
-		t.Errorf("queryAppType = %q, want empty when app_type is empty", result)
-	}
-}

shortcuts/apps/apps_release_create.go

@@ -56,10 +56,9 @@ var AppsReleaseCreate = common.Shortcut{
 		out := map[string]interface{}{
 			"release_id": common.GetString(data, "release_id"),
 			"status":     common.GetString(data, "status"),
-			"sync":       common.GetBool(data, "sync"),
 		}
 		rctx.OutFormat(out, nil, func(w io.Writer) {
-			fmt.Fprintf(w, "release_id: %s\nstatus: %s\nsync: %v\n", out["release_id"], out["status"], out["sync"])
+			fmt.Fprintf(w, "release_id: %s\nstatus: %s\n", out["release_id"], out["status"])
 		})
 		return nil
 	},

shortcuts/apps/apps_release_create_test.go

@@ -105,45 +105,3 @@ func TestAppsReleaseCreateExecute_Success(t *testing.T) {
 		t.Errorf("status = %v, want publishing", env.Data["status"])
 	}
 }
-
-func TestAppsReleaseCreate_SyncField(t *testing.T) {
-	rctx, stdoutBuf, reg := newReleaseCreateRuntimeContext(t, "app_sync", "main")
-	reg.Register(&httpmock.Stub{
-		Method: "POST",
-		URL:    "/open-apis/spark/v1/apps/app_sync/releases",
-		Body: map[string]interface{}{
-			"code": 0,
-			"msg":  "",
-			"data": map[string]interface{}{
-				"release_id": "456",
-				"status":     "publishing",
-				"sync":       true,
-			},
-		},
-	})
-
-	err := AppsReleaseCreate.Execute(context.Background(), rctx)
-	if err != nil {
-		t.Fatalf("Execute() = %v", err)
-	}
-
-	var env struct {
-		OK   bool                   `json:"ok"`
-		Data map[string]interface{} `json:"data"`
-	}
-	if err := json.Unmarshal(stdoutBuf.Bytes(), &env); err != nil {
-		t.Fatalf("unmarshal output: %v\nraw: %s", err, stdoutBuf.String())
-	}
-	if !env.OK {
-		t.Fatalf("expected ok=true, got: %s", stdoutBuf.String())
-	}
-	if env.Data["release_id"] != "456" {
-		t.Errorf("release_id = %v, want 456", env.Data["release_id"])
-	}
-	if env.Data["status"] != "publishing" {
-		t.Errorf("status = %v, want publishing", env.Data["status"])
-	}
-	if env.Data["sync"] != true {
-		t.Errorf("sync = %v, want true", env.Data["sync"])
-	}
-}

shortcuts/apps/shortcuts.go

@@ -12,7 +12,6 @@ func Shortcuts() []common.Shortcut {
 
 	return []common.Shortcut{
 		AppsCreate,
-		AppsGet,
 		AppsUpdate,
 		AppsList,
 		AppsAccessScopeSet,

shortcuts/apps/shortcuts_test.go

@@ -21,10 +21,10 @@ import (
 //   - 5 session（create/list/get/stop/chat）+ 1 session-messages-list
 //   - 8 openapi-key（list/get/create/update/enable/disable/delete/reset）
 //   - 3 plugin（install/uninstall/list）= 63。
-func TestAppsShortcuts_Returns64(t *testing.T) {
+func TestAppsShortcuts_Returns63(t *testing.T) {
 	got := Shortcuts()
-	if len(got) != 64 {
-		t.Fatalf("Shortcuts() returned %d entries, want 64", len(got))
+	if len(got) != 63 {
+		t.Fatalf("Shortcuts() returned %d entries, want 63", len(got))
 	}
 }
 

shortcuts/base/record_json_shorthand_test.go

@@ -1,73 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package base
-
-import (
-	"strings"
-	"testing"
-
-	"github.com/spf13/cobra"
-
-	"github.com/larksuite/cli/internal/cmdutil"
-	"github.com/larksuite/cli/shortcuts/common"
-)
-
-func mountBaseShortcutFlags(t *testing.T, s common.Shortcut, name string) *cobra.Command {
-	t.Helper()
-	parent := &cobra.Command{Use: "test"}
-	s.Mount(parent, &cmdutil.Factory{})
-	cmd, _, err := parent.Find([]string{name})
-	if err != nil {
-		t.Fatalf("Find(%s) error = %v", name, err)
-	}
-	return cmd
-}
-
-// record-list 获得 --json 简写
-func TestRecordListRegistersJSONShorthand(t *testing.T) {
-	cmd := mountBaseShortcutFlags(t, BaseRecordList, "+record-list")
-	fl := cmd.Flags().Lookup("json")
-	if fl == nil {
-		t.Fatal("+record-list missing --json shorthand")
-	}
-	if fl.Usage != "shorthand for --format json" {
-		t.Errorf("usage = %q, want shorthand", fl.Usage)
-	}
-	if def := cmd.Flags().Lookup("format").DefValue; def != "markdown" {
-		t.Errorf("format default = %q, want markdown (unchanged)", def)
-	}
-}
-
-// record-search / record-get 的 --json 保持请求体语义，不被覆盖（回归锚点）
-func TestRecordSearchGetKeepRequestBodyJSON(t *testing.T) {
-	for _, tc := range []struct {
-		name     string
-		shortcut common.Shortcut
-		cmdName  string
-	}{
-		{"record-search", BaseRecordSearch, "+record-search"},
-		{"record-get", BaseRecordGet, "+record-get"},
-	} {
-		cmd := mountBaseShortcutFlags(t, tc.shortcut, tc.cmdName)
-		fl := cmd.Flags().Lookup("json")
-		if fl == nil {
-			t.Fatalf("%s: --json (request body) missing", tc.name)
-		}
-		if strings.Contains(fl.Usage, "shorthand") {
-			t.Fatalf("%s: request-body --json overwritten by shorthand: %q", tc.name, fl.Usage)
-		}
-		if fl.Value.Type() != "string" {
-			t.Fatalf("%s: --json type = %q, want string", tc.name, fl.Value.Type())
-		}
-	}
-}
-
-// Enum 已接入：help 描述携带枚举后缀（框架对带 Enum 的 flag 自动追加 " (markdown|json)"）
-func TestRecordReadFormatFlagCarriesEnum(t *testing.T) {
-	cmd := mountBaseShortcutFlags(t, BaseRecordList, "+record-list")
-	usage := cmd.Flags().Lookup("format").Usage
-	if !strings.Contains(usage, "(markdown|json)") {
-		t.Fatalf("format usage missing enum suffix: %q", usage)
-	}
-}

shortcuts/base/record_list.go

@@ -85,7 +85,6 @@ func recordReadFormatFlag() common.Flag {
 	return common.Flag{
 		Name:    "format",
 		Default: "markdown",
-		Enum:    []string{"markdown", "json"},
 		Desc:    "output format: markdown (default) | json",
 	}
 }

shortcuts/common/runner.go

@@ -1027,7 +1027,6 @@ func newRuntimeContext(cmd *cobra.Command, f *cmdutil.Factory, s *Shortcut, conf
 	}
 	rctx.larkSDK = sdk
 
-	applyJSONShorthand(cmd, s)
 	rctx.Format = rctx.Str("format")
 	rctx.JqExpr, _ = cmd.Flags().GetString("jq")
 	return rctx, nil
@@ -1070,7 +1069,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 +1103,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.
@@ -1180,75 +1172,6 @@ func registerShortcutFlags(cmd *cobra.Command, f *cmdutil.Factory, s *Shortcut)
 	registerShortcutFlagsWithContext(context.Background(), cmd, f, s)
 }
 
-// shortcutDeclaresJSONFlag reports whether the shortcut itself declares a flag
-// named "json" in its Flags list (custom semantics, e.g. event +subscribe's
-// pretty-print switch or base +record-search's request-body payload).
-// Framework-injected flags never appear in s.Flags, so this cleanly separates
-// "self-declared json" from "injected shorthand".
-func shortcutDeclaresJSONFlag(s *Shortcut) bool {
-	for _, fl := range s.Flags {
-		if fl.Name == "json" {
-			return true
-		}
-	}
-	return false
-}
-
-// shortcutFormatSupportsJSON reports whether the command's format flag accepts
-// "json": a self-declared format supports it only when its Enum lists "json";
-// a framework-injected default format (no format entry in s.Flags) always does.
-func shortcutFormatSupportsJSON(s *Shortcut) bool {
-	for _, fl := range s.Flags {
-		if fl.Name == "format" {
-			return slices.Contains(fl.Enum, "json")
-		}
-	}
-	return true // framework-injected: json (default) | pretty | table | ndjson | csv
-}
-
-// ensureJSONShorthand registers --json as a shorthand for --format json when:
-//  1. the command has a format flag (self-declared or framework-injected), AND
-//  2. that format supports "json" (see shortcutFormatSupportsJSON), AND
-//  3. no flag named "json" is registered yet — pflag panics on duplicate
-//     registration, and commands that declare their own --json (event
-//     +subscribe, base +record-search/-get) keep their custom semantics.
-func ensureJSONShorthand(cmd *cobra.Command, s *Shortcut) {
-	// A shortcut that declares its own "json" flag defines custom semantics
-	// (e.g. pretty-print switch, request-body payload) — never a shorthand.
-	if shortcutDeclaresJSONFlag(s) {
-		return
-	}
-	if cmd.Flags().Lookup("format") == nil {
-		return
-	}
-	if !shortcutFormatSupportsJSON(s) {
-		return
-	}
-	// Safety net: pflag panics on duplicate registration.
-	if cmd.Flags().Lookup("json") != nil {
-		return
-	}
-	cmd.Flags().Bool("json", false, "shorthand for --format json")
-}
-
-// applyJSONShorthand folds the injected --json shorthand into the format flag
-// itself, before rctx.Format caches it — so both the cached value (OutFormat,
-// ValidateJqFlags, dry-run) and later runtime.Str("format") reads observe
-// "json". An explicitly passed --format always wins over the shorthand (the
-// shorthand only fills in when the user did not choose a format). Shortcuts
-// that declare their own "json" flag keep its custom semantics untouched.
-func applyJSONShorthand(cmd *cobra.Command, s *Shortcut) {
-	if shortcutDeclaresJSONFlag(s) {
-		return
-	}
-	if cmd.Flags().Lookup("json") == nil || cmd.Flags().Changed("format") {
-		return
-	}
-	if set, _ := cmd.Flags().GetBool("json"); set {
-		_ = cmd.Flags().Set("format", "json")
-	}
-}
-
 func registerShortcutFlagsWithContext(ctx context.Context, cmd *cobra.Command, f *cmdutil.Factory, s *Shortcut) {
 	for _, fl := range s.Flags {
 		desc := fl.Desc
@@ -1312,8 +1235,10 @@ func registerShortcutFlagsWithContext(ctx context.Context, cmd *cobra.Command, f
 		cmdutil.RegisterFlagCompletion(cmd, "format", func(_ *cobra.Command, _ []string, _ string) ([]string, cobra.ShellCompDirective) {
 			return []string{"json", "pretty", "table", "ndjson", "csv"}, cobra.ShellCompDirectiveNoFileComp
 		})
+		if cmd.Flags().Lookup("json") == nil {
+			cmd.Flags().Bool("json", false, "shorthand for --format json")
+		}
 	}
-	ensureJSONShorthand(cmd, s)
 	if s.Risk == "high-risk-write" {
 		cmd.Flags().Bool("yes", false, "confirm high-risk operation")
 	}

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_json_shorthand_test.go

@@ -1,200 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package common
-
-import (
-	"context"
-	"testing"
-
-	"github.com/spf13/cobra"
-
-	"github.com/larksuite/cli/internal/cmdutil"
-)
-
-const jsonShorthandUsage = "shorthand for --format json"
-
-func mountTestShortcut(t *testing.T, s Shortcut) *cobra.Command {
-	t.Helper()
-	f, _, _, _ := cmdutil.TestFactory(t, nil)
-	parent := &cobra.Command{Use: "root"}
-	s.Mount(parent, f)
-	cmd, _, err := parent.Find([]string{s.Command})
-	if err != nil {
-		t.Fatalf("Find() error = %v", err)
-	}
-	return cmd
-}
-
-// 自定义 format 且 Enum 含 json → 注册简写（本次修复的核心行为）
-func TestJSONShorthand_CustomFormatWithJSONEnum_Registered(t *testing.T) {
-	cmd := mountTestShortcut(t, Shortcut{
-		Service: "mail", Command: "+fake-triage", Description: "x",
-		Flags:   []Flag{{Name: "format", Default: "table", Enum: []string{"table", "json", "data"}, Desc: "fmt"}},
-		Execute: func(context.Context, *RuntimeContext) error { return nil },
-	})
-	fl := cmd.Flags().Lookup("json")
-	if fl == nil {
-		t.Fatal("--json not registered for custom-format shortcut whose Enum contains json")
-	}
-	if fl.Usage != jsonShorthandUsage {
-		t.Errorf("usage = %q, want %q", fl.Usage, jsonShorthandUsage)
-	}
-	// 默认输出格式不被改变
-	if def := cmd.Flags().Lookup("format").DefValue; def != "table" {
-		t.Errorf("format default = %q, want table", def)
-	}
-}
-
-// 自定义 format 但 Enum 不含 json → 不注册
-func TestJSONShorthand_CustomFormatWithoutJSONEnum_NotRegistered(t *testing.T) {
-	cmd := mountTestShortcut(t, Shortcut{
-		Service: "x", Command: "+no-json", Description: "x",
-		Flags:   []Flag{{Name: "format", Default: "csv", Enum: []string{"csv", "table"}, Desc: "fmt"}},
-		Execute: func(context.Context, *RuntimeContext) error { return nil },
-	})
-	if cmd.Flags().Lookup("json") != nil {
-		t.Fatal("--json must NOT be registered when format Enum lacks json")
-	}
-}
-
-// 自定义 format 但无 Enum（现状 triage 形态）→ 不注册（Enum 是判定依据）
-func TestJSONShorthand_CustomFormatNoEnum_NotRegistered(t *testing.T) {
-	cmd := mountTestShortcut(t, Shortcut{
-		Service: "x", Command: "+legacy", Description: "x",
-		Flags:   []Flag{{Name: "format", Default: "table", Desc: "fmt"}},
-		Execute: func(context.Context, *RuntimeContext) error { return nil },
-	})
-	if cmd.Flags().Lookup("json") != nil {
-		t.Fatal("--json must NOT be registered when format has no Enum metadata")
-	}
-}
-
-// 自声明 json flag（subscribe 的 pretty / record-search 的请求体）→ 不覆盖、不 panic、语义保留
-func TestJSONShorthand_SelfDeclaredJSON_Preserved(t *testing.T) {
-	cmd := mountTestShortcut(t, Shortcut{
-		Service: "event", Command: "+fake-subscribe", Description: "x",
-		Flags: []Flag{
-			{Name: "json", Type: "bool", Desc: "pretty-print JSON instead of NDJSON"},
-		},
-		Execute: func(context.Context, *RuntimeContext) error { return nil },
-	})
-	fl := cmd.Flags().Lookup("json")
-	if fl == nil {
-		t.Fatal("self-declared --json missing")
-	}
-	if fl.Usage != "pretty-print JSON instead of NDJSON" {
-		t.Errorf("self-declared --json usage overwritten: %q", fl.Usage)
-	}
-}
-
-// parseMounted mounts the shortcut and parses args against the command's FlagSet
-// (registration side effects included), without executing RunE.
-func parseMounted(t *testing.T, s Shortcut, args []string) *cobra.Command {
-	t.Helper()
-	cmd := mountTestShortcut(t, s)
-	if err := cmd.ParseFlags(args); err != nil {
-		t.Fatalf("ParseFlags(%v) error = %v", args, err)
-	}
-	return cmd
-}
-
-func customFormatShortcut() Shortcut {
-	return Shortcut{
-		Service: "mail", Command: "+fake-triage", Description: "x",
-		Flags:   []Flag{{Name: "format", Default: "table", Enum: []string{"table", "json", "data"}, Desc: "fmt"}},
-		Execute: func(context.Context, *RuntimeContext) error { return nil },
-	}
-}
-
-// --json 单独使用 → format 归一化为 json
-func TestApplyJSONShorthand_JSONAlone_SetsFormatJSON(t *testing.T) {
-	s := customFormatShortcut()
-	cmd := parseMounted(t, s, []string{"--json"})
-	applyJSONShorthand(cmd, &s)
-	if got := cmd.Flags().Lookup("format").Value.String(); got != "json" {
-		t.Fatalf("format = %q, want json", got)
-	}
-}
-
-// 显式 --format 优先于 --json 简写：--format table --json → table
-func TestApplyJSONShorthand_ExplicitFormatWins(t *testing.T) {
-	s := customFormatShortcut()
-	cmd := parseMounted(t, s, []string{"--format", "table", "--json"})
-	applyJSONShorthand(cmd, &s)
-	if got := cmd.Flags().Lookup("format").Value.String(); got != "table" {
-		t.Fatalf("format = %q, want table (explicit --format must win)", got)
-	}
-}
-
-// --format json --json → json（一致，无冲突）
-func TestApplyJSONShorthand_ExplicitJSONFormatConsistent(t *testing.T) {
-	s := customFormatShortcut()
-	cmd := parseMounted(t, s, []string{"--format", "json", "--json"})
-	applyJSONShorthand(cmd, &s)
-	if got := cmd.Flags().Lookup("format").Value.String(); got != "json" {
-		t.Fatalf("format = %q, want json", got)
-	}
-}
-
-// 均不传 → 默认值不变
-func TestApplyJSONShorthand_NoFlags_DefaultUntouched(t *testing.T) {
-	s := customFormatShortcut()
-	cmd := parseMounted(t, s, nil)
-	applyJSONShorthand(cmd, &s)
-	if got := cmd.Flags().Lookup("format").Value.String(); got != "table" {
-		t.Fatalf("format = %q, want table (default untouched)", got)
-	}
-}
-
-// 自声明 string 型 --json（record-search 形态：format+json 双声明）→ 归一化跳过
-func TestApplyJSONShorthand_SelfDeclaredStringJSON_Skipped(t *testing.T) {
-	s := Shortcut{
-		Service: "base", Command: "+fake-record-search", Description: "x",
-		Flags: []Flag{
-			{Name: "format", Default: "markdown", Enum: []string{"markdown", "json"}, Desc: "fmt"},
-			{Name: "json", Desc: "request body JSON object"},
-		},
-		Execute: func(context.Context, *RuntimeContext) error { return nil },
-	}
-	cmd := parseMounted(t, s, []string{"--json", `{"keyword":"Alice"}`})
-	applyJSONShorthand(cmd, &s)
-	if got := cmd.Flags().Lookup("format").Value.String(); got != "markdown" {
-		t.Fatalf("format = %q, want markdown (self-declared json must not normalize)", got)
-	}
-	if got := cmd.Flags().Lookup("json").Value.String(); got != `{"keyword":"Alice"}` {
-		t.Fatalf("request-body --json corrupted: %q", got)
-	}
-}
-
-// 自声明 bool 型 --json（subscribe 形态：无自定义 format，框架注入 format）→ 归一化跳过
-func TestApplyJSONShorthand_SelfDeclaredBoolJSON_Skipped(t *testing.T) {
-	s := Shortcut{
-		Service: "event", Command: "+fake-subscribe", Description: "x",
-		Flags: []Flag{
-			{Name: "json", Type: "bool", Desc: "pretty-print JSON instead of NDJSON"},
-		},
-		Execute: func(context.Context, *RuntimeContext) error { return nil },
-	}
-	cmd := parseMounted(t, s, []string{"--json"})
-	applyJSONShorthand(cmd, &s)
-	// 注入的 format 默认即 json；这里断言的是 Changed 状态未被归一化污染
-	if cmd.Flags().Changed("format") {
-		t.Fatal("normalization must not touch format for shortcuts declaring their own --json")
-	}
-}
-
-// 无自定义 format（普通命令）→ 注入默认 format + 简写（现状回归）
-func TestJSONShorthand_DefaultInjectedFormat_StillRegistered(t *testing.T) {
-	cmd := mountTestShortcut(t, Shortcut{
-		Service: "im", Command: "+plain", Description: "x",
-		Execute: func(context.Context, *RuntimeContext) error { return nil },
-	})
-	fl := cmd.Flags().Lookup("json")
-	if fl == nil {
-		t.Fatal("--json missing on default-format shortcut (regression)")
-	}
-	if fl.Usage != jsonShorthandUsage {
-		t.Errorf("usage = %q, want %q", fl.Usage, jsonShorthandUsage)
-	}
-}

shortcuts/doc/docs_fetch_v2.go

@@ -151,12 +151,12 @@ func resolveFetchLang(runtime *common.RuntimeContext) string {
 
 // buildReadOption 拼装 read_option JSON；full/空模式返回 nil，让服务端走默认全文路径。
 func buildReadOption(runtime *common.RuntimeContext) map[string]interface{} {
-	mode := effectiveFetchReadMode(runtime)
+	mode := strings.TrimSpace(runtime.Str("scope"))
 	if mode == "" || mode == "full" {
 		return nil
 	}
 	ro := map[string]interface{}{"read_mode": mode}
-	if v := effectiveFetchStartBlockID(runtime, mode); v != "" {
+	if v := strings.TrimSpace(runtime.Str("start-block-id")); v != "" {
 		ro["start_block_id"] = v
 	}
 	if v := strings.TrimSpace(runtime.Str("end-block-id")); v != "" {
@@ -177,72 +177,6 @@ func buildReadOption(runtime *common.RuntimeContext) map[string]interface{} {
 	return ro
 }
 
-func effectiveFetchReadMode(runtime *common.RuntimeContext) string {
-	mode := rawFetchReadMode(runtime)
-	if shouldUseDocSelectionAnchor(runtime, mode) {
-		if anchor := docSelectionAnchorStartBlockID(runtime); anchor != "" {
-			return "range"
-		}
-	}
-	return mode
-}
-
-func rawFetchReadMode(runtime *common.RuntimeContext) string {
-	mode := strings.TrimSpace(runtime.Str("scope"))
-	if mode == "" {
-		return "full"
-	}
-	return mode
-}
-
-func effectiveFetchStartBlockID(runtime *common.RuntimeContext, mode string) string {
-	if v := strings.TrimSpace(runtime.Str("start-block-id")); v != "" {
-		return v
-	}
-	if mode == "range" && shouldUseDocSelectionAnchor(runtime, rawFetchReadMode(runtime)) {
-		if anchor := docSelectionAnchorStartBlockID(runtime); anchor != "" {
-			return anchor
-		}
-	}
-	return ""
-}
-
-func shouldUseDocSelectionAnchor(runtime *common.RuntimeContext, mode string) bool {
-	if runtime.Changed("start-block-id") || runtime.Changed("end-block-id") {
-		return false
-	}
-	if runtime.Changed("scope") {
-		return mode == "range"
-	}
-	return mode == "" || mode == "full"
-}
-
-func docSelectionAnchorStartBlockID(runtime *common.RuntimeContext) string {
-	ref, err := parseDocumentRef(runtime.Str("doc"))
-	if err != nil {
-		return ""
-	}
-	anchor, ok := parseDocShareSelectionAnchor(ref.Fragment)
-	if !ok {
-		return ""
-	}
-	return anchor
-}
-
-func parseDocShareSelectionAnchor(raw string) (string, bool) {
-	value := strings.TrimSpace(raw)
-	value = strings.TrimPrefix(value, "#")
-	const prefix = "share-"
-	if !strings.HasPrefix(value, prefix) {
-		return "", false
-	}
-	anchorID := strings.TrimSpace(strings.TrimPrefix(value, prefix))
-	if anchorID == "" {
-		return "", false
-	}
-	return prefix + anchorID, true
-}
-
 // effectiveFetchDetail degrades detail options that cannot be represented by
 // non-XML exports. The original flag value is left intact so callers can still
 // surface an explicit warning in execute output.
@@ -274,7 +208,7 @@ func addFetchDetailDowngradeWarning(runtime *common.RuntimeContext, data map[str
 
 // validateReadModeFlags 客户端前置校验，服务端也会再校验一次。
 func validateReadModeFlags(runtime *common.RuntimeContext) error {
-	mode := effectiveFetchReadMode(runtime)
+	mode := strings.TrimSpace(runtime.Str("scope"))
 	if mode == "" || mode == "full" {
 		return nil
 	}
@@ -293,7 +227,7 @@ func validateReadModeFlags(runtime *common.RuntimeContext) error {
 	case "outline":
 		return nil
 	case "range":
-		if effectiveFetchStartBlockID(runtime, mode) == "" &&
+		if strings.TrimSpace(runtime.Str("start-block-id")) == "" &&
 			strings.TrimSpace(runtime.Str("end-block-id")) == "" {
 			return errs.NewValidationError(errs.SubtypeInvalidArgument, "range mode requires --start-block-id or --end-block-id").WithParams(
 				errs.InvalidParam{Name: "--start-block-id", Reason: "provide --start-block-id or --end-block-id for range mode"},

shortcuts/doc/docs_fetch_v2_test.go

@@ -180,64 +180,6 @@ func TestBuildFetchBodyIncludesReadOption(t *testing.T) {
 	}
 }
 
-func TestBuildFetchBodyUsesSelectionAnchorFragmentAsRangeStart(t *testing.T) {
-	t.Parallel()
-
-	runtime := newFetchBodyTestRuntime(context.Background())
-	mustSetFetchFlag(t, runtime, "doc", "https://example.larksuite.com/wiki/wikcnToken#share-CUE3d6Ykno2fkexEvt8cGF8Wnse")
-
-	body := buildFetchBody(runtime)
-	want := map[string]interface{}{
-		"read_mode":      "range",
-		"start_block_id": "share-CUE3d6Ykno2fkexEvt8cGF8Wnse",
-	}
-	if got := body["read_option"]; !reflect.DeepEqual(got, want) {
-		t.Fatalf("read_option = %#v, want %#v", got, want)
-	}
-}
-
-func TestBuildFetchBodyExplicitFullIgnoresSelectionAnchorFragment(t *testing.T) {
-	t.Parallel()
-
-	runtime := newFetchBodyTestRuntime(context.Background())
-	mustSetFetchFlag(t, runtime, "doc", "https://example.larksuite.com/wiki/wikcnToken#share-CUE3d6Ykno2fkexEvt8cGF8Wnse")
-	mustSetFetchFlag(t, runtime, "scope", "full")
-
-	body := buildFetchBody(runtime)
-	if _, ok := body["read_option"]; ok {
-		t.Fatalf("did not expect read_option for explicit full scope: %#v", body["read_option"])
-	}
-}
-
-func TestBuildFetchBodyDoesNotAutoReadOrdinaryFragment(t *testing.T) {
-	t.Parallel()
-
-	runtime := newFetchBodyTestRuntime(context.Background())
-	mustSetFetchFlag(t, runtime, "doc", "https://example.larksuite.com/wiki/wikcnToken#blk_plain")
-
-	body := buildFetchBody(runtime)
-	if _, ok := body["read_option"]; ok {
-		t.Fatalf("did not expect read_option for ordinary URL fragment: %#v", body["read_option"])
-	}
-}
-
-func TestBuildFetchBodyDoesNotAutoReadUnsupportedSelectionAnchorFragments(t *testing.T) {
-	t.Parallel()
-
-	for _, doc := range []string{
-		"https://example.larksuite.com/wiki/wikcnToken#part-CUE3d6Ykno2fkexEvt8cGF8Wnse",
-		"https://example.larksuite.com/wiki/wikcnToken#share-",
-	} {
-		runtime := newFetchBodyTestRuntime(context.Background())
-		mustSetFetchFlag(t, runtime, "doc", doc)
-
-		body := buildFetchBody(runtime)
-		if _, ok := body["read_option"]; ok {
-			t.Fatalf("did not expect read_option for unsupported URL fragment %q: %#v", doc, body["read_option"])
-		}
-	}
-}
-
 func TestBuildReadOptionModes(t *testing.T) {
 	t.Parallel()
 
@@ -433,12 +375,6 @@ func TestValidateReadModeFlagsAcceptsValidScopeOptions(t *testing.T) {
 				"end-block-id": "blk_end",
 			},
 		},
-		{
-			name: "default scope with selection anchor fragment",
-			setFlags: map[string]string{
-				"doc": "https://example.larksuite.com/wiki/wikcnToken#share-CUE3d6Ykno2fkexEvt8cGF8Wnse",
-			},
-		},
 		{
 			name: "keyword with keyword",
 			setFlags: map[string]string{
@@ -948,7 +884,6 @@ func TestDocsFetchRejectsLegacyFlags(t *testing.T) {
 
 func newFetchBodyTestRuntime(ctx context.Context) *common.RuntimeContext {
 	cmd := &cobra.Command{Use: "+fetch"}
-	cmd.Flags().String("doc", "doxcnFetchDryRun", "")
 	cmd.Flags().String("doc-format", fetchDefault("doc-format"), "")
 	cmd.Flags().String("detail", fetchDefault("detail"), "")
 	cmd.Flags().String("lang", fetchDefault("lang"), "")

shortcuts/doc/helpers.go

@@ -17,9 +17,8 @@ import (
 const docsSceneContextKey = "lark_cli_docs_scene"
 
 type documentRef struct {
-	Kind     string
-	Token    string
-	Fragment string
+	Kind  string
+	Token string
 }
 
 func parseDocumentRef(input string) (documentRef, error) {
@@ -29,13 +28,13 @@ func parseDocumentRef(input string) (documentRef, error) {
 	}
 
 	if token, ok := extractDocumentToken(raw, "/wiki/"); ok {
-		return documentRef{Kind: "wiki", Token: token, Fragment: extractDocumentFragment(raw)}, nil
+		return documentRef{Kind: "wiki", Token: token}, nil
 	}
 	if token, ok := extractDocumentToken(raw, "/docx/"); ok {
-		return documentRef{Kind: "docx", Token: token, Fragment: extractDocumentFragment(raw)}, nil
+		return documentRef{Kind: "docx", Token: token}, nil
 	}
 	if token, ok := extractDocumentToken(raw, "/doc/"); ok {
-		return documentRef{Kind: "doc", Token: token, Fragment: extractDocumentFragment(raw)}, nil
+		return documentRef{Kind: "doc", Token: token}, nil
 	}
 	if strings.Contains(raw, "://") {
 		return documentRef{}, errs.NewValidationError(errs.SubtypeInvalidArgument, "unsupported --doc input %q: use a docx URL/token or a wiki URL that resolves to docx", raw).WithParam("--doc")
@@ -63,14 +62,6 @@ func extractDocumentToken(raw, marker string) (string, bool) {
 	return token, true
 }
 
-func extractDocumentFragment(raw string) string {
-	idx := strings.Index(raw, "#")
-	if idx < 0 {
-		return ""
-	}
-	return strings.TrimSpace(raw[idx+1:])
-}
-
 // doDocAPI executes an OpenAPI request against the docs_ai endpoints and returns
 // the parsed "data" field from the standard Lark response envelope {code, msg, data}.
 // CallAPITyped lifts the x-tt-logid response header onto the typed error so log_id

shortcuts/doc/helpers_test.go

@@ -13,12 +13,11 @@ func TestParseDocumentRef(t *testing.T) {
 	t.Parallel()
 
 	tests := []struct {
-		name         string
-		input        string
-		wantKind     string
-		wantToken    string
-		wantFragment string
-		wantErr      string
+		name      string
+		input     string
+		wantKind  string
+		wantToken string
+		wantErr   string
 	}{
 		{
 			name:      "docx url",
@@ -32,13 +31,6 @@ func TestParseDocumentRef(t *testing.T) {
 			wantKind:  "wiki",
 			wantToken: "xxxxxx",
 		},
-		{
-			name:         "wiki url with selection anchor",
-			input:        "https://example.larksuite.com/wiki/xxxxxx#share-CUE3d6Ykno2fkexEvt8cGF8Wnse",
-			wantKind:     "wiki",
-			wantToken:    "xxxxxx",
-			wantFragment: "share-CUE3d6Ykno2fkexEvt8cGF8Wnse",
-		},
 		{
 			name:      "doc url",
 			input:     "https://example.larksuite.com/doc/xxxxxx",
@@ -81,9 +73,6 @@ func TestParseDocumentRef(t *testing.T) {
 			if got.Token != tt.wantToken {
 				t.Fatalf("parseDocumentRef(%q) token = %q, want %q", tt.input, got.Token, tt.wantToken)
 			}
-			if got.Fragment != tt.wantFragment {
-				t.Fatalf("parseDocumentRef(%q) fragment = %q, want %q", tt.input, got.Fragment, tt.wantFragment)
-			}
 		})
 	}
 }

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_push.go

@@ -623,10 +623,6 @@ func driveClassifyBatchFailure(err error) driveBatchFailureDecision {
 	case problem.Subtype == errs.SubtypeRateLimit || problem.Code == 99991400:
 		decision.Class = "rate_limited"
 		decision.Terminal = true
-	case problem.Code == 1062507:
-		decision.Class = "parent_sibling_limit"
-		decision.Terminal = true
-		decision.Hint = "The destination parent folder has reached its child-count limit. Clean up that folder, choose another --folder-token, or split the upload across subfolders before retrying."
 	case problem.Subtype == errs.SubtypeQuotaExceeded || problem.Code == 1061043:
 		decision.Class = "file_size_limit"
 	case problem.Code == 1062009:

shortcuts/drive/drive_push_test.go

@@ -1334,75 +1334,6 @@ func TestDrivePushAbortsAfterCreateFolderMissingScope(t *testing.T) {
 	}
 }
 
-func TestDrivePushAbortsAfterCreateFolderParentSiblingLimit(t *testing.T) {
-	f, stdout, _, reg := cmdutil.TestFactory(t, driveTestConfig())
-
-	tmpDir := t.TempDir()
-	withDriveWorkingDir(t, tmpDir)
-	if err := os.MkdirAll(filepath.Join("local", "a"), 0o755); err != nil {
-		t.Fatalf("MkdirAll a: %v", err)
-	}
-	if err := os.MkdirAll(filepath.Join("local", "b"), 0o755); err != nil {
-		t.Fatalf("MkdirAll b: %v", err)
-	}
-
-	reg.Register(&httpmock.Stub{
-		Method: "GET",
-		URL:    "folder_token=folder_root",
-		Body: map[string]interface{}{
-			"code": 0, "msg": "ok",
-			"data": map[string]interface{}{"files": []interface{}{}, "has_more": false},
-		},
-	})
-	reg.Register(&httpmock.Stub{
-		Method: "POST",
-		URL:    "/open-apis/drive/v1/files/create_folder",
-		Body: map[string]interface{}{
-			"code": 1062507,
-			"msg":  "parent node out of sibling num.",
-		},
-	})
-
-	err := mountAndRunDrive(t, DrivePush, []string{
-		"+push",
-		"--local-dir", "local",
-		"--folder-token", "folder_root",
-		"--as", "bot",
-	}, f, stdout)
-	if err == nil {
-		t.Fatalf("expected partial failure, got nil\nstdout: %s", stdout.String())
-	}
-	var pfErr *output.PartialFailureError
-	if !errors.As(err, &pfErr) {
-		t.Fatalf("expected *output.PartialFailureError, got %T: %v", err, err)
-	}
-	summary, items := splitDrivePushStdout(t, stdout.Bytes())
-	if got := summary["failed"]; got != float64(1) {
-		t.Fatalf("summary.failed = %v, want 1", got)
-	}
-	if got := summary["aborted"]; got != true {
-		t.Fatalf("summary.aborted = %v, want true", got)
-	}
-	if len(items) != 1 {
-		t.Fatalf("items len = %d, want 1; items=%#v", len(items), items)
-	}
-	item := items[0]
-	if item["rel_path"] != "a" || item["phase"] != "create_folder" || item["error_class"] != "parent_sibling_limit" {
-		t.Fatalf("unexpected failed item: %#v", item)
-	}
-	if item["code"] != float64(1062507) || item["subtype"] != "quota_exceeded" || item["retryable"] != false {
-		t.Fatalf("unexpected failure metadata: %#v", item)
-	}
-	if got, _ := item["hint"].(string); !strings.Contains(got, "--folder-token") || !strings.Contains(got, "child-count limit") {
-		t.Fatalf("hint should explain the destination folder child-count limit, got item=%#v", item)
-	}
-	for _, item := range items {
-		if item["rel_path"] == "b" {
-			t.Fatalf("parent sibling limit must abort before b, got items=%#v", items)
-		}
-	}
-}
-
 func TestDrivePushDetectsLocalFileChangedBeforeUpload(t *testing.T) {
 	f, stdout, _, reg := cmdutil.TestFactory(t, driveTestConfig())
 

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/event/subscribe.go

@@ -21,6 +21,7 @@ import (
 	"github.com/larksuite/cli/internal/validate"
 	"github.com/larksuite/cli/shortcuts/common"
 
+	lark "github.com/larksuite/oapi-sdk-go/v3"
 	larkcore "github.com/larksuite/oapi-sdk-go/v3/core"
 	larkevent "github.com/larksuite/oapi-sdk-go/v3/event"
 	"github.com/larksuite/oapi-sdk-go/v3/event/dispatcher"
@@ -246,7 +247,10 @@ var EventSubscribe = common.Shortcut{
 		}
 
 		// --- WebSocket ---
-		domain := core.ResolveEndpoints(runtime.Config.Brand).Open
+		domain := lark.FeishuBaseUrl
+		if runtime.Config.Brand == core.BrandLark {
+			domain = lark.LarkBaseUrl
+		}
 
 		info(fmt.Sprintf("%sConnecting to Lark event WebSocket...%s", output.Cyan, output.Reset))
 		if eventTypeFilter != nil {

shortcuts/event/subscribe_test.go

@@ -1,22 +0,0 @@
-// Copyright (c) 2026 Lark Technologies Pte. Ltd.
-// SPDX-License-Identifier: MIT
-
-package event
-
-import (
-	"testing"
-
-	"github.com/larksuite/cli/internal/core"
-	lark "github.com/larksuite/oapi-sdk-go/v3"
-)
-
-// The resolver's Open host must equal the SDK's per-brand WS base URL;
-// fails if the SDK constants ever drift from the resolver.
-func TestWSDomainMatchesResolver(t *testing.T) {
-	if got, want := core.ResolveEndpoints(core.BrandFeishu).Open, lark.FeishuBaseUrl; got != want {
-		t.Errorf("feishu WS domain = %q, want SDK %q", got, want)
-	}
-	if got, want := core.ResolveEndpoints(core.BrandLark).Open, lark.LarkBaseUrl; got != want {
-		t.Errorf("lark WS domain = %q, want SDK %q", got, want)
-	}
-}

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)
 		}
 	})