feat(im): support feed card time sensitive

Add bot-only IM shortcuts for feed card temporary pinning: +feed-card-bot-time-sensitive wraps PATCH /open-apis/im/v2/feed_cards/bot_time_sentive, and +feed-card-time-sensitive wraps PATCH /open-apis/im/v2/feed_cards/{feed_card_id}.

Both shortcuts accept --user-ids, --user-id-type, and an explicit --time-sensitive flag so true pins and false unpins are both represented in the request body. The feed_card_id path segment is escaped before execution.

Add unit tests for payload construction, validation, dry-run shape, and execute requests, plus CLI dry-run E2E coverage for both new commands.

Address PR review feedback by registering the app feed card live workflow cleanup immediately after a successful create exit before stdout assertions can fail.

Verification: go test ./shortcuts/im -run 'TestBuildFeedCard|TestFeedCard|TestShortcuts' -count=1; go test ./shortcuts/im ./shortcuts -count=1; go vet ./shortcuts/im; go build -o /tmp/lark-cli-feed-card-test .; env LARK_CLI_BIN=/tmp/lark-cli-feed-card-test go test ./tests/cli_e2e/im -run 'TestIM_(AppFeedCard|FeedCard).*DryRun' -count=1.

Author: renxianwei98

shortcuts/im/helpers_test.go

@@ -647,6 +647,8 @@ func TestShortcuts(t *testing.T) {
 		"+app-feed-card-create",
 		"+app-feed-card-delete",
 		"+app-feed-card-update",
+		"+feed-card-bot-time-sensitive",
+		"+feed-card-time-sensitive",
 		"+chat-create",
 		"+chat-messages-list",
 		"+chat-search",

shortcuts/im/im_feed_card_time_sensitive.go

@@ -0,0 +1,171 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package im
+
+import (
+	"context"
+	"io"
+	"net/http"
+	"strings"
+
+	"github.com/larksuite/cli/internal/output"
+	"github.com/larksuite/cli/internal/validate"
+	"github.com/larksuite/cli/shortcuts/common"
+	larkcore "github.com/larksuite/oapi-sdk-go/v3/core"
+)
+
+const feedCardTimeSensitiveBasePath = "/open-apis/im/v2/feed_cards"
+const feedCardBotTimeSensitiveSegment = "bot_time_sentive"
+const feedCardBotTimeSensitivePath = feedCardTimeSensitiveBasePath + "/" + feedCardBotTimeSensitiveSegment
+const feedCardTimeSensitivePathTemplate = feedCardTimeSensitiveBasePath + "/:feed_card_id"
+
+const feedCardTimeSensitiveScope = "im:datasync.feed_card.time_sensitive:write"
+
+var ImFeedCardBotTimeSensitive = common.Shortcut{
+	Service:     "im",
+	Command:     "+feed-card-bot-time-sensitive",
+	Description: "Set bot chat feed cards as temporarily pinned or unpinned for users; bot only",
+	Risk:        "write",
+	Scopes:      []string{feedCardTimeSensitiveScope},
+	AuthTypes:   []string{"bot"},
+	HasFormat:   true,
+	Flags: []common.Flag{
+		{Name: "user-ids", Desc: "recipient user IDs, comma-separated; IDs must match --user-id-type", Required: true},
+		{Name: "user-id-type", Default: "open_id", Desc: "recipient ID type", Enum: []string{"open_id", "union_id", "user_id"}},
+		{Name: "time-sensitive", Type: "bool", Desc: "temporary pin status; pass true to pin or false to unpin", Required: true},
+	},
+	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
+		body, _ := buildFeedCardTimeSensitiveBody(runtime)
+		return common.NewDryRunAPI().
+			PATCH(feedCardBotTimeSensitivePath).
+			Params(map[string]interface{}{"user_id_type": appFeedCardUserIDType(runtime)}).
+			Body(body)
+	},
+	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
+		_, err := buildFeedCardTimeSensitiveBody(runtime)
+		return err
+	},
+	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
+		body, err := buildFeedCardTimeSensitiveBody(runtime)
+		if err != nil {
+			return err
+		}
+		_, err = runtime.DoAPIJSON(http.MethodPatch, feedCardBotTimeSensitivePath,
+			larkcore.QueryParams{"user_id_type": []string{appFeedCardUserIDType(runtime)}},
+			body,
+		)
+		if err != nil {
+			return err
+		}
+		return outputFeedCardTimeSensitiveResult(runtime, "", body)
+	},
+}
+
+var ImFeedCardTimeSensitive = common.Shortcut{
+	Service:     "im",
+	Command:     "+feed-card-time-sensitive",
+	Description: "Set a feed card as temporarily pinned or unpinned for users by feed_card_id; bot only",
+	Risk:        "write",
+	Scopes:      []string{feedCardTimeSensitiveScope},
+	AuthTypes:   []string{"bot"},
+	HasFormat:   true,
+	Flags: []common.Flag{
+		{Name: "feed-card-id", Desc: "feed_card_id to update", Required: true},
+		{Name: "user-ids", Desc: "recipient user IDs, comma-separated; IDs must match --user-id-type", Required: true},
+		{Name: "user-id-type", Default: "open_id", Desc: "recipient ID type", Enum: []string{"open_id", "union_id", "user_id"}},
+		{Name: "time-sensitive", Type: "bool", Desc: "temporary pin status; pass true to pin or false to unpin", Required: true},
+	},
+	DryRun: func(ctx context.Context, runtime *common.RuntimeContext) *common.DryRunAPI {
+		body, _ := buildFeedCardTimeSensitiveBody(runtime)
+		return common.NewDryRunAPI().
+			PATCH(feedCardTimeSensitivePathTemplate).
+			Set("feed_card_id", strings.TrimSpace(runtime.Str("feed-card-id"))).
+			Params(map[string]interface{}{"user_id_type": appFeedCardUserIDType(runtime)}).
+			Body(body)
+	},
+	Validate: func(ctx context.Context, runtime *common.RuntimeContext) error {
+		if _, err := feedCardIDForTimeSensitive(runtime); err != nil {
+			return err
+		}
+		_, err := buildFeedCardTimeSensitiveBody(runtime)
+		return err
+	},
+	Execute: func(ctx context.Context, runtime *common.RuntimeContext) error {
+		requestPath, feedCardID, err := feedCardTimeSensitiveRequestPath(runtime)
+		if err != nil {
+			return err
+		}
+		body, err := buildFeedCardTimeSensitiveBody(runtime)
+		if err != nil {
+			return err
+		}
+		_, err = runtime.DoAPIJSON(http.MethodPatch, requestPath,
+			larkcore.QueryParams{"user_id_type": []string{appFeedCardUserIDType(runtime)}},
+			body,
+		)
+		if err != nil {
+			return err
+		}
+		return outputFeedCardTimeSensitiveResult(runtime, feedCardID, body)
+	},
+}
+
+func buildFeedCardTimeSensitiveBody(runtime *common.RuntimeContext) (map[string]interface{}, error) {
+	userIDs := common.SplitCSV(runtime.Str("user-ids"))
+	if err := validateAppFeedUserIDs(userIDs, appFeedCardUserIDType(runtime), "--user-ids"); err != nil {
+		return nil, err
+	}
+	if !flagChanged(runtime, "time-sensitive") {
+		return nil, output.ErrValidation("--time-sensitive is required; pass --time-sensitive=true to pin or --time-sensitive=false to unpin")
+	}
+	return map[string]interface{}{
+		"user_ids":       userIDs,
+		"time_sensitive": runtime.Bool("time-sensitive"),
+	}, nil
+}
+
+func feedCardIDForTimeSensitive(runtime *common.RuntimeContext) (string, error) {
+	feedCardID := strings.TrimSpace(runtime.Str("feed-card-id"))
+	if feedCardID == "" {
+		return "", output.ErrValidation("--feed-card-id is required")
+	}
+	if isReservedFeedCardTimeSensitiveSegment(feedCardID) {
+		return "", output.ErrWithHint(output.ExitValidation, "validation",
+			`--feed-card-id "bot_time_sentive" conflicts with the bot time sensitive endpoint`,
+			`use "lark-cli im +feed-card-bot-time-sensitive" for /open-apis/im/v2/feed_cards/bot_time_sentive, or pass a real feed_card_id to "lark-cli im +feed-card-time-sensitive"`)
+	}
+	if !strings.HasPrefix(feedCardID, "oc_") {
+		return "", output.ErrWithHint(output.ExitValidation, "validation",
+			`--feed-card-id must be a group feed_card_id starting with "oc_"`,
+			`use "lark-cli im +feed-card-bot-time-sensitive" for the bot conversation endpoint, or pass a group feed_card_id such as oc_xxx to "lark-cli im +feed-card-time-sensitive"`)
+	}
+	return feedCardID, nil
+}
+
+func feedCardTimeSensitiveRequestPath(runtime *common.RuntimeContext) (string, string, error) {
+	feedCardID, err := feedCardIDForTimeSensitive(runtime)
+	if err != nil {
+		return "", "", err
+	}
+	return feedCardTimeSensitiveBasePath + "/" + validate.EncodePathSegment(feedCardID), feedCardID, nil
+}
+
+func isReservedFeedCardTimeSensitiveSegment(feedCardID string) bool {
+	return feedCardID == feedCardBotTimeSensitiveSegment
+}
+
+func outputFeedCardTimeSensitiveResult(runtime *common.RuntimeContext, feedCardID string, body map[string]interface{}) error {
+	userIDs, _ := body["user_ids"].([]string)
+	out := map[string]interface{}{
+		"requested_user_count": len(userIDs),
+		"time_sensitive":       body["time_sensitive"],
+	}
+	if feedCardID != "" {
+		out["feed_card_id"] = feedCardID
+	}
+	runtime.OutFormat(out, nil, func(w io.Writer) {
+		output.PrintTable(w, []map[string]interface{}{out})
+	})
+	return nil
+}

shortcuts/im/im_feed_card_time_sensitive_test.go

@@ -0,0 +1,217 @@
+// Copyright (c) 2026 Lark Technologies Pte. Ltd.
+// SPDX-License-Identifier: MIT
+
+package im
+
+import (
+	"context"
+	"encoding/json"
+	"strings"
+	"testing"
+
+	"github.com/larksuite/cli/internal/httpmock"
+)
+
+func TestBuildFeedCardTimeSensitiveBody(t *testing.T) {
+	runtime := newTestRuntimeContext(t, map[string]string{
+		"user-ids": "ou_1, ou_2",
+	}, map[string]bool{
+		"time-sensitive": true,
+	})
+
+	body, err := buildFeedCardTimeSensitiveBody(runtime)
+	if err != nil {
+		t.Fatalf("buildFeedCardTimeSensitiveBody() error = %v", err)
+	}
+	userIDs, _ := body["user_ids"].([]string)
+	if len(userIDs) != 2 || userIDs[0] != "ou_1" || userIDs[1] != "ou_2" {
+		t.Fatalf("user_ids = %#v", body["user_ids"])
+	}
+	if body["time_sensitive"] != true {
+		t.Fatalf("time_sensitive = %#v", body["time_sensitive"])
+	}
+}
+
+func TestBuildFeedCardTimeSensitiveBodyAcceptsFalse(t *testing.T) {
+	runtime := newTestRuntimeContext(t, map[string]string{
+		"user-ids": "ou_1",
+	}, map[string]bool{
+		"time-sensitive": false,
+	})
+
+	body, err := buildFeedCardTimeSensitiveBody(runtime)
+	if err != nil {
+		t.Fatalf("buildFeedCardTimeSensitiveBody() error = %v", err)
+	}
+	if body["time_sensitive"] != false {
+		t.Fatalf("time_sensitive = %#v", body["time_sensitive"])
+	}
+}
+
+func TestBuildFeedCardTimeSensitiveBodyValidation(t *testing.T) {
+	invalidOpenIDErr := invalidOpenIDError(t)
+	tests := []struct {
+		name      string
+		strFlags  map[string]string
+		boolFlags map[string]bool
+		wantErr   string
+	}{
+		{
+			name:     "missing time sensitive",
+			strFlags: map[string]string{"user-ids": "ou_1"},
+			wantErr:  "--time-sensitive is required",
+		},
+		{
+			name:      "invalid recipient open id",
+			strFlags:  map[string]string{"user-ids": "bad_user"},
+			boolFlags: map[string]bool{"time-sensitive": true},
+			wantErr:   invalidOpenIDErr,
+		},
+		{
+			name:      "union id bypasses open id prefix validation",
+			strFlags:  map[string]string{"user-ids": "onion_1", "user-id-type": "union_id"},
+			boolFlags: map[string]bool{"time-sensitive": true},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			runtime := newTestRuntimeContext(t, tt.strFlags, tt.boolFlags)
+			_, err := buildFeedCardTimeSensitiveBody(runtime)
+			if tt.wantErr == "" {
+				if err != nil {
+					t.Fatalf("unexpected error = %v", err)
+				}
+				return
+			}
+			if err == nil || !strings.Contains(err.Error(), tt.wantErr) {
+				t.Fatalf("error = %v, want substring %q", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func TestFeedCardIDForTimeSensitiveValidation(t *testing.T) {
+	runtime := newTestRuntimeContext(t, map[string]string{"feed-card-id": "  "}, nil)
+	if _, err := feedCardIDForTimeSensitive(runtime); err == nil || !strings.Contains(err.Error(), "--feed-card-id is required") {
+		t.Fatalf("feedCardIDForTimeSensitive() error = %v", err)
+	}
+
+	runtime = newTestRuntimeContext(t, map[string]string{"feed-card-id": "bot_time_sentive"}, nil)
+	if _, err := feedCardIDForTimeSensitive(runtime); err == nil ||
+		!strings.Contains(err.Error(), "conflicts with the bot time sensitive endpoint") {
+		t.Fatalf("feedCardIDForTimeSensitive() reserved segment error = %v", err)
+	}
+
+	runtime = newTestRuntimeContext(t, map[string]string{"feed-card-id": "om_123"}, nil)
+	if _, err := feedCardIDForTimeSensitive(runtime); err == nil ||
+		!strings.Contains(err.Error(), `starting with "oc_"`) {
+		t.Fatalf("feedCardIDForTimeSensitive() non-group feed card error = %v", err)
+	}
+}
+
+func TestFeedCardTimeSensitiveRequestPathRejectsReservedSegment(t *testing.T) {
+	runtime := newTestRuntimeContext(t, map[string]string{"feed-card-id": "bot_time_sentive"}, nil)
+	if _, _, err := feedCardTimeSensitiveRequestPath(runtime); err == nil ||
+		!strings.Contains(err.Error(), "conflicts with the bot time sensitive endpoint") {
+		t.Fatalf("feedCardTimeSensitiveRequestPath() error = %v", err)
+	}
+}
+
+func TestFeedCardTimeSensitiveDryRunShape(t *testing.T) {
+	botRuntime := newTestRuntimeContext(t, map[string]string{
+		"user-ids": "ou_1",
+	}, map[string]bool{
+		"time-sensitive": true,
+	})
+	botGot := mustMarshalDryRun(t, ImFeedCardBotTimeSensitive.DryRun(context.Background(), botRuntime))
+	if !strings.Contains(botGot, `"method":"PATCH"`) ||
+		!strings.Contains(botGot, `"/open-apis/im/v2/feed_cards/bot_time_sentive"`) ||
+		!strings.Contains(botGot, `"user_id_type":"open_id"`) ||
+		!strings.Contains(botGot, `"time_sensitive":true`) {
+		t.Fatalf("ImFeedCardBotTimeSensitive.DryRun() = %s", botGot)
+	}
+
+	cardRuntime := newTestRuntimeContext(t, map[string]string{
+		"feed-card-id": "oc_dryrun",
+		"user-ids":     "ou_1",
+	}, map[string]bool{
+		"time-sensitive": false,
+	})
+	cardGot := mustMarshalDryRun(t, ImFeedCardTimeSensitive.DryRun(context.Background(), cardRuntime))
+	if !strings.Contains(cardGot, `"method":"PATCH"`) ||
+		!strings.Contains(cardGot, `"/open-apis/im/v2/feed_cards/oc_dryrun"`) ||
+		!strings.Contains(cardGot, `"time_sensitive":false`) {
+		t.Fatalf("ImFeedCardTimeSensitive.DryRun() = %s", cardGot)
+	}
+}
+
+func TestFeedCardBotTimeSensitiveExecute(t *testing.T) {
+	factory, stdout, reg := newIMExecuteFactory(t)
+	stub := &httpmock.Stub{
+		Method: "PATCH",
+		URL:    feedCardBotTimeSensitivePath,
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "ok",
+			"data": map[string]interface{}{},
+		},
+	}
+	reg.Register(stub)
+
+	err := mountAndRunIMShortcut(t, ImFeedCardBotTimeSensitive, []string{
+		"+feed-card-bot-time-sensitive",
+		"--user-ids", "ou_1",
+		"--time-sensitive",
+	}, factory, stdout)
+	if err != nil {
+		t.Fatalf("mountAndRunIMShortcut() error = %v", err)
+	}
+	if !strings.Contains(stdout.String(), `"requested_user_count": 1`) || !strings.Contains(stdout.String(), `"time_sensitive": true`) {
+		t.Fatalf("stdout = %s", stdout.String())
+	}
+
+	var captured map[string]interface{}
+	if err := json.Unmarshal(stub.CapturedBody, &captured); err != nil {
+		t.Fatalf("captured body JSON = %s, err=%v", string(stub.CapturedBody), err)
+	}
+	if captured["time_sensitive"] != true {
+		t.Fatalf("captured body = %#v", captured)
+	}
+}
+
+func TestFeedCardTimeSensitiveExecute(t *testing.T) {
+	factory, stdout, reg := newIMExecuteFactory(t)
+	stub := &httpmock.Stub{
+		Method: "PATCH",
+		URL:    "/open-apis/im/v2/feed_cards/oc_123",
+		Body: map[string]interface{}{
+			"code": 0,
+			"msg":  "ok",
+			"data": map[string]interface{}{},
+		},
+	}
+	reg.Register(stub)
+
+	err := mountAndRunIMShortcut(t, ImFeedCardTimeSensitive, []string{
+		"+feed-card-time-sensitive",
+		"--feed-card-id", "oc_123",
+		"--user-ids", "ou_1",
+		"--time-sensitive=false",
+	}, factory, stdout)
+	if err != nil {
+		t.Fatalf("mountAndRunIMShortcut() error = %v", err)
+	}
+	if !strings.Contains(stdout.String(), `"feed_card_id": "oc_123"`) || !strings.Contains(stdout.String(), `"time_sensitive": false`) {
+		t.Fatalf("stdout = %s", stdout.String())
+	}
+
+	var captured map[string]interface{}
+	if err := json.Unmarshal(stub.CapturedBody, &captured); err != nil {
+		t.Fatalf("captured body JSON = %s, err=%v", string(stub.CapturedBody), err)
+	}
+	userIDs, _ := captured["user_ids"].([]interface{})
+	if len(userIDs) != 1 || captured["time_sensitive"] != false {
+		t.Fatalf("captured body = %#v", captured)
+	}
+}