[CAP-8118] fix local dev server task and taskrun list behavior (#325)

blue-keleher · render-oss-copybara-sync[bot] · commit a2075ff6e9f5 · 2026-03-03T22:42:28.000Z
Fix local dev server to properly handle `tasks list` and `taskruns list` commands:
- `taskruns list`:
  - list all task runs without requiring a task ID filter (non-interactive only)
  - resolve task names (not just task IDs) when filtering task runs
  - populate `parentTaskRunId` and `rootTaskRunId` in task run responses
- `tasks list`:
  - list all tasks without requiring a workflow version ID (non-interactive only)
  - reject workflow version IDs in local mode (they don't exist locally)

GitOrigin-RevId: f4c262c6978c036fed9f9083a56acf891fe0227d
diff --git a/cmd/tasklist.go b/cmd/tasklist.go
@@ -41,6 +41,7 @@ Examples:
 			}
 
 			var input workflowviews.TaskListInput
+			input.Local = local
 			err = command.ParseCommand(cmd, args, &input)
 			if err != nil {
 				return fmt.Errorf("failed to parse command: %w", err)
diff --git a/cmd/taskrunlist.go b/cmd/taskrunlist.go
@@ -40,6 +40,7 @@ Examples:
 			}
 
 			var input workflowviews.TaskRunListInput
+			input.Local = local
 			err = command.ParseCommand(cmd, args, &input)
 			if err != nil {
 				return fmt.Errorf("failed to parse command: %w", err)
diff --git a/pkg/tui/flows/workflow.go b/pkg/tui/flows/workflow.go
@@ -179,8 +179,7 @@ func (f *Workflow) versionRelease(ctx context.Context, input *workflowviews.Vers
 
 func (f *Workflow) unspecifiedTask(ctx context.Context, action func(t *workflows.Task) tea.Cmd) tea.Cmd {
 	if f.local {
-		// when running locally, we don't have a workflow version id, so we just use a dummy one
-		return f.taskList(ctx, &workflowviews.TaskListInput{WorkflowVersionID: "local"}, action)
+		return f.taskList(ctx, &workflowviews.TaskListInput{}, action)
 	}
 
 	return f.workflowList(ctx, &workflowviews.WorkflowInput{}, func(ctx context.Context, r resource.Resource) tea.Cmd {
diff --git a/pkg/tui/views/workflows/loader.go b/pkg/tui/views/workflows/loader.go
@@ -275,7 +275,10 @@ func (w *WorkflowLoader) GetTask(ctx context.Context, id string) (*wfclient.Task
 
 func (w *WorkflowLoader) LoadTaskRunList(ctx context.Context, input TaskRunListInput, cur client.Cursor) (client.Cursor, []*wfclient.TaskRun, error) {
 	pageSize := 20
-	params := &client.ListTaskRunsParams{Limit: &pageSize, TaskId: pointers.From([]string{input.TaskID})}
+	params := &client.ListTaskRunsParams{Limit: &pageSize}
+	if input.TaskID != "" {
+		params.TaskId = pointers.From([]string{input.TaskID})
+	}
 	if cur != "" {
 		params.Cursor = &cur
 	}
@@ -312,7 +315,10 @@ func (w *WorkflowLoader) LoadAllTasks(ctx context.Context, input TaskListInput)
 // progressive loading, so older runs beyond this limit will not be shown.
 func (w *WorkflowLoader) LoadAllTaskRuns(ctx context.Context, input TaskRunListInput) ([]*wfclient.TaskRun, error) {
 	pageSize := 100
-	params := &client.ListTaskRunsParams{Limit: &pageSize, TaskId: pointers.From([]string{input.TaskID})}
+	params := &client.ListTaskRunsParams{Limit: &pageSize}
+	if input.TaskID != "" {
+		params.TaskId = pointers.From([]string{input.TaskID})
+	}
 
 	_, taskRuns, err := w.taskRepo.ListTaskRuns(ctx, params)
 	return taskRuns, err
diff --git a/pkg/tui/views/workflows/types.go b/pkg/tui/views/workflows/types.go
@@ -11,6 +11,7 @@ type TaskListInput struct {
 	WorkflowVersionID string `cli:"arg:0"`
 	WorkflowID        string
 	LatestVersionOnly bool
+	Local             bool
 }
 
 type TaskRunInput struct {
@@ -28,6 +29,7 @@ type VersionListInput struct {
 
 type TaskRunListInput struct {
 	TaskID string `cli:"arg:0"`
+	Local  bool
 }
 
 type VersionReleaseInput struct {
@@ -37,14 +39,17 @@ type VersionReleaseInput struct {
 }
 
 func (t TaskListInput) Validate(interactive bool) error {
-	if !interactive && t.WorkflowVersionID == "" {
+	if !interactive && t.Local && t.WorkflowVersionID != "" {
+		return errors.New("workflow version id is not supported in local mode")
+	}
+	if !interactive && !t.Local && t.WorkflowVersionID == "" {
 		return errors.New("workflow version id must be specified when output is not interactive")
 	}
 	return nil
 }
 
 func (t TaskRunListInput) Validate(interactive bool) error {
-	if !interactive && t.TaskID == "" {
+	if !interactive && !t.Local && t.TaskID == "" {
 		return errors.New("task id must be specified when output is not interactive")
 	}
 	return nil
diff --git a/pkg/tui/views/workflows/types_test.go b/pkg/tui/views/workflows/types_test.go
@@ -24,6 +24,18 @@ func TestTaskListInputValidate(t *testing.T) {
 		input := TaskListInput{WorkflowVersionID: "wfv-123"}
 		assert.NoError(t, input.Validate(false))
 	})
+
+	t.Run("non-interactive local allows empty version ID", func(t *testing.T) {
+		input := TaskListInput{Local: true}
+		assert.NoError(t, input.Validate(false))
+	})
+
+	t.Run("non-interactive local rejects version ID", func(t *testing.T) {
+		input := TaskListInput{Local: true, WorkflowVersionID: "wfv-123"}
+		err := input.Validate(false)
+		require.Error(t, err)
+		assert.Contains(t, err.Error(), "workflow version id is not supported in local mode")
+	})
 }
 
 func TestTaskRunInputValidate(t *testing.T) {
@@ -76,6 +88,16 @@ func TestTaskRunListInputValidate(t *testing.T) {
 		input := TaskRunListInput{TaskID: "tsk-1"}
 		assert.NoError(t, input.Validate(false))
 	})
+
+	t.Run("non-interactive local allows empty task ID", func(t *testing.T) {
+		input := TaskRunListInput{Local: true}
+		assert.NoError(t, input.Validate(false))
+	})
+
+	t.Run("non-interactive local with task ID succeeds", func(t *testing.T) {
+		input := TaskRunListInput{TaskID: "tsk-1", Local: true}
+		assert.NoError(t, input.Validate(false))
+	})
 }
 
 func TestVersionListInputValidate(t *testing.T) {
diff --git a/pkg/workflows/apiserver/internal/handler.go b/pkg/workflows/apiserver/internal/handler.go
@@ -37,12 +37,17 @@ func GetTask(store *store.TaskStore, taskID string) *workflowclient.Task {
 	return mapTask(task)
 }
 
-func ListTaskRuns(store *store.TaskStore, taskID string) []*workflowclient.TaskRun {
-	taskRuns := store.GetTaskRuns(taskID)
+func ListTaskRuns(s *store.TaskStore, taskID string) []*workflowclient.TaskRun {
+	var taskRuns []*store.TaskRun
+	if taskID == "" {
+		taskRuns = s.GetAllTaskRuns()
+	} else {
+		taskRuns = s.GetTaskRuns(taskID)
+	}
 
 	taskRunList := make([]*workflowclient.TaskRun, len(taskRuns))
 	for i, taskRun := range taskRuns {
-		taskRunList[i] = MapTaskRun(store, taskRun)
+		taskRunList[i] = MapTaskRun(s, taskRun)
 	}
 
 	return taskRunList
diff --git a/pkg/workflows/apiserver/internal/handler_test.go b/pkg/workflows/apiserver/internal/handler_test.go
@@ -57,23 +57,53 @@ func (f *fakeRunner) StartTask(ctx context.Context, taskName string, input []byt
 }
 
 func TestListTaskRuns(t *testing.T) {
-	store := store.NewTaskStore()
+	t.Run("by task ID", func(t *testing.T) {
+		store := store.NewTaskStore()
 
-	store.SetTasks([]taskserver.Task{
-		{
-			Name: "test",
-		},
+		store.SetTasks([]taskserver.Task{
+			{Name: "test"},
+		})
+
+		store.StartTaskRun("test", []byte("abc"), nil)
+
+		tasks := store.GetTasks()
+		got := internal.ListTaskRuns(store, tasks[0].ID)
+
+		require.Equal(t, 1, len(got))
+		require.Equal(t, tasks[0].ID, got[0].TaskId)
 	})
 
-	input := []byte("abc")
+	t.Run("by task name", func(t *testing.T) {
+		store := store.NewTaskStore()
 
-	store.StartTaskRun("test", input, nil)
+		store.SetTasks([]taskserver.Task{
+			{Name: "test"},
+		})
 
-	tasks := store.GetTasks()
-	got := internal.ListTaskRuns(store, tasks[0].ID)
+		store.StartTaskRun("test", []byte("abc"), nil)
 
-	require.Equal(t, 1, len(got))
-	require.Equal(t, tasks[0].ID, got[0].TaskId)
+		tasks := store.GetTasks()
+		got := internal.ListTaskRuns(store, "test")
+
+		require.Equal(t, 1, len(got))
+		require.Equal(t, tasks[0].ID, got[0].TaskId)
+	})
+
+	t.Run("all task runs when taskID is empty", func(t *testing.T) {
+		store := store.NewTaskStore()
+
+		store.SetTasks([]taskserver.Task{
+			{Name: "task1"},
+			{Name: "task2"},
+		})
+
+		store.StartTaskRun("task1", []byte("abc"), nil)
+		store.StartTaskRun("task2", []byte("def"), nil)
+
+		got := internal.ListTaskRuns(store, "")
+
+		require.Equal(t, 2, len(got))
+	})
 }
 
 func TestGetTaskRun(t *testing.T) {
diff --git a/pkg/workflows/apiserver/internal/map.go b/pkg/workflows/apiserver/internal/map.go
@@ -36,15 +36,24 @@ func mapTaskRunStatus(status store.TaskRunStatus) workflowClient.TaskRunStatus {
 	}
 }
 
+func parentTaskRunID(taskRun *store.TaskRun) string {
+	if taskRun.ParentTaskRunID != nil {
+		return *taskRun.ParentTaskRunID
+	}
+	return ""
+}
+
 func MapTaskRun(store *store.TaskStore, taskRun *store.TaskRun) *workflowClient.TaskRun {
 	task := store.GetTaskByName(taskRun.TaskName)
 
 	return &workflowClient.TaskRun{
-		Id:          taskRun.ID,
-		TaskId:      task.ID,
-		Status:      mapTaskRunStatus(taskRun.Status),
-		StartedAt:   taskRun.StartedAt,
-		CompletedAt: taskRun.CompletedAt,
+		Id:              taskRun.ID,
+		TaskId:          task.ID,
+		Status:          mapTaskRunStatus(taskRun.Status),
+		StartedAt:       taskRun.StartedAt,
+		CompletedAt:     taskRun.CompletedAt,
+		ParentTaskRunId: parentTaskRunID(taskRun),
+		RootTaskRunId:   taskRun.RootTaskRunID,
 	}
 }
 
@@ -59,14 +68,16 @@ func mapTaskRunDetails(store *store.TaskStore, taskRun *store.TaskRun) *workflow
 	_ = json.Unmarshal(taskRun.Input, &input)
 
 	return &workflowClient.TaskRunDetails{
-		Id:          taskRun.ID,
-		TaskId:      task.ID,
-		Status:      mapTaskRunStatus(taskRun.Status),
-		StartedAt:   taskRun.StartedAt,
-		CompletedAt: taskRun.CompletedAt,
-		Results:     results,
-		Input:       input,
-		Error:       taskRun.Error,
+		Id:              taskRun.ID,
+		TaskId:          task.ID,
+		Status:          mapTaskRunStatus(taskRun.Status),
+		StartedAt:       taskRun.StartedAt,
+		CompletedAt:     taskRun.CompletedAt,
+		Results:         results,
+		Input:           input,
+		Error:           taskRun.Error,
+		ParentTaskRunId: parentTaskRunID(taskRun),
+		RootTaskRunId:   taskRun.RootTaskRunID,
 	}
 }
 
diff --git a/pkg/workflows/apiserver/server.go b/pkg/workflows/apiserver/server.go
@@ -175,11 +175,6 @@ func (h *ServerHandler) ListTaskRuns(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "application/json")
 
 	taskID := r.URL.Query().Get("taskId")
-	if taskID == "" {
-		handleError(w, fmt.Errorf("taskId is required"), http.StatusBadRequest)
-		return
-	}
-
 	json.NewEncoder(w).Encode(internal.ListTaskRuns(h.taskStore, taskID))
 }
 
diff --git a/pkg/workflows/store/store.go b/pkg/workflows/store/store.go
@@ -30,6 +30,9 @@ type TaskRun struct {
 	CompletedAt *time.Time
 
 	ParentTaskRunID *string
+	// RootTaskRunID is the ID of the top-level task run that initiated this
+	// chain of subtasks. For root tasks, this equals ID.
+	RootTaskRunID string
 }
 
 type TaskRunStatus string
@@ -77,15 +80,27 @@ func (s *TaskStore) StartTaskRun(taskName string, input []byte, parentTaskRunID
 	s.mu.Lock()
 	defer s.mu.Unlock()
 
+	id := NewTaskRunID()
+
+	// Propagate the root task run ID from the parent. For root tasks (no
+	// parent), the task run is its own root.
+	rootTaskRunID := id
+	if parentTaskRunID != nil {
+		if parent := s.getTaskRun(*parentTaskRunID); parent != nil {
+			rootTaskRunID = parent.RootTaskRunID
+		}
+	}
+
 	taskRun := &TaskRun{
-		ID:       NewTaskRunID(),
+		ID:       id,
 		TaskName: taskName,
 		Input:    input,
 		Status:   TaskRunStatusRunning,
 
 		StartedAt: pointers.From(time.Now()),
 
 		ParentTaskRunID: parentTaskRunID,
+		RootTaskRunID:   rootTaskRunID,
 	}
 
 	s.taskRuns = append(s.taskRuns, taskRun)
@@ -133,19 +148,22 @@ func (s *TaskStore) FailTaskRun(taskRunID string, errString string) (*TaskRun, e
 	return taskRun, nil
 }
 
-func (s *TaskStore) GetTaskRun(taskRunID string) *TaskRun {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-
+func (s *TaskStore) getTaskRun(taskRunID string) *TaskRun {
 	for i := range s.taskRuns {
 		if s.taskRuns[i].ID == taskRunID {
 			return s.taskRuns[i]
 		}
 	}
-
 	return nil
 }
 
+func (s *TaskStore) GetTaskRun(taskRunID string) *TaskRun {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	return s.getTaskRun(taskRunID)
+}
+
 func (s *TaskStore) GetTasks() []*Task {
 	s.mu.Lock()
 	defer s.mu.Unlock()
@@ -162,13 +180,22 @@ func (s *TaskStore) GetTaskRuns(taskID string) []*TaskRun {
 	s.mu.Lock()
 	defer s.mu.Unlock()
 
+	// Resolve taskID to task name, matching by ID first, then by name
 	var taskName string
 	for _, task := range s.tasks {
 		if task.ID == taskID {
 			taskName = task.Name
 			break
 		}
 	}
+	if taskName == "" {
+		for _, task := range s.tasks {
+			if task.Name == taskID {
+				taskName = task.Name
+				break
+			}
+		}
+	}
 
 	taskRuns := make([]*TaskRun, 0)
 	for _, taskRun := range s.taskRuns {
@@ -180,6 +207,15 @@ func (s *TaskStore) GetTaskRuns(taskID string) []*TaskRun {
 	return taskRuns
 }
 
+func (s *TaskStore) GetAllTaskRuns() []*TaskRun {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	taskRuns := make([]*TaskRun, len(s.taskRuns))
+	copy(taskRuns, s.taskRuns)
+	return taskRuns
+}
+
 func (s *TaskStore) GetTask(taskID string) *Task {
 	s.mu.Lock()
 	defer s.mu.Unlock()
diff --git a/pkg/workflows/store/store_test.go b/pkg/workflows/store/store_test.go

Original file line number	Diff line number	Diff line change
`@@ -41,6 +41,7 @@ Examples:`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`var input workflowviews.TaskListInput`
	`44`	`+ input.Local = local`
`44`	`45`	`err = command.ParseCommand(cmd, args, &input)`
`45`	`46`	`if err != nil {`
`46`	`47`	`return fmt.Errorf("failed to parse command: %w", err)`
Original file line number	Diff line number	Diff line change
`@@ -40,6 +40,7 @@ Examples:`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`var input workflowviews.TaskRunListInput`
	`43`	`+ input.Local = local`
`43`	`44`	`err = command.ParseCommand(cmd, args, &input)`
`44`	`45`	`if err != nil {`
`45`	`46`	`return fmt.Errorf("failed to parse command: %w", err)`
Original file line number	Diff line number	Diff line change
`@@ -179,8 +179,7 @@ func (f Workflow) versionRelease(ctx context.Context, input workflowviews.Vers`
`179`	`179`
`180`	`180`	`func (f Workflow) unspecifiedTask(ctx context.Context, action func(t workflows.Task) tea.Cmd) tea.Cmd {`
`181`	`181`	`if f.local {`
`182`		`- // when running locally, we don't have a workflow version id, so we just use a dummy one`
`183`		`- return f.taskList(ctx, &workflowviews.TaskListInput{WorkflowVersionID: "local"}, action)`
	`182`	`+ return f.taskList(ctx, &workflowviews.TaskListInput{}, action)`
`184`	`183`	`}`
`185`	`184`
`186`	`185`	`return f.workflowList(ctx, &workflowviews.WorkflowInput{}, func(ctx context.Context, r resource.Resource) tea.Cmd {`
Original file line number	Diff line number	Diff line change
`@@ -11,6 +11,7 @@ type TaskListInput struct {`
`11`	`11`	WorkflowVersionID string `cli:"arg:0"`
`12`	`12`	`WorkflowID string`
`13`	`13`	`LatestVersionOnly bool`
	`14`	`+ Local bool`
`14`	`15`	`}`
`15`	`16`
`16`	`17`	`type TaskRunInput struct {`
`@@ -28,6 +29,7 @@ type VersionListInput struct {`
`28`	`29`
`29`	`30`	`type TaskRunListInput struct {`
`30`	`31`	TaskID string `cli:"arg:0"`
	`32`	`+ Local bool`
`31`	`33`	`}`
`32`	`34`
`33`	`35`	`type VersionReleaseInput struct {`
`@@ -37,14 +39,17 @@ type VersionReleaseInput struct {`
`37`	`39`	`}`
`38`	`40`
`39`	`41`	`func (t TaskListInput) Validate(interactive bool) error {`
`40`		`- if !interactive && t.WorkflowVersionID == "" {`
	`42`	`+ if !interactive && t.Local && t.WorkflowVersionID != "" {`
	`43`	`+ return errors.New("workflow version id is not supported in local mode")`
	`44`	`+ }`
	`45`	`+ if !interactive && !t.Local && t.WorkflowVersionID == "" {`
`41`	`46`	`return errors.New("workflow version id must be specified when output is not interactive")`
`42`	`47`	`}`
`43`	`48`	`return nil`
`44`	`49`	`}`
`45`	`50`
`46`	`51`	`func (t TaskRunListInput) Validate(interactive bool) error {`
`47`		`- if !interactive && t.TaskID == "" {`
	`52`	`+ if !interactive && !t.Local && t.TaskID == "" {`
`48`	`53`	`return errors.New("task id must be specified when output is not interactive")`
`49`	`54`	`}`
`50`	`55`	`return nil`