fix(chat): normalize threads

Author: Peter Steinberger

internal/cmd/chat_dm.go

@@ -56,7 +56,11 @@ func (c *ChatDMSendCmd) Run(ctx context.Context, flags *RootFlags) error {
 	message := &chat.Message{Text: text}
 	thread := strings.TrimSpace(c.Thread)
 	if thread != "" {
-		message.Thread = &chat.Thread{Name: thread}
+		threadName, err := normalizeThread(space.Name, thread)
+		if err != nil {
+			return usage(fmt.Sprintf("invalid thread: %v", err))
+		}
+		message.Thread = &chat.Thread{Name: threadName}
 	}
 
 	call := svc.Spaces.Messages.Create(space.Name, message)

internal/cmd/chat_helpers.go

@@ -33,6 +33,30 @@ func normalizeUser(resource string) string {
 	return "users/" + user
 }
 
+func normalizeThread(space, resource string) (string, error) {
+	thread := strings.TrimSpace(resource)
+	if thread == "" {
+		return "", fmt.Errorf("empty thread")
+	}
+	if strings.HasPrefix(thread, "spaces/") {
+		if !strings.Contains(thread, "/threads/") {
+			return "", fmt.Errorf("invalid thread resource %q", thread)
+		}
+		return thread, nil
+	}
+	if strings.HasPrefix(thread, "threads/") {
+		thread = strings.TrimPrefix(thread, "threads/")
+	}
+	if strings.Contains(thread, "/") {
+		return "", fmt.Errorf("invalid thread id %q", thread)
+	}
+	space, err := normalizeSpace(space)
+	if err != nil {
+		return "", err
+	}
+	return fmt.Sprintf("%s/threads/%s", space, thread), nil
+}
+
 func parseCommaArgs(values []string) []string {
 	out := make([]string, 0, len(values))
 	for _, raw := range values {

internal/cmd/chat_messages.go

@@ -46,7 +46,11 @@ func (c *ChatMessagesListCmd) Run(ctx context.Context, flags *RootFlags) error {
 	filters := make([]string, 0, 2)
 	thread := strings.TrimSpace(c.Thread)
 	if thread != "" {
-		filters = append(filters, fmt.Sprintf("thread.name = \"%s\"", thread))
+		threadName, err := normalizeThread(space, thread)
+		if err != nil {
+			return usage(fmt.Sprintf("invalid thread: %v", err))
+		}
+		filters = append(filters, fmt.Sprintf("thread.name = \"%s\"", threadName))
 	}
 	if c.Unread {
 		readState, readErr := svc.Users.Spaces.GetSpaceReadState(fmt.Sprintf("users/me/spaces/%s/spaceReadState", spaceID(space))).Do()
@@ -155,7 +159,11 @@ func (c *ChatMessagesSendCmd) Run(ctx context.Context, flags *RootFlags) error {
 	message := &chat.Message{Text: text}
 	thread := strings.TrimSpace(c.Thread)
 	if thread != "" {
-		message.Thread = &chat.Thread{Name: thread}
+		threadName, err := normalizeThread(space, thread)
+		if err != nil {
+			return usage(fmt.Sprintf("invalid thread: %v", err))
+		}
+		message.Thread = &chat.Thread{Name: threadName}
 	}
 
 	call := svc.Spaces.Messages.Create(space, message)

internal/cmd/chat_spaces.go

@@ -219,13 +219,16 @@ func (c *ChatSpacesCreateCmd) Run(ctx context.Context, flags *RootFlags) error {
 		})
 	}
 
-	resp, err := svc.Spaces.Setup(&chat.SetUpSpaceRequest{
+	req := &chat.SetUpSpaceRequest{
 		Space: &chat.Space{
 			SpaceType:   "SPACE",
 			DisplayName: displayName,
 		},
-		Memberships: memberships,
-	}).Do()
+	}
+	if len(memberships) > 0 {
+		req.Memberships = memberships
+	}
+	resp, err := svc.Spaces.Setup(req).Do()
 	if err != nil {
 		return err
 	}

internal/cmd/execute_chat_test.go

@@ -232,7 +232,7 @@ func TestExecute_ChatMessagesList_Text_Unread(t *testing.T) {
 
 	out := captureStdout(t, func() {
 		errOut := captureStderr(t, func() {
-			if err := Execute([]string{"--account", "a@b.com", "chat", "messages", "list", "spaces/aaa", "--unread"}); err != nil {
+			if err := Execute([]string{"--account", "a@b.com", "chat", "messages", "list", "spaces/aaa", "--unread", "--thread", "t1"}); err != nil {
 				t.Fatalf("Execute: %v", err)
 			}
 		})
@@ -246,13 +246,17 @@ func TestExecute_ChatMessagesList_Text_Unread(t *testing.T) {
 	if !strings.Contains(gotFilter, "createTime > \"2025-01-01T00:00:00Z\"") {
 		t.Fatalf("unexpected filter: %q", gotFilter)
 	}
+	if !strings.Contains(gotFilter, "thread.name = \"spaces/aaa/threads/t1\"") {
+		t.Fatalf("unexpected thread filter: %q", gotFilter)
+	}
 }
 
 func TestExecute_ChatMessagesSend_JSON(t *testing.T) {
 	origNew := newChatService
 	t.Cleanup(func() { newChatService = origNew })
 
 	var gotText string
+	var gotThread string
 
 	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		if !(r.Method == http.MethodPost && strings.Contains(r.URL.Path, "/messages")) {
@@ -262,6 +266,9 @@ func TestExecute_ChatMessagesSend_JSON(t *testing.T) {
 		var body map[string]any
 		_ = json.NewDecoder(r.Body).Decode(&body)
 		gotText, _ = body["text"].(string)
+		if thread, ok := body["thread"].(map[string]any); ok {
+			gotThread, _ = thread["name"].(string)
+		}
 
 		w.Header().Set("Content-Type", "application/json")
 		_ = json.NewEncoder(w).Encode(map[string]any{
@@ -282,14 +289,17 @@ func TestExecute_ChatMessagesSend_JSON(t *testing.T) {
 
 	out := captureStdout(t, func() {
 		_ = captureStderr(t, func() {
-			if err := Execute([]string{"--json", "--account", "a@b.com", "chat", "messages", "send", "spaces/aaa", "--text", "hello"}); err != nil {
+			if err := Execute([]string{"--json", "--account", "a@b.com", "chat", "messages", "send", "spaces/aaa", "--text", "hello", "--thread", "t1"}); err != nil {
 				t.Fatalf("Execute: %v", err)
 			}
 		})
 	})
 	if gotText != "hello" {
 		t.Fatalf("unexpected text: %q", gotText)
 	}
+	if gotThread != "spaces/aaa/threads/t1" {
+		t.Fatalf("unexpected thread: %q", gotThread)
+	}
 	if !strings.Contains(out, "spaces/aaa/messages/msg2") {
 		t.Fatalf("unexpected out=%q", out)
 	}