fix: restore workspace deletion from settings (#1547)

* fix: restore workspace deletion from settings

* fix: validate workspace delete in service

* fix: clarify workspace delete errors

* fix: address workspace delete review feedback

* fix: guard confirmed workspace delete before cascade

* fix: simplify workspace delete cascade guard

* fix: make confirmed workspace delete atomic

* fix: preserve confirmed workspace delete side effects

* fix: snapshot confirmed workspace cascade rows

* fix: clarify confirmed workspace delete cleanup

* fix: preserve office workspace deletion cleanup

* fix: preserve workspace delete error mapping

* fix: streamline workspace delete cascade

* fix: harden workspace delete cleanup

* fix: keep workspace delete failure logs

* fix: fail workspace delete on missing session inventory

---------

Co-authored-by: root <root@kandev.ts.net>
This commit is contained in:
Carlos Florêncio
2026-06-30 08:24:43 +01:00
committed by GitHub
parent e51e0ebf3c
commit 657b92eb69
17 changed files with 1826 additions and 107 deletions
@@ -393,6 +393,9 @@ func (m *mockRepository) UpdateWorkspace(ctx context.Context, workspace *models.
return nil
}
func (m *mockRepository) DeleteWorkspace(ctx context.Context, id string) error { return nil }
func (m *mockRepository) DeleteWorkspaceCascadeWithName(ctx context.Context, id, name string) ([]*models.Task, []*models.Workflow, error) {
return nil, nil, m.DeleteWorkspace(ctx, id)
}
func (m *mockRepository) ListWorkspaces(ctx context.Context) ([]*models.Workspace, error) {
return nil, nil
}
@@ -44,6 +44,7 @@ func isNotFound(err error) bool {
return false
}
if errors.Is(err, taskrepo.ErrTaskNotFound) ||
errors.Is(err, taskrepo.ErrWorkspaceNotFound) ||
errors.Is(err, taskrepo.ErrNoPrimarySession) ||
errors.Is(err, service.ErrDocumentNotFound) ||
errors.Is(err, service.ErrTaskPlanNotFound) ||
@@ -17,11 +17,12 @@ import (
// status mapping survives downstream wrap/unwrap changes.
func TestErrorsAreClassifiable(t *testing.T) {
notFoundSentinels := map[string]error{
"taskrepo.ErrTaskNotFound": taskrepo.ErrTaskNotFound,
"taskrepo.ErrNoPrimarySession": taskrepo.ErrNoPrimarySession,
"service.ErrDocumentNotFound": service.ErrDocumentNotFound,
"service.ErrTaskPlanNotFound": service.ErrTaskPlanNotFound,
"service.ErrRevisionNotFound": service.ErrRevisionNotFound,
"taskrepo.ErrTaskNotFound": taskrepo.ErrTaskNotFound,
"taskrepo.ErrWorkspaceNotFound": taskrepo.ErrWorkspaceNotFound,
"taskrepo.ErrNoPrimarySession": taskrepo.ErrNoPrimarySession,
"service.ErrDocumentNotFound": service.ErrDocumentNotFound,
"service.ErrTaskPlanNotFound": service.ErrTaskPlanNotFound,
"service.ErrRevisionNotFound": service.ErrRevisionNotFound,
}
for name, sentinel := range notFoundSentinels {
t.Run("isNotFound recognizes "+name, func(t *testing.T) {
@@ -44,6 +44,12 @@ func (m *mockRepository) UpdateWorkspace(ctx context.Context, workspace *models.
func (m *mockRepository) DeleteWorkspace(ctx context.Context, id string) error {
return nil
}
func (m *mockRepository) DeleteWorkspaceCascade(ctx context.Context, id string) ([]*models.Task, []*models.Workflow, error) {
return nil, nil, m.DeleteWorkspace(ctx, id)
}
func (m *mockRepository) DeleteWorkspaceCascadeWithName(ctx context.Context, id, name string) ([]*models.Task, []*models.Workflow, error) {
return nil, nil, m.DeleteWorkspace(ctx, id)
}
func (m *mockRepository) ListWorkspaces(ctx context.Context) ([]*models.Workspace, error) {
return nil, nil
}
@@ -2,6 +2,7 @@ package handlers
import (
"context"
"errors"
"net/http"
"github.com/gin-gonic/gin"
@@ -147,14 +148,42 @@ func (h *WorkspaceHandlers) httpUpdateWorkspace(c *gin.Context) {
c.JSON(http.StatusOK, dto.FromWorkspace(workspace))
}
type httpDeleteWorkspaceRequest struct {
ConfirmName string `json:"confirm_name"`
}
func (h *WorkspaceHandlers) httpDeleteWorkspace(c *gin.Context) {
if err := h.service.DeleteWorkspace(c.Request.Context(), c.Param("id")); err != nil {
handleNotFound(c, h.logger, err, "workspace not deleted")
var body httpDeleteWorkspaceRequest
if err := c.ShouldBindJSON(&body); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid payload"})
return
}
if body.ConfirmName == "" {
c.JSON(http.StatusBadRequest, gin.H{"error": "confirm_name is required"})
return
}
if err := h.service.DeleteWorkspaceWithConfirmName(
c.Request.Context(),
c.Param("id"),
body.ConfirmName,
); err != nil {
h.handleHTTPDeleteWorkspaceError(c, err)
return
}
c.JSON(http.StatusOK, dto.SuccessResponse{Success: true})
}
func (h *WorkspaceHandlers) handleHTTPDeleteWorkspaceError(c *gin.Context, err error) {
switch {
case errors.Is(err, service.ErrWorkspaceConfirmNameMismatch):
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
case isNotFound(err):
c.JSON(http.StatusNotFound, gin.H{"error": "workspace not found"})
default:
c.JSON(http.StatusInternalServerError, gin.H{"error": "workspace not deleted"})
}
}
// WS handlers
func (h *WorkspaceHandlers) wsListWorkspaces(ctx context.Context, msg *ws.Message) (*ws.Message, error) {
@@ -254,12 +283,35 @@ func (h *WorkspaceHandlers) wsUpdateWorkspace(ctx context.Context, msg *ws.Messa
return ws.NewResponse(msg.ID, msg.Action, dto.FromWorkspace(workspace))
}
func (h *WorkspaceHandlers) wsDeleteWorkspace(ctx context.Context, msg *ws.Message) (*ws.Message, error) {
return wsHandleIDRequest(ctx, msg, h.logger, "failed to delete workspace",
func(ctx context.Context, id string) (any, error) {
if err := h.service.DeleteWorkspace(ctx, id); err != nil {
return nil, err
}
return dto.SuccessResponse{Success: true}, nil
})
type wsDeleteWorkspaceRequest struct {
ID string `json:"id"`
ConfirmName string `json:"confirm_name"`
}
func (h *WorkspaceHandlers) wsDeleteWorkspace(ctx context.Context, msg *ws.Message) (*ws.Message, error) {
var req wsDeleteWorkspaceRequest
if err := msg.ParsePayload(&req); err != nil {
return ws.NewError(msg.ID, msg.Action, ws.ErrorCodeBadRequest, "Invalid payload: "+err.Error(), nil)
}
if req.ID == "" {
return ws.NewError(msg.ID, msg.Action, ws.ErrorCodeValidation, "id is required", nil)
}
if req.ConfirmName == "" {
return ws.NewError(msg.ID, msg.Action, ws.ErrorCodeValidation, "confirm_name is required", nil)
}
if err := h.service.DeleteWorkspaceWithConfirmName(ctx, req.ID, req.ConfirmName); err != nil {
return h.wsDeleteWorkspaceError(msg, err)
}
return ws.NewResponse(msg.ID, msg.Action, dto.SuccessResponse{Success: true})
}
func (h *WorkspaceHandlers) wsDeleteWorkspaceError(msg *ws.Message, err error) (*ws.Message, error) {
switch {
case errors.Is(err, service.ErrWorkspaceConfirmNameMismatch):
return ws.NewError(msg.ID, msg.Action, ws.ErrorCodeValidation, err.Error(), nil)
case isNotFound(err):
return ws.NewError(msg.ID, msg.Action, ws.ErrorCodeNotFound, "Workspace not found", nil)
default:
return ws.NewError(msg.ID, msg.Action, ws.ErrorCodeInternalError, "failed to delete workspace", nil)
}
}
@@ -0,0 +1,365 @@
package handlers
import (
"context"
"errors"
"net/http"
"net/http/httptest"
"strings"
"testing"
"github.com/gin-gonic/gin"
"github.com/stretchr/testify/require"
"github.com/kandev/kandev/internal/common/logger"
"github.com/kandev/kandev/internal/task/models"
"github.com/kandev/kandev/internal/task/service"
ws "github.com/kandev/kandev/pkg/websocket"
)
type workspaceDeleteRepo struct {
mockRepository
deleteCalled bool
cascadeCalled bool
cascadeID string
cascadeName string
cascadeTasks []*models.Task
cascadeWorkflows []*models.Workflow
cascadeErr error
getCalls int
getErr error
}
func (r *workspaceDeleteRepo) GetWorkspace(_ context.Context, id string) (*models.Workspace, error) {
r.getCalls++
if r.getErr != nil {
return nil, r.getErr
}
return &models.Workspace{ID: id, Name: "Delete Me"}, nil
}
func (r *workspaceDeleteRepo) DeleteWorkspace(_ context.Context, _ string) error {
r.deleteCalled = true
return nil
}
func (r *workspaceDeleteRepo) DeleteWorkspaceCascade(_ context.Context, id string) ([]*models.Task, []*models.Workflow, error) {
r.cascadeCalled = true
r.cascadeID = id
r.cascadeName = ""
if r.cascadeErr != nil {
return nil, nil, r.cascadeErr
}
return r.cascadeTasks, r.cascadeWorkflows, nil
}
func (r *workspaceDeleteRepo) DeleteWorkspaceCascadeWithName(_ context.Context, id, name string) ([]*models.Task, []*models.Workflow, error) {
r.cascadeCalled = true
r.cascadeID = id
r.cascadeName = name
if r.cascadeErr != nil {
return nil, nil, r.cascadeErr
}
return r.cascadeTasks, r.cascadeWorkflows, nil
}
func TestHTTPDeleteWorkspaceRequiresMatchingConfirmName(t *testing.T) {
gin.SetMode(gin.TestMode)
repo := &workspaceDeleteRepo{}
log, _ := logger.NewLogger(logger.LoggingConfig{Level: "error", Format: "json", OutputPath: "stdout"})
svc := service.NewService(service.Repos{
Workspaces: repo,
Tasks: repo,
TaskRepos: repo,
Workflows: repo,
Messages: repo,
Turns: repo,
Sessions: repo,
GitSnapshots: repo,
RepoEntities: repo,
Executors: repo,
Environments: repo,
TaskEnvironments: repo,
Reviews: repo,
}, nil, log, service.RepositoryDiscoveryConfig{})
h := NewWorkspaceHandlers(svc, log)
rec := httptest.NewRecorder()
c, _ := gin.CreateTestContext(rec)
c.Request = httptest.NewRequest(
http.MethodDelete,
"/api/v1/workspaces/ws-1",
strings.NewReader(`{"confirm_name":"Wrong"}`),
)
c.Request.Header.Set("Content-Type", "application/json")
c.Params = gin.Params{{Key: "id", Value: "ws-1"}}
h.httpDeleteWorkspace(c)
require.Equal(t, http.StatusBadRequest, rec.Code)
require.False(t, repo.deleteCalled, "handler must not delete when confirm_name does not match")
require.False(t, repo.cascadeCalled, "handler must not cascade when confirm_name does not match")
require.Equal(t, 1, repo.getCalls, "handler should leave confirmation lookup to the service")
}
func TestHTTPDeleteWorkspaceRejectsInvalidPayload(t *testing.T) {
gin.SetMode(gin.TestMode)
repo := &workspaceDeleteRepo{}
log, _ := logger.NewLogger(logger.LoggingConfig{Level: "error", Format: "json", OutputPath: "stdout"})
svc := service.NewService(service.Repos{
Workspaces: repo,
Tasks: repo,
TaskRepos: repo,
Workflows: repo,
Messages: repo,
Turns: repo,
Sessions: repo,
GitSnapshots: repo,
RepoEntities: repo,
Executors: repo,
Environments: repo,
TaskEnvironments: repo,
Reviews: repo,
}, nil, log, service.RepositoryDiscoveryConfig{})
h := NewWorkspaceHandlers(svc, log)
rec := httptest.NewRecorder()
c, _ := gin.CreateTestContext(rec)
c.Request = httptest.NewRequest(http.MethodDelete, "/api/v1/workspaces/ws-1", strings.NewReader(`{`))
c.Request.Header.Set("Content-Type", "application/json")
c.Params = gin.Params{{Key: "id", Value: "ws-1"}}
h.httpDeleteWorkspace(c)
require.Equal(t, http.StatusBadRequest, rec.Code)
require.JSONEq(t, `{"error":"invalid payload"}`, rec.Body.String())
require.Equal(t, 0, repo.getCalls, "invalid payload must not look up the workspace")
require.False(t, repo.deleteCalled, "invalid payload must not delete")
require.False(t, repo.cascadeCalled, "invalid payload must not cascade")
}
func TestHTTPDeleteWorkspaceReturnsNotFoundWhenWorkspaceMissing(t *testing.T) {
gin.SetMode(gin.TestMode)
repo := &workspaceDeleteRepo{getErr: errors.New("workspace not found")}
log, _ := logger.NewLogger(logger.LoggingConfig{Level: "error", Format: "json", OutputPath: "stdout"})
svc := service.NewService(service.Repos{
Workspaces: repo,
Tasks: repo,
TaskRepos: repo,
Workflows: repo,
Messages: repo,
Turns: repo,
Sessions: repo,
GitSnapshots: repo,
RepoEntities: repo,
Executors: repo,
Environments: repo,
TaskEnvironments: repo,
Reviews: repo,
}, nil, log, service.RepositoryDiscoveryConfig{})
h := NewWorkspaceHandlers(svc, log)
rec := httptest.NewRecorder()
c, _ := gin.CreateTestContext(rec)
c.Request = httptest.NewRequest(
http.MethodDelete,
"/api/v1/workspaces/ws-missing",
strings.NewReader(`{"confirm_name":"Delete Me"}`),
)
c.Request.Header.Set("Content-Type", "application/json")
c.Params = gin.Params{{Key: "id", Value: "ws-missing"}}
h.httpDeleteWorkspace(c)
require.Equal(t, http.StatusNotFound, rec.Code)
require.JSONEq(t, `{"error":"workspace not found"}`, rec.Body.String())
require.Equal(t, 1, repo.getCalls, "handler should let service resolve the workspace")
require.False(t, repo.deleteCalled, "missing workspace must not delete")
require.False(t, repo.cascadeCalled, "missing workspace must not cascade")
}
func TestHTTPDeleteWorkspaceDeletesWhenConfirmNameMatches(t *testing.T) {
gin.SetMode(gin.TestMode)
repo := &workspaceDeleteRepo{}
log, _ := logger.NewLogger(logger.LoggingConfig{Level: "error", Format: "json", OutputPath: "stdout"})
svc := service.NewService(service.Repos{
Workspaces: repo,
Tasks: repo,
TaskRepos: repo,
Workflows: repo,
Messages: repo,
Turns: repo,
Sessions: repo,
GitSnapshots: repo,
RepoEntities: repo,
Executors: repo,
Environments: repo,
TaskEnvironments: repo,
Reviews: repo,
}, nil, log, service.RepositoryDiscoveryConfig{})
h := NewWorkspaceHandlers(svc, log)
rec := httptest.NewRecorder()
c, _ := gin.CreateTestContext(rec)
c.Request = httptest.NewRequest(
http.MethodDelete,
"/api/v1/workspaces/ws-1",
strings.NewReader(`{"confirm_name":"Delete Me"}`),
)
c.Request.Header.Set("Content-Type", "application/json")
c.Params = gin.Params{{Key: "id", Value: "ws-1"}}
h.httpDeleteWorkspace(c)
require.Equal(t, http.StatusOK, rec.Code)
require.False(t, repo.deleteCalled, "handler must use the confirmed cascade path")
require.True(t, repo.cascadeCalled, "handler must cascade when confirm_name matches")
require.Equal(t, "ws-1", repo.cascadeID)
require.Equal(t, "Delete Me", repo.cascadeName)
require.Equal(t, 1, repo.getCalls, "confirmed delete should fetch the workspace once")
}
func TestHTTPDeleteWorkspaceReturnsDeleteFailureWhenCascadeFails(t *testing.T) {
gin.SetMode(gin.TestMode)
repo := &workspaceDeleteRepo{cascadeErr: errors.New("cleanup failed")}
log, _ := logger.NewLogger(logger.LoggingConfig{Level: "error", Format: "json", OutputPath: "stdout"})
svc := service.NewService(service.Repos{
Workspaces: repo,
Tasks: repo,
TaskRepos: repo,
Workflows: repo,
Messages: repo,
Turns: repo,
Sessions: repo,
GitSnapshots: repo,
RepoEntities: repo,
Executors: repo,
Environments: repo,
TaskEnvironments: repo,
Reviews: repo,
}, nil, log, service.RepositoryDiscoveryConfig{})
h := NewWorkspaceHandlers(svc, log)
rec := httptest.NewRecorder()
c, _ := gin.CreateTestContext(rec)
c.Request = httptest.NewRequest(
http.MethodDelete,
"/api/v1/workspaces/ws-1",
strings.NewReader(`{"confirm_name":"Delete Me"}`),
)
c.Request.Header.Set("Content-Type", "application/json")
c.Params = gin.Params{{Key: "id", Value: "ws-1"}}
h.httpDeleteWorkspace(c)
require.Equal(t, http.StatusInternalServerError, rec.Code)
require.JSONEq(t, `{"error":"workspace not deleted"}`, rec.Body.String())
require.True(t, repo.cascadeCalled, "handler should surface cascade failures separately")
require.Equal(t, 1, repo.getCalls, "confirmed delete should fetch the workspace once")
}
func TestWSDeleteWorkspaceRequiresConfirmName(t *testing.T) {
repo := &workspaceDeleteRepo{}
log, _ := logger.NewLogger(logger.LoggingConfig{Level: "error", Format: "json", OutputPath: "stdout"})
svc := service.NewService(service.Repos{
Workspaces: repo,
Tasks: repo,
TaskRepos: repo,
Workflows: repo,
Messages: repo,
Turns: repo,
Sessions: repo,
GitSnapshots: repo,
RepoEntities: repo,
Executors: repo,
Environments: repo,
TaskEnvironments: repo,
Reviews: repo,
}, nil, log, service.RepositoryDiscoveryConfig{})
h := NewWorkspaceHandlers(svc, log)
req, err := ws.NewRequest("req-1", ws.ActionWorkspaceDelete, map[string]string{"id": "ws-1"})
require.NoError(t, err)
resp, err := h.wsDeleteWorkspace(context.Background(), req)
require.NoError(t, err)
require.Equal(t, ws.MessageTypeError, resp.Type)
require.Contains(t, string(resp.Payload), "confirm_name is required")
require.Equal(t, 0, repo.getCalls, "missing confirm_name must not look up the workspace")
require.False(t, repo.deleteCalled, "missing confirm_name must not delete")
require.False(t, repo.cascadeCalled, "missing confirm_name must not cascade")
}
func TestWSDeleteWorkspaceReturnsNotFoundWhenWorkspaceMissing(t *testing.T) {
repo := &workspaceDeleteRepo{getErr: errors.New("workspace not found")}
log, _ := logger.NewLogger(logger.LoggingConfig{Level: "error", Format: "json", OutputPath: "stdout"})
svc := service.NewService(service.Repos{
Workspaces: repo,
Tasks: repo,
TaskRepos: repo,
Workflows: repo,
Messages: repo,
Turns: repo,
Sessions: repo,
GitSnapshots: repo,
RepoEntities: repo,
Executors: repo,
Environments: repo,
TaskEnvironments: repo,
Reviews: repo,
}, nil, log, service.RepositoryDiscoveryConfig{})
h := NewWorkspaceHandlers(svc, log)
req, err := ws.NewRequest("req-1", ws.ActionWorkspaceDelete, map[string]string{
"id": "ws-missing",
"confirm_name": "Delete Me",
})
require.NoError(t, err)
resp, err := h.wsDeleteWorkspace(context.Background(), req)
require.NoError(t, err)
require.Equal(t, ws.MessageTypeError, resp.Type)
require.Contains(t, string(resp.Payload), string(ws.ErrorCodeNotFound))
require.Contains(t, string(resp.Payload), "Workspace not found")
require.Equal(t, 1, repo.getCalls, "handler should let service resolve the workspace")
require.False(t, repo.cascadeCalled, "missing workspace must not cascade")
}
func TestWSDeleteWorkspaceDeletesWhenConfirmNameMatches(t *testing.T) {
repo := &workspaceDeleteRepo{}
log, _ := logger.NewLogger(logger.LoggingConfig{Level: "error", Format: "json", OutputPath: "stdout"})
svc := service.NewService(service.Repos{
Workspaces: repo,
Tasks: repo,
TaskRepos: repo,
Workflows: repo,
Messages: repo,
Turns: repo,
Sessions: repo,
GitSnapshots: repo,
RepoEntities: repo,
Executors: repo,
Environments: repo,
TaskEnvironments: repo,
Reviews: repo,
}, nil, log, service.RepositoryDiscoveryConfig{})
h := NewWorkspaceHandlers(svc, log)
req, err := ws.NewRequest("req-1", ws.ActionWorkspaceDelete, map[string]string{
"id": "ws-1",
"confirm_name": "Delete Me",
})
require.NoError(t, err)
resp, err := h.wsDeleteWorkspace(context.Background(), req)
require.NoError(t, err)
require.Equal(t, ws.MessageTypeResponse, resp.Type)
require.False(t, repo.deleteCalled, "handler must use the confirmed cascade path")
require.True(t, repo.cascadeCalled, "handler must cascade when confirm_name matches")
require.Equal(t, "ws-1", repo.cascadeID)
require.Equal(t, "Delete Me", repo.cascadeName)
require.Equal(t, 1, repo.getCalls, "confirmed delete should fetch the workspace once")
}
@@ -6,15 +6,21 @@ import (
agentdto "github.com/kandev/kandev/internal/agent/dto"
"github.com/kandev/kandev/internal/task/models"
"github.com/kandev/kandev/internal/task/repository/repoerrors"
v1 "github.com/kandev/kandev/pkg/api/v1"
)
var ErrWorkspaceNameMismatch = repoerrors.ErrWorkspaceNameMismatch
var ErrWorkspaceNotFound = repoerrors.ErrWorkspaceNotFound
// WorkspaceRepository handles workspace CRUD.
type WorkspaceRepository interface {
CreateWorkspace(ctx context.Context, workspace *models.Workspace) error
GetWorkspace(ctx context.Context, id string) (*models.Workspace, error)
UpdateWorkspace(ctx context.Context, workspace *models.Workspace) error
DeleteWorkspace(ctx context.Context, id string) error
DeleteWorkspaceCascade(ctx context.Context, id string) ([]*models.Task, []*models.Workflow, error)
DeleteWorkspaceCascadeWithName(ctx context.Context, id, name string) ([]*models.Task, []*models.Workflow, error)
ListWorkspaces(ctx context.Context) ([]*models.Workspace, error)
}
@@ -0,0 +1,10 @@
package repoerrors
import "errors"
// ErrWorkspaceNameMismatch reports that a confirmed workspace delete did not
// match the workspace row's current name.
var ErrWorkspaceNameMismatch = errors.New("workspace name mismatch")
// ErrWorkspaceNotFound reports that no workspace row matched the supplied id.
var ErrWorkspaceNotFound = errors.New("workspace not found")
@@ -1,6 +1,10 @@
package sqlite
import "errors"
import (
"errors"
"github.com/kandev/kandev/internal/task/repository/repoerrors"
)
// ErrTaskNotFound is returned by Repository methods (GetTask, UpdateTask,
// DeleteTask, UpdateTaskState, …) when no row matches the supplied id.
@@ -8,6 +12,10 @@ import "errors"
// formatted message, which includes the task id and is therefore brittle.
var ErrTaskNotFound = errors.New("task not found")
// ErrWorkspaceNotFound is returned by Repository workspace methods when no row
// matches the supplied id.
var ErrWorkspaceNotFound = repoerrors.ErrWorkspaceNotFound
// ErrNoPrimarySession is returned by GetPrimarySessionByTaskID when the task
// has no primary session row. Callers should use errors.Is to distinguish this
// "not found" case from genuine backend/DB errors.
@@ -69,23 +69,33 @@ func normalizeWorkflowStyle(style string) string {
return models.WorkflowStyleKanban
}
// GetWorkflow retrieves a workflow by ID
func (r *Repository) GetWorkflow(ctx context.Context, id string) (*models.Workflow, error) {
const workflowSelectColumns = `
id, workspace_id, name, description, agent_profile_id,
workflow_template_id, sort_order, hidden, style, created_at, updated_at
`
type workflowScanner interface {
Scan(dest ...interface{}) error
}
func scanWorkflowRow(scanner workflowScanner) (*models.Workflow, error) {
workflow := &models.Workflow{}
var workflowTemplateID, agentProfileID, style sql.NullString
err := r.ro.QueryRowContext(ctx, r.ro.Rebind(`
SELECT id, workspace_id, name, description, agent_profile_id, workflow_template_id, sort_order, hidden, style, created_at, updated_at
FROM workflows WHERE id = ?
`), id).Scan(&workflow.ID, &workflow.WorkspaceID, &workflow.Name, &workflow.Description, &agentProfileID, &workflowTemplateID, &workflow.SortOrder, &workflow.Hidden, &style, &workflow.CreatedAt, &workflow.UpdatedAt)
if err == sql.ErrNoRows {
return nil, fmt.Errorf("workflow not found: %s", id)
}
if err != nil {
if err := scanner.Scan(
&workflow.ID,
&workflow.WorkspaceID,
&workflow.Name,
&workflow.Description,
&agentProfileID,
&workflowTemplateID,
&workflow.SortOrder,
&workflow.Hidden,
&style,
&workflow.CreatedAt,
&workflow.UpdatedAt,
); err != nil {
return nil, err
}
if agentProfileID.Valid {
workflow.AgentProfileID = agentProfileID.String
}
@@ -100,6 +110,33 @@ func (r *Repository) GetWorkflow(ctx context.Context, id string) (*models.Workfl
return workflow, nil
}
func scanWorkflowRows(rows *sql.Rows) ([]*models.Workflow, error) {
var result []*models.Workflow
for rows.Next() {
workflow, err := scanWorkflowRow(rows)
if err != nil {
return nil, err
}
result = append(result, workflow)
}
return result, rows.Err()
}
// GetWorkflow retrieves a workflow by ID
func (r *Repository) GetWorkflow(ctx context.Context, id string) (*models.Workflow, error) {
workflow, err := scanWorkflowRow(r.ro.QueryRowContext(ctx, r.ro.Rebind(fmt.Sprintf(`
SELECT %s
FROM workflows WHERE id = ?
`, workflowSelectColumns)), id))
if err == sql.ErrNoRows {
return nil, fmt.Errorf("workflow not found: %s", id)
}
if err != nil {
return nil, err
}
return workflow, nil
}
// UpdateWorkflow updates an existing workflow
func (r *Repository) UpdateWorkflow(ctx context.Context, workflow *models.Workflow) error {
workflow.UpdatedAt = time.Now().UTC()
@@ -159,9 +196,10 @@ func (r *Repository) DeleteWorkflow(ctx context.Context, id string) error {
// ListWorkflows returns workflows for the given workspace, excluding hidden by default.
// Pass includeHidden=true to also return system-only workflows like Improve Kandev.
func (r *Repository) ListWorkflows(ctx context.Context, workspaceID string, includeHidden bool) ([]*models.Workflow, error) {
query := `
SELECT id, workspace_id, name, description, agent_profile_id, workflow_template_id, sort_order, hidden, style, created_at, updated_at FROM workflows
`
query := fmt.Sprintf(`
SELECT %s
FROM workflows
`, workflowSelectColumns)
var args []interface{}
var conditions []string
if workspaceID != "" {
@@ -186,28 +224,7 @@ func (r *Repository) ListWorkflows(ctx context.Context, workspaceID string, incl
}
defer func() { _ = rows.Close() }()
var result []*models.Workflow
for rows.Next() {
workflow := &models.Workflow{}
var agentProfileID, workflowTemplateID, style sql.NullString
err := rows.Scan(&workflow.ID, &workflow.WorkspaceID, &workflow.Name, &workflow.Description, &agentProfileID, &workflowTemplateID, &workflow.SortOrder, &workflow.Hidden, &style, &workflow.CreatedAt, &workflow.UpdatedAt)
if err != nil {
return nil, err
}
if agentProfileID.Valid {
workflow.AgentProfileID = agentProfileID.String
}
if workflowTemplateID.Valid {
workflow.WorkflowTemplateID = &workflowTemplateID.String
}
if style.Valid && style.String != "" {
workflow.Style = style.String
} else {
workflow.Style = models.WorkflowStyleKanban
}
result = append(result, workflow)
}
return result, rows.Err()
return scanWorkflowRows(rows)
}
// ReorderWorkflows updates sort_order for workflows within a workspace using a transaction.
@@ -3,12 +3,15 @@ package sqlite
import (
"context"
"database/sql"
"errors"
"fmt"
"time"
"github.com/google/uuid"
"github.com/jmoiron/sqlx"
"github.com/kandev/kandev/internal/task/models"
"github.com/kandev/kandev/internal/task/repository/repoerrors"
)
// CreateWorkspace creates a new workspace
@@ -85,7 +88,7 @@ func (r *Repository) GetWorkspace(ctx context.Context, id string) (*models.Works
}
if err == sql.ErrNoRows {
return nil, fmt.Errorf("workspace not found: %s", id)
return nil, workspaceNotFoundError(id)
}
return workspace, err
}
@@ -111,7 +114,7 @@ func (r *Repository) UpdateWorkspace(ctx context.Context, workspace *models.Work
rows, _ := result.RowsAffected()
if rows == 0 {
return fmt.Errorf("workspace not found: %s", workspace.ID)
return workspaceNotFoundError(workspace.ID)
}
return nil
}
@@ -125,11 +128,182 @@ func (r *Repository) DeleteWorkspace(ctx context.Context, id string) error {
rows, _ := result.RowsAffected()
if rows == 0 {
return fmt.Errorf("workspace not found: %s", id)
return workspaceNotFoundError(id)
}
return nil
}
// DeleteWorkspaceCascade deletes a workspace and its task/workflow rows in one transaction.
func (r *Repository) DeleteWorkspaceCascade(
ctx context.Context,
id string,
) ([]*models.Task, []*models.Workflow, error) {
return r.deleteWorkspaceCascade(ctx, id, nil)
}
// DeleteWorkspaceCascadeWithName deletes a workspace and its task/workflow rows
// in one transaction, only if the current workspace name matches name.
func (r *Repository) DeleteWorkspaceCascadeWithName(
ctx context.Context,
id, name string,
) ([]*models.Task, []*models.Workflow, error) {
return r.deleteWorkspaceCascade(ctx, id, &name)
}
func (r *Repository) deleteWorkspaceCascade(
ctx context.Context,
id string,
expectedName *string,
) ([]*models.Task, []*models.Workflow, error) {
tx, err := r.db.BeginTxx(ctx, nil)
if err != nil {
return nil, nil, err
}
defer func() { _ = tx.Rollback() }()
if expectedName != nil {
if err := r.confirmWorkspaceNameForCascadeDelete(ctx, tx, id, *expectedName); err != nil {
return nil, nil, err
}
}
tasks, err := r.listWorkspaceCascadeDeleteTasks(ctx, tx, id)
if err != nil {
return nil, nil, err
}
workflows, err := r.listWorkspaceCascadeDeleteWorkflows(ctx, tx, id)
if err != nil {
return nil, nil, err
}
rows, err := r.deleteWorkspaceCascadeRow(ctx, tx, id, expectedName)
if err != nil {
return nil, nil, err
}
if rows == 0 {
if expectedName != nil {
return nil, nil, r.confirmedWorkspaceDeleteMismatch(ctx, tx, id)
}
return nil, nil, workspaceNotFoundError(id)
}
if _, err := tx.ExecContext(ctx, r.db.Rebind(`
DELETE FROM tasks
WHERE workspace_id = ?
`), id); err != nil {
return nil, nil, err
}
if _, err := tx.ExecContext(ctx, r.db.Rebind(`
DELETE FROM workflows
WHERE workspace_id = ?
`), id); err != nil {
return nil, nil, err
}
if err := tx.Commit(); err != nil {
return nil, nil, err
}
return tasks, workflows, nil
}
func (r *Repository) deleteWorkspaceCascadeRow(
ctx context.Context,
tx *sqlx.Tx,
id string,
expectedName *string,
) (int64, error) {
var result sql.Result
var err error
if expectedName == nil {
result, err = tx.ExecContext(ctx, r.db.Rebind(`
DELETE FROM workspaces
WHERE id = ?
`), id)
} else {
// Keep the name predicate on the delete itself so a rename racing after
// the confirmation cannot delete the newly renamed workspace.
result, err = tx.ExecContext(ctx, r.db.Rebind(`
DELETE FROM workspaces
WHERE id = ? AND name = ?
`), id, *expectedName)
}
if err != nil {
return 0, err
}
rows, _ := result.RowsAffected()
return rows, nil
}
func (r *Repository) confirmWorkspaceNameForCascadeDelete(ctx context.Context, tx *sqlx.Tx, id, name string) error {
currentName, err := r.workspaceNameForCascadeDelete(ctx, tx, id)
if err != nil {
return err
}
if currentName != name {
return repoerrors.ErrWorkspaceNameMismatch
}
return nil
}
func (r *Repository) workspaceNameForCascadeDelete(ctx context.Context, tx *sqlx.Tx, id string) (string, error) {
var currentName string
err := tx.QueryRowContext(ctx, r.db.Rebind(`
SELECT name
FROM workspaces
WHERE id = ?
`), id).Scan(&currentName)
if errors.Is(err, sql.ErrNoRows) {
return "", workspaceNotFoundError(id)
}
return currentName, err
}
func workspaceNotFoundError(id string) error {
return fmt.Errorf("%w: %s", repoerrors.ErrWorkspaceNotFound, id)
}
func (r *Repository) confirmedWorkspaceDeleteMismatch(ctx context.Context, tx *sqlx.Tx, id string) error {
if _, err := r.workspaceNameForCascadeDelete(ctx, tx, id); err != nil {
return err
}
return repoerrors.ErrWorkspaceNameMismatch
}
func (r *Repository) listWorkspaceCascadeDeleteTasks(
ctx context.Context,
tx *sqlx.Tx,
workspaceID string,
) ([]*models.Task, error) {
rows, err := tx.QueryContext(ctx, r.db.Rebind(fmt.Sprintf(`
SELECT %s
FROM tasks
WHERE workspace_id = ?
ORDER BY created_at ASC, id ASC
`, taskSelectColumns("tasks"))), workspaceID)
if err != nil {
return nil, err
}
defer func() { _ = rows.Close() }()
return r.scanTasks(rows)
}
func (r *Repository) listWorkspaceCascadeDeleteWorkflows(
ctx context.Context,
tx *sqlx.Tx,
workspaceID string,
) ([]*models.Workflow, error) {
rows, err := tx.QueryContext(ctx, r.db.Rebind(`
SELECT `+workflowSelectColumns+`
FROM workflows
WHERE workspace_id = ?
ORDER BY sort_order ASC, created_at ASC
`), workspaceID)
if err != nil {
return nil, err
}
defer func() { _ = rows.Close() }()
return scanWorkflowRows(rows)
}
// ListWorkspaces returns all workspaces
func (r *Repository) ListWorkspaces(ctx context.Context) ([]*models.Workspace, error) {
rows, err := r.ro.QueryContext(ctx, `
@@ -0,0 +1,278 @@
package sqlite
import (
"context"
"errors"
"testing"
"github.com/kandev/kandev/internal/task/models"
"github.com/kandev/kandev/internal/task/repository/repoerrors"
)
func TestDeleteWorkspaceCascadeWithNameDeletesWorkspaceChildren(t *testing.T) {
ctx := context.Background()
repo := newRepoForHealTests(t)
seedWorkspaceCascadeRows(t, repo, "ws-delete")
tasks, workflows, err := repo.DeleteWorkspaceCascadeWithName(ctx, "ws-delete", "Delete Me")
if err != nil {
t.Fatalf("DeleteWorkspaceCascadeWithName: %v", err)
}
if len(tasks) != 1 || tasks[0].ID != "task-delete" {
t.Fatalf("deleted tasks = %#v, want task-delete", tasks)
}
if len(workflows) != 1 || workflows[0].ID != "wf-delete" {
t.Fatalf("deleted workflows = %#v, want wf-delete", workflows)
}
if _, err := repo.GetWorkspace(ctx, "ws-delete"); err == nil {
t.Fatalf("workspace should be deleted")
}
if _, err := repo.GetTask(ctx, "task-delete"); err == nil {
t.Fatalf("workspace task should be deleted")
}
workflows, err = repo.ListWorkflows(ctx, "ws-delete", true)
if err != nil {
t.Fatalf("ListWorkflows: %v", err)
}
if len(workflows) != 0 {
t.Fatalf("workspace workflows should be deleted, got %d", len(workflows))
}
assertNoWorkspaceCascadeDependents(t, repo)
}
func TestDeleteWorkspaceCascadeDeletesWorkspaceChildren(t *testing.T) {
ctx := context.Background()
repo := newRepoForHealTests(t)
seedWorkspaceCascadeRows(t, repo, "ws-delete")
tasks, workflows, err := repo.DeleteWorkspaceCascade(ctx, "ws-delete")
if err != nil {
t.Fatalf("DeleteWorkspaceCascade: %v", err)
}
if len(tasks) != 1 || tasks[0].ID != "task-delete" {
t.Fatalf("deleted tasks = %#v, want task-delete", tasks)
}
if len(workflows) != 1 || workflows[0].ID != "wf-delete" {
t.Fatalf("deleted workflows = %#v, want wf-delete", workflows)
}
if _, err := repo.GetWorkspace(ctx, "ws-delete"); err == nil {
t.Fatalf("workspace should be deleted")
}
if _, err := repo.GetTask(ctx, "task-delete"); err == nil {
t.Fatalf("workspace task should be deleted")
}
workflows, err = repo.ListWorkflows(ctx, "ws-delete", true)
if err != nil {
t.Fatalf("ListWorkflows: %v", err)
}
if len(workflows) != 0 {
t.Fatalf("workspace workflows should be deleted, got %d", len(workflows))
}
assertNoWorkspaceCascadeDependents(t, repo)
}
func TestDeleteWorkspaceCascadeWithNameRejectsMismatchedName(t *testing.T) {
ctx := context.Background()
repo := newRepoForHealTests(t)
seedWorkspaceCascadeRows(t, repo, "ws-delete")
_, _, err := repo.DeleteWorkspaceCascadeWithName(ctx, "ws-delete", "Wrong")
if !errors.Is(err, repoerrors.ErrWorkspaceNameMismatch) {
t.Fatalf("expected ErrWorkspaceNameMismatch, got %v", err)
}
if _, err := repo.GetWorkspace(ctx, "ws-delete"); err != nil {
t.Fatalf("workspace should remain: %v", err)
}
if _, err := repo.GetTask(ctx, "task-delete"); err != nil {
t.Fatalf("workspace task should remain: %v", err)
}
if _, err := repo.GetWorkflow(ctx, "wf-delete"); err != nil {
t.Fatalf("workspace workflow should remain: %v", err)
}
}
func TestDeleteWorkspaceCascadeWithNameRollsBackWhenChildDeleteFails(t *testing.T) {
ctx := context.Background()
repo := newRepoForHealTests(t)
seedWorkspaceCascadeRows(t, repo, "ws-delete")
if _, err := repo.db.Exec(`
CREATE TRIGGER fail_workspace_task_delete
BEFORE DELETE ON tasks
WHEN OLD.workspace_id = 'ws-delete'
BEGIN
SELECT RAISE(ABORT, 'task delete blocked');
END
`); err != nil {
t.Fatalf("create trigger: %v", err)
}
if _, _, err := repo.DeleteWorkspaceCascadeWithName(ctx, "ws-delete", "Delete Me"); err == nil {
t.Fatalf("expected child delete failure")
}
if _, err := repo.GetWorkspace(ctx, "ws-delete"); err != nil {
t.Fatalf("workspace should roll back: %v", err)
}
if _, err := repo.GetTask(ctx, "task-delete"); err != nil {
t.Fatalf("workspace task should roll back: %v", err)
}
if _, err := repo.GetWorkflow(ctx, "wf-delete"); err != nil {
t.Fatalf("workspace workflow should roll back: %v", err)
}
}
func seedWorkspaceCascadeRows(t *testing.T, repo *Repository, workspaceID string) {
t.Helper()
ctx := context.Background()
if err := repo.CreateWorkspace(ctx, &models.Workspace{ID: workspaceID, Name: "Delete Me"}); err != nil {
t.Fatalf("CreateWorkspace: %v", err)
}
if err := repo.CreateWorkflow(ctx, &models.Workflow{
ID: "wf-delete",
WorkspaceID: workspaceID,
Name: "Doomed",
}); err != nil {
t.Fatalf("CreateWorkflow: %v", err)
}
if err := repo.CreateTask(ctx, &models.Task{
ID: "task-delete",
WorkspaceID: workspaceID,
WorkflowID: "wf-delete",
WorkflowStepID: "step-delete",
Title: "Delete task",
}); err != nil {
t.Fatalf("CreateTask: %v", err)
}
if err := repo.CreateRepository(ctx, &models.Repository{
ID: "repo-delete",
WorkspaceID: workspaceID,
Name: "Repo",
SourceType: "local",
LocalPath: "/tmp/repo-delete",
}); err != nil {
t.Fatalf("CreateRepository: %v", err)
}
if err := repo.CreateRepositoryScript(ctx, &models.RepositoryScript{
ID: "script-delete",
RepositoryID: "repo-delete",
Name: "test",
Command: "true",
}); err != nil {
t.Fatalf("CreateRepositoryScript: %v", err)
}
if err := repo.CreateTaskRepository(ctx, &models.TaskRepository{
ID: "task-repo-delete",
TaskID: "task-delete",
RepositoryID: "repo-delete",
BaseBranch: "main",
}); err != nil {
t.Fatalf("CreateTaskRepository: %v", err)
}
if err := repo.CreateTaskEnvironment(ctx, &models.TaskEnvironment{
ID: "env-delete",
TaskID: "task-delete",
RepositoryID: "repo-delete",
ExecutorType: string(models.ExecutorTypeWorktree),
Status: models.TaskEnvironmentStatusReady,
WorktreeID: "wt-delete",
WorktreePath: "/tmp/wt-delete",
WorkspacePath: "/tmp/wt-delete",
Repos: []*models.TaskEnvironmentRepo{{
ID: "env-repo-delete",
RepositoryID: "repo-delete",
WorktreeID: "wt-delete",
WorktreePath: "/tmp/wt-delete",
WorktreeBranch: "branch-delete",
}},
}); err != nil {
t.Fatalf("CreateTaskEnvironment: %v", err)
}
if err := repo.CreateTaskSession(ctx, &models.TaskSession{
ID: "session-delete",
TaskID: "task-delete",
AgentExecutionID: "exec-delete",
TaskEnvironmentID: "env-delete",
State: models.TaskSessionStateCreated,
}); err != nil {
t.Fatalf("CreateTaskSession: %v", err)
}
if err := repo.CreateTaskSessionWorktree(ctx, &models.TaskSessionWorktree{
ID: "session-wt-delete",
SessionID: "session-delete",
WorktreeID: "wt-delete",
RepositoryID: "repo-delete",
WorktreePath: "/tmp/wt-delete",
WorktreeBranch: "branch-delete",
}); err != nil {
t.Fatalf("CreateTaskSessionWorktree: %v", err)
}
if err := repo.CreateTurn(ctx, &models.Turn{
ID: "turn-delete",
TaskSessionID: "session-delete",
TaskID: "task-delete",
}); err != nil {
t.Fatalf("CreateTurn: %v", err)
}
if err := repo.CreateMessage(ctx, &models.Message{
ID: "message-delete",
TaskSessionID: "session-delete",
TaskID: "task-delete",
TurnID: "turn-delete",
AuthorType: models.MessageAuthorUser,
Content: "hello",
}); err != nil {
t.Fatalf("CreateMessage: %v", err)
}
if err := repo.CreateTaskPlan(ctx, &models.TaskPlan{
ID: "plan-delete",
TaskID: "task-delete",
Title: "Plan",
Content: "one",
CreatedBy: "agent",
}); err != nil {
t.Fatalf("CreateTaskPlan: %v", err)
}
if err := repo.InsertTaskPlanRevision(ctx, &models.TaskPlanRevision{
ID: "plan-revision-delete",
TaskID: "task-delete",
RevisionNumber: 1,
Title: "Plan",
Content: "one",
AuthorKind: "agent",
}); err != nil {
t.Fatalf("InsertTaskPlanRevision: %v", err)
}
}
func assertNoWorkspaceCascadeDependents(t *testing.T, repo *Repository) {
t.Helper()
for _, table := range []string{
"repositories",
"repository_scripts",
"task_repositories",
"task_sessions",
"task_environments",
"task_environment_repos",
"task_session_worktrees",
"task_session_turns",
"task_session_messages",
"task_plans",
"task_plan_revisions",
} {
assertTableRowCount(t, repo, table, 0)
}
}
func assertTableRowCount(t *testing.T, repo *Repository, table string, want int) {
t.Helper()
var got int
if err := repo.ro.QueryRow("SELECT COUNT(*) FROM " + table).Scan(&got); err != nil {
t.Fatalf("count %s: %v", table, err)
}
if got != want {
t.Fatalf("%s rows = %d, want %d", table, got, want)
}
}
@@ -5,6 +5,7 @@ import (
"errors"
"fmt"
"strings"
"sync"
"time"
"github.com/google/uuid"
@@ -12,10 +13,25 @@ import (
"github.com/kandev/kandev/internal/events"
"github.com/kandev/kandev/internal/task/models"
taskrepo "github.com/kandev/kandev/internal/task/repository"
"github.com/kandev/kandev/internal/worktree"
)
const spritesTokenEnvKey = "SPRITES_API_TOKEN"
const (
spritesTokenEnvKey = "SPRITES_API_TOKEN"
workspaceDeletePageSize = 500
workspaceDeleteCleanupConcurrency = 8
)
var ErrWorkspaceConfirmNameMismatch = errors.New("confirm_name does not match workspace name")
type workspaceDeleteTaskCleanup struct {
task *models.Task
sessions []*models.TaskSession
worktrees []*worktree.Worktree
stopTargets []taskStopTarget
taskEnv *models.TaskEnvironment
}
// Workspace operations
@@ -90,15 +106,231 @@ func (s *Service) DeleteWorkspace(ctx context.Context, id string) error {
if err != nil {
return err
}
if err := s.workspaces.DeleteWorkspace(ctx, id); err != nil {
s.logger.Error("failed to delete workspace", zap.String("workspace_id", id), zap.Error(err))
return s.deleteWorkspace(ctx, workspace, nil)
}
// DeleteWorkspaceWithConfirmName deletes a workspace only when confirmName
// matches the workspace name read for the cascade and final row delete.
func (s *Service) DeleteWorkspaceWithConfirmName(ctx context.Context, id, confirmName string) error {
workspace, err := s.workspaces.GetWorkspace(ctx, id)
if err != nil {
return err
}
if confirmName != workspace.Name {
return ErrWorkspaceConfirmNameMismatch
}
return s.deleteWorkspace(ctx, workspace, &confirmName)
}
func (s *Service) deleteWorkspace(ctx context.Context, workspace *models.Workspace, confirmedName *string) error {
tasks, err := s.listAllTasksForWorkspaceDelete(ctx, workspace.ID)
if err != nil {
return err
}
// Runtime cleanup needs task rows before the cascade removes them.
cleanups, err := s.prepareWorkspaceDeleteTaskCleanups(ctx, tasks)
if err != nil {
return err
}
var deletedTasks []*models.Task
var deletedWorkflows []*models.Workflow
if confirmedName == nil {
deletedTasks, deletedWorkflows, err = s.workspaces.DeleteWorkspaceCascade(ctx, workspace.ID)
} else {
deletedTasks, deletedWorkflows, err = s.workspaces.DeleteWorkspaceCascadeWithName(ctx, workspace.ID, *confirmedName)
}
if err != nil {
return s.mapWorkspaceDeleteError(workspace.ID, err)
}
cleanups = s.appendWorkspaceDeleteMissingTaskCleanups(ctx, cleanups, deletedTasks)
s.publishWorkspaceDeleteChildEvents(ctx, deletedTasks, deletedWorkflows)
s.runWorkspaceDeleteTaskCleanups(cleanups, deletedTasks)
s.publishWorkspaceEvent(ctx, events.WorkspaceDeleted, workspace)
s.logger.Info("workspace deleted", zap.String("workspace_id", id))
s.logger.Info("workspace deleted", zap.String("workspace_id", workspace.ID))
return nil
}
func (s *Service) prepareWorkspaceDeleteTaskCleanups(ctx context.Context, tasks []*models.Task) ([]workspaceDeleteTaskCleanup, error) {
cleanups := make([]workspaceDeleteTaskCleanup, 0, len(tasks))
for _, task := range tasks {
if task == nil || task.ID == "" {
continue
}
cleanup, err := s.prepareWorkspaceDeleteTaskCleanup(ctx, task)
if err != nil {
return nil, err
}
cleanups = append(cleanups, cleanup)
}
return cleanups, nil
}
func (s *Service) appendWorkspaceDeleteMissingTaskCleanups(
ctx context.Context,
cleanups []workspaceDeleteTaskCleanup,
deletedTasks []*models.Task,
) []workspaceDeleteTaskCleanup {
prepared := make(map[string]struct{}, len(cleanups))
for _, cleanup := range cleanups {
if cleanup.task != nil && cleanup.task.ID != "" {
prepared[cleanup.task.ID] = struct{}{}
}
}
for _, task := range deletedTasks {
if task == nil || task.ID == "" {
continue
}
if _, ok := prepared[task.ID]; ok {
continue
}
cleanup, err := s.prepareWorkspaceDeleteTaskCleanup(ctx, task)
if err != nil {
s.logger.Error("failed to prepare late workspace task cleanup",
zap.String("task_id", task.ID),
zap.Error(err))
continue
}
cleanups = append(cleanups, cleanup)
prepared[task.ID] = struct{}{}
}
return cleanups
}
func (s *Service) prepareWorkspaceDeleteTaskCleanup(ctx context.Context, task *models.Task) (workspaceDeleteTaskCleanup, error) {
cleanup := workspaceDeleteTaskCleanup{
task: task,
worktrees: s.gatherWorktreesForDelete(ctx, task.ID),
taskEnv: s.gatherTaskEnvironmentForCleanup(ctx, task.ID),
}
var err error
cleanup.sessions, err = s.sessions.ListTaskSessions(ctx, task.ID)
if err != nil {
return workspaceDeleteTaskCleanup{}, fmt.Errorf("list task sessions for workspace delete task %q: %w", task.ID, err)
}
if s.executionStopper == nil {
return cleanup, nil
}
activeSessions, err := s.sessions.ListActiveTaskSessionsByTaskID(ctx, task.ID)
if err != nil {
s.logger.Warn("failed to list active task sessions for workspace delete",
zap.String("task_id", task.ID),
zap.Error(err))
}
cleanup.stopTargets, err = s.buildStopTargets(ctx, task.ID, activeSessions)
if err != nil {
return workspaceDeleteTaskCleanup{}, fmt.Errorf("list runtime cleanup inventory: %w", err)
}
return cleanup, nil
}
func (s *Service) publishWorkspaceDeleteChildEvents(ctx context.Context, tasks []*models.Task, workflows []*models.Workflow) {
for _, task := range tasks {
if task == nil || task.ID == "" {
continue
}
s.publishTaskEvent(ctx, events.TaskDeleted, task, nil)
}
for _, workflow := range workflows {
if workflow == nil || workflow.ID == "" {
continue
}
s.publishWorkflowEvent(ctx, events.WorkflowDeleted, workflow)
}
}
func (s *Service) runWorkspaceDeleteTaskCleanups(cleanups []workspaceDeleteTaskCleanup, deletedTasks []*models.Task) {
jobs := s.workspaceDeleteTaskCleanupJobs(cleanups, deletedTasks)
if len(jobs) == 0 {
return
}
go s.runWorkspaceDeleteTaskCleanupJobs(jobs)
}
func (s *Service) workspaceDeleteTaskCleanupJobs(
cleanups []workspaceDeleteTaskCleanup,
deletedTasks []*models.Task,
) []workspaceDeleteTaskCleanup {
deletedTaskIDs := make(map[string]struct{}, len(deletedTasks))
for _, task := range deletedTasks {
if task != nil && task.ID != "" {
deletedTaskIDs[task.ID] = struct{}{}
}
}
jobs := make([]workspaceDeleteTaskCleanup, 0, len(cleanups))
for _, cleanup := range cleanups {
if cleanup.task == nil {
continue
}
if _, ok := deletedTaskIDs[cleanup.task.ID]; !ok {
continue
}
hasCleanup := len(cleanup.stopTargets) > 0 || s.worktreeCleanup != nil ||
len(cleanup.sessions) > 0 || cleanup.task.IsEphemeral || cleanup.taskEnv != nil
if !hasCleanup {
continue
}
jobs = append(jobs, cleanup)
}
return jobs
}
func (s *Service) runWorkspaceDeleteTaskCleanupJobs(jobs []workspaceDeleteTaskCleanup) {
workers := workspaceDeleteCleanupConcurrency
if len(jobs) < workers {
workers = len(jobs)
}
jobCh := make(chan workspaceDeleteTaskCleanup)
var wg sync.WaitGroup
wg.Add(workers)
for i := 0; i < workers; i++ {
go func() {
defer wg.Done()
for cleanup := range jobCh {
s.runWorkspaceDeleteTaskCleanup(cleanup)
}
}()
}
for _, job := range jobs {
jobCh <- job
}
close(jobCh)
wg.Wait()
}
func (s *Service) runWorkspaceDeleteTaskCleanup(cleanup workspaceDeleteTaskCleanup) {
envCleanup := taskEnvironmentCleanup{env: cleanup.taskEnv, deleteRow: false}
s.runTaskCleanup(cleanup.task.ID, cleanup.sessions, cleanup.worktrees, cleanup.stopTargets, envCleanup,
"task deleted", "failed to stop session on task delete", "task cleanup completed")
}
func (s *Service) mapWorkspaceDeleteError(id string, err error) error {
if err == nil {
return nil
}
if errors.Is(err, taskrepo.ErrWorkspaceNameMismatch) {
return ErrWorkspaceConfirmNameMismatch
}
s.logger.Error("failed to delete workspace", zap.String("workspace_id", id), zap.Error(err))
return err
}
func (s *Service) listAllTasksForWorkspaceDelete(ctx context.Context, workspaceID string) ([]*models.Task, error) {
var all []*models.Task
for page := 1; ; page++ {
tasks, total, err := s.tasks.ListTasksByWorkspace(
ctx, workspaceID, "", "", "", page, workspaceDeletePageSize, true, true, false, false,
)
if err != nil {
return nil, fmt.Errorf("list workspace tasks: %w", err)
}
all = append(all, tasks...)
if len(all) >= total || len(tasks) == 0 {
return all, nil
}
}
}
func normalizeOptionalID(value *string) *string {
if value == nil {
return nil
@@ -3,10 +3,16 @@ package service
import (
"context"
"errors"
"fmt"
"strings"
"sync/atomic"
"testing"
"time"
"github.com/kandev/kandev/internal/events"
"github.com/kandev/kandev/internal/task/models"
"github.com/kandev/kandev/internal/task/repository"
"github.com/kandev/kandev/internal/worktree"
)
// errWorkspaceRepo is a WorkspaceRepository that always returns an error from
@@ -16,6 +22,59 @@ type errWorkspaceRepo struct {
WorkspaceRepositoryStub
}
type blockingWorktreeCleanup struct {
release chan struct{}
active atomic.Int32
maxActive atomic.Int32
}
func (c *blockingWorktreeCleanup) OnTaskDeleted(context.Context, string) error {
return nil
}
func (c *blockingWorktreeCleanup) GetAllByTaskID(context.Context, string) ([]*worktree.Worktree, error) {
return nil, nil
}
func (c *blockingWorktreeCleanup) CleanupWorktrees(ctx context.Context, _ []*worktree.Worktree) error {
active := c.active.Add(1)
updateMaxActive(&c.maxActive, active)
defer c.active.Add(-1)
select {
case <-ctx.Done():
return ctx.Err()
case <-c.release:
return nil
}
}
func updateMaxActive(maxActive *atomic.Int32, value int32) {
for {
current := maxActive.Load()
if value <= current || maxActive.CompareAndSwap(current, value) {
return
}
}
}
func waitForActiveCleanups(t *testing.T, cleanup *blockingWorktreeCleanup, want int32) {
t.Helper()
deadline := time.After(500 * time.Millisecond)
ticker := time.NewTicker(5 * time.Millisecond)
defer ticker.Stop()
for {
if cleanup.active.Load() >= want {
return
}
select {
case <-deadline:
t.Fatalf("active cleanups = %d, want at least %d", cleanup.active.Load(), want)
case <-ticker.C:
}
}
}
// WorkspaceRepositoryStub satisfies the full WorkspaceRepository interface
// with no-op / panic stubs. Only methods under test need real implementations.
type WorkspaceRepositoryStub struct{}
@@ -32,10 +91,73 @@ func (WorkspaceRepositoryStub) UpdateWorkspace(_ context.Context, _ *models.Work
func (WorkspaceRepositoryStub) DeleteWorkspace(_ context.Context, _ string) error {
panic("not implemented")
}
func (WorkspaceRepositoryStub) DeleteWorkspaceCascade(_ context.Context, _ string) ([]*models.Task, []*models.Workflow, error) {
panic("not implemented")
}
func (WorkspaceRepositoryStub) DeleteWorkspaceCascadeWithName(_ context.Context, _, _ string) ([]*models.Task, []*models.Workflow, error) {
panic("not implemented")
}
func (WorkspaceRepositoryStub) ListWorkspaces(_ context.Context) ([]*models.Workspace, error) {
panic("not implemented")
}
type renameBeforeConfirmedDeleteRepo struct {
repository.WorkspaceRepository
}
func (r renameBeforeConfirmedDeleteRepo) DeleteWorkspaceCascadeWithName(
ctx context.Context,
id, name string,
) ([]*models.Task, []*models.Workflow, error) {
workspace, err := r.GetWorkspace(ctx, id)
if err != nil {
return nil, nil, err
}
workspace.Name = "Renamed"
if err := r.UpdateWorkspace(ctx, workspace); err != nil {
return nil, nil, err
}
return r.WorkspaceRepository.DeleteWorkspaceCascadeWithName(ctx, id, name)
}
type createDuringConfirmedDeleteRepo struct {
repository.WorkspaceRepository
tasks repository.TaskRepository
workflows repository.WorkflowRepository
}
func (r createDuringConfirmedDeleteRepo) DeleteWorkspaceCascadeWithName(
ctx context.Context,
id, name string,
) ([]*models.Task, []*models.Workflow, error) {
if err := r.workflows.CreateWorkflow(ctx, &models.Workflow{
ID: "wf-raced",
WorkspaceID: id,
Name: "Raced",
}); err != nil {
return nil, nil, err
}
if err := r.tasks.CreateTask(ctx, &models.Task{
ID: "task-raced",
WorkspaceID: id,
WorkflowID: "wf-raced",
WorkflowStepID: "step-raced",
Title: "Raced task",
}); err != nil {
return nil, nil, err
}
return r.WorkspaceRepository.DeleteWorkspaceCascadeWithName(ctx, id, name)
}
type failingListTaskSessionsRepo struct {
repository.SessionRepository
err error
}
func (r failingListTaskSessionsRepo) ListTaskSessions(context.Context, string) ([]*models.TaskSession, error) {
return nil, r.err
}
func (e errWorkspaceRepo) ListWorkspaces(_ context.Context) ([]*models.Workspace, error) {
return nil, errors.New("db unavailable")
}
@@ -129,6 +251,388 @@ func TestService_GetOfficeWorkflowIDs_DBError(t *testing.T) {
}
}
func TestService_DeleteWorkspaceDeletesWorkspaceOwnedTasksAndWorkflows(t *testing.T) {
svc, _, repo := createTestService(t)
ctx := context.Background()
_ = repo.CreateWorkspace(ctx, &models.Workspace{ID: "ws-delete", Name: "Delete Me"})
_ = repo.CreateWorkspace(ctx, &models.Workspace{ID: "ws-keep", Name: "Keep Me"})
_ = repo.CreateWorkflow(ctx, &models.Workflow{ID: "wf-delete", WorkspaceID: "ws-delete", Name: "Doomed"})
_ = repo.CreateWorkflow(ctx, &models.Workflow{ID: "wf-keep", WorkspaceID: "ws-keep", Name: "Keep"})
if err := repo.CreateTask(ctx, &models.Task{
ID: "task-delete",
WorkspaceID: "ws-delete",
WorkflowID: "wf-delete",
WorkflowStepID: "step-delete",
Title: "Delete task",
}); err != nil {
t.Fatalf("CreateTask: %v", err)
}
if err := svc.DeleteWorkspace(ctx, "ws-delete"); err != nil {
t.Fatalf("DeleteWorkspace: %v", err)
}
if _, err := repo.GetWorkspace(ctx, "ws-delete"); err == nil {
t.Fatalf("workspace should be deleted")
}
if _, err := repo.GetTask(ctx, "task-delete"); err == nil {
t.Fatalf("workspace task should be deleted")
}
workflows, err := repo.ListWorkflows(ctx, "ws-delete", true)
if err != nil {
t.Fatalf("ListWorkflows: %v", err)
}
if len(workflows) != 0 {
t.Fatalf("workspace workflows should be deleted, got %d", len(workflows))
}
if _, err := repo.GetWorkflow(ctx, "wf-keep"); err != nil {
t.Fatalf("unrelated workflow should remain: %v", err)
}
}
func TestService_DeleteWorkspacePublishesChildEventsAndCleansResources(t *testing.T) {
svc, eventBus, repo := createTestService(t)
ctx := context.Background()
svc.setCleanupDoneForTestHook(make(chan struct{}, 1))
cleanup := &recordingWorktreeCleanup{
worktrees: []*worktree.Worktree{{ID: "wt-delete", TaskID: "task-delete"}},
}
svc.SetWorktreeCleanup(cleanup)
_ = repo.CreateWorkspace(ctx, &models.Workspace{ID: "ws-delete", Name: "Delete Me"})
_ = repo.CreateWorkflow(ctx, &models.Workflow{ID: "wf-delete", WorkspaceID: "ws-delete", Name: "Doomed"})
if err := repo.CreateTask(ctx, &models.Task{
ID: "task-delete",
WorkspaceID: "ws-delete",
WorkflowID: "wf-delete",
WorkflowStepID: "step-delete",
Title: "Delete task",
}); err != nil {
t.Fatalf("CreateTask: %v", err)
}
eventBus.ClearEvents()
if err := svc.DeleteWorkspace(ctx, "ws-delete"); err != nil {
t.Fatalf("DeleteWorkspace: %v", err)
}
waitForCleanupDone(t, svc)
eventCounts := make(map[string]int)
for _, event := range eventBus.GetPublishedEvents() {
eventCounts[event.Type]++
}
if eventCounts[events.TaskDeleted] != 1 {
t.Fatalf("task deleted events = %d, want 1", eventCounts[events.TaskDeleted])
}
if eventCounts[events.WorkflowDeleted] != 1 {
t.Fatalf("workflow deleted events = %d, want 1", eventCounts[events.WorkflowDeleted])
}
if eventCounts[events.WorkspaceDeleted] != 1 {
t.Fatalf("workspace deleted events = %d, want 1", eventCounts[events.WorkspaceDeleted])
}
cleanedIDs := cleanup.cleanedIDs()
if len(cleanedIDs) != 1 || cleanedIDs[0] != "wt-delete" {
t.Fatalf("cleaned worktrees = %#v, want wt-delete", cleanedIDs)
}
}
func TestService_DeleteWorkspaceStopsBeforeCascadeWhenSessionInventoryFails(t *testing.T) {
svc, _, repo := createTestService(t)
ctx := context.Background()
_ = repo.CreateWorkspace(ctx, &models.Workspace{ID: "ws-delete", Name: "Delete Me"})
_ = repo.CreateWorkflow(ctx, &models.Workflow{ID: "wf-delete", WorkspaceID: "ws-delete", Name: "Doomed"})
if err := repo.CreateTask(ctx, &models.Task{
ID: "task-delete",
WorkspaceID: "ws-delete",
WorkflowID: "wf-delete",
WorkflowStepID: "step-delete",
Title: "Delete task",
}); err != nil {
t.Fatalf("CreateTask: %v", err)
}
listErr := errors.New("session inventory unavailable")
svc.sessions = failingListTaskSessionsRepo{SessionRepository: repo, err: listErr}
err := svc.DeleteWorkspace(ctx, "ws-delete")
if !errors.Is(err, listErr) {
t.Fatalf("expected session inventory error, got %v", err)
}
if _, err := repo.GetWorkspace(ctx, "ws-delete"); err != nil {
t.Fatalf("workspace should remain: %v", err)
}
if _, err := repo.GetTask(ctx, "task-delete"); err != nil {
t.Fatalf("workspace task should remain: %v", err)
}
if _, err := repo.GetWorkflow(ctx, "wf-delete"); err != nil {
t.Fatalf("workspace workflow should remain: %v", err)
}
}
func TestService_RunWorkspaceDeleteTaskCleanupsCapsConcurrency(t *testing.T) {
svc, _, _ := createTestService(t)
taskCount := workspaceDeleteCleanupConcurrency + 3
svc.setCleanupDoneForTestHook(make(chan struct{}, taskCount))
cleanup := &blockingWorktreeCleanup{release: make(chan struct{})}
svc.SetWorktreeCleanup(cleanup)
cleanups := make([]workspaceDeleteTaskCleanup, 0, taskCount)
deletedTasks := make([]*models.Task, 0, taskCount)
for i := 0; i < taskCount; i++ {
taskID := fmt.Sprintf("task-%02d", i)
task := &models.Task{ID: taskID}
cleanups = append(cleanups, workspaceDeleteTaskCleanup{
task: task,
worktrees: []*worktree.Worktree{{ID: "wt-" + taskID, TaskID: taskID}},
})
deletedTasks = append(deletedTasks, task)
}
svc.runWorkspaceDeleteTaskCleanups(cleanups, deletedTasks)
waitForActiveCleanups(t, cleanup, workspaceDeleteCleanupConcurrency)
close(cleanup.release)
for i := 0; i < taskCount; i++ {
waitForCleanupDone(t, svc)
}
if got := cleanup.maxActive.Load(); got > workspaceDeleteCleanupConcurrency {
t.Fatalf("max active cleanups = %d, want <= %d", got, workspaceDeleteCleanupConcurrency)
}
}
func TestService_DeleteWorkspaceWithConfirmNameDeletesWhenNameMatches(t *testing.T) {
svc, _, repo := createTestService(t)
ctx := context.Background()
_ = repo.CreateWorkspace(ctx, &models.Workspace{ID: "ws-delete", Name: "Delete Me"})
_ = repo.CreateWorkflow(ctx, &models.Workflow{ID: "wf-delete", WorkspaceID: "ws-delete", Name: "Doomed"})
if err := repo.CreateTask(ctx, &models.Task{
ID: "task-delete",
WorkspaceID: "ws-delete",
WorkflowID: "wf-delete",
WorkflowStepID: "step-delete",
Title: "Delete task",
}); err != nil {
t.Fatalf("CreateTask: %v", err)
}
if err := svc.DeleteWorkspaceWithConfirmName(ctx, "ws-delete", "Delete Me"); err != nil {
t.Fatalf("DeleteWorkspaceWithConfirmName: %v", err)
}
if _, err := repo.GetWorkspace(ctx, "ws-delete"); err == nil {
t.Fatalf("workspace should be deleted")
}
if _, err := repo.GetTask(ctx, "task-delete"); err == nil {
t.Fatalf("workspace task should be deleted")
}
workflows, err := repo.ListWorkflows(ctx, "ws-delete", true)
if err != nil {
t.Fatalf("ListWorkflows: %v", err)
}
if len(workflows) != 0 {
t.Fatalf("workspace workflows should be deleted, got %d", len(workflows))
}
}
func TestService_DeleteWorkspaceWithConfirmNamePublishesChildEventsAndCleansResources(t *testing.T) {
svc, eventBus, repo := createTestService(t)
ctx := context.Background()
svc.setCleanupDoneForTestHook(make(chan struct{}, 1))
cleanup := &recordingWorktreeCleanup{
worktrees: []*worktree.Worktree{{ID: "wt-delete", TaskID: "task-delete"}},
}
svc.SetWorktreeCleanup(cleanup)
_ = repo.CreateWorkspace(ctx, &models.Workspace{ID: "ws-delete", Name: "Delete Me"})
_ = repo.CreateWorkflow(ctx, &models.Workflow{ID: "wf-delete", WorkspaceID: "ws-delete", Name: "Doomed"})
if err := repo.CreateTask(ctx, &models.Task{
ID: "task-delete",
WorkspaceID: "ws-delete",
WorkflowID: "wf-delete",
WorkflowStepID: "step-delete",
Title: "Delete task",
}); err != nil {
t.Fatalf("CreateTask: %v", err)
}
eventBus.ClearEvents()
if err := svc.DeleteWorkspaceWithConfirmName(ctx, "ws-delete", "Delete Me"); err != nil {
t.Fatalf("DeleteWorkspaceWithConfirmName: %v", err)
}
waitForCleanupDone(t, svc)
eventCounts := make(map[string]int)
for _, event := range eventBus.GetPublishedEvents() {
eventCounts[event.Type]++
}
if eventCounts[events.TaskDeleted] != 1 {
t.Fatalf("task deleted events = %d, want 1", eventCounts[events.TaskDeleted])
}
if eventCounts[events.WorkflowDeleted] != 1 {
t.Fatalf("workflow deleted events = %d, want 1", eventCounts[events.WorkflowDeleted])
}
if eventCounts[events.WorkspaceDeleted] != 1 {
t.Fatalf("workspace deleted events = %d, want 1", eventCounts[events.WorkspaceDeleted])
}
cleanedIDs := cleanup.cleanedIDs()
if len(cleanedIDs) != 1 || cleanedIDs[0] != "wt-delete" {
t.Fatalf("cleaned worktrees = %#v, want wt-delete", cleanedIDs)
}
}
func TestService_DeleteWorkspaceWithConfirmNamePublishesEventsForAllCascadeDeletedChildren(t *testing.T) {
svc, eventBus, repo := createTestService(t)
ctx := context.Background()
svc.setCleanupDoneForTestHook(make(chan struct{}, 2))
cleanup := &recordingWorktreeCleanup{
worktreesByTaskID: map[string][]*worktree.Worktree{
"task-delete": {{ID: "wt-delete", TaskID: "task-delete"}},
"task-raced": {{ID: "wt-raced", TaskID: "task-raced"}},
},
}
svc.SetWorktreeCleanup(cleanup)
_ = repo.CreateWorkspace(ctx, &models.Workspace{ID: "ws-delete", Name: "Delete Me"})
_ = repo.CreateWorkflow(ctx, &models.Workflow{ID: "wf-delete", WorkspaceID: "ws-delete", Name: "Doomed"})
if err := repo.CreateTask(ctx, &models.Task{
ID: "task-delete",
WorkspaceID: "ws-delete",
WorkflowID: "wf-delete",
WorkflowStepID: "step-delete",
Title: "Delete task",
}); err != nil {
t.Fatalf("CreateTask: %v", err)
}
svc.workspaces = createDuringConfirmedDeleteRepo{
WorkspaceRepository: repo,
tasks: repo,
workflows: repo,
}
eventBus.ClearEvents()
if err := svc.DeleteWorkspaceWithConfirmName(ctx, "ws-delete", "Delete Me"); err != nil {
t.Fatalf("DeleteWorkspaceWithConfirmName: %v", err)
}
waitForCleanupDone(t, svc)
waitForCleanupDone(t, svc)
// This covers event publication from the repository cascade return value.
// Runtime cleanup is prepared before the cascade and topped up from the
// cascade return value for children that appear after that first snapshot.
eventCounts := make(map[string]int)
for _, event := range eventBus.GetPublishedEvents() {
eventCounts[event.Type]++
}
if eventCounts[events.TaskDeleted] != 2 {
t.Fatalf("task deleted events = %d, want 2", eventCounts[events.TaskDeleted])
}
if eventCounts[events.WorkflowDeleted] != 2 {
t.Fatalf("workflow deleted events = %d, want 2", eventCounts[events.WorkflowDeleted])
}
if _, err := repo.GetTask(ctx, "task-raced"); err == nil {
t.Fatalf("late-created task should be deleted")
}
if _, err := repo.GetWorkflow(ctx, "wf-raced"); err == nil {
t.Fatalf("late-created workflow should be deleted")
}
cleaned := make(map[string]bool)
for _, id := range cleanup.cleanedIDs() {
cleaned[id] = true
}
if len(cleaned) != 2 || !cleaned["wt-delete"] || !cleaned["wt-raced"] {
t.Fatalf("cleaned worktrees = %#v, want wt-delete and wt-raced", cleaned)
}
}
func TestService_DeleteWorkspaceWithConfirmNameRejectsMismatchedName(t *testing.T) {
svc, _, repo := createTestService(t)
ctx := context.Background()
_ = repo.CreateWorkspace(ctx, &models.Workspace{ID: "ws-delete", Name: "Delete Me"})
_ = repo.CreateWorkflow(ctx, &models.Workflow{ID: "wf-delete", WorkspaceID: "ws-delete", Name: "Doomed"})
if err := repo.CreateTask(ctx, &models.Task{
ID: "task-delete",
WorkspaceID: "ws-delete",
WorkflowID: "wf-delete",
WorkflowStepID: "step-delete",
Title: "Delete task",
}); err != nil {
t.Fatalf("CreateTask: %v", err)
}
err := svc.DeleteWorkspaceWithConfirmName(ctx, "ws-delete", "Wrong")
if !errors.Is(err, ErrWorkspaceConfirmNameMismatch) {
t.Fatalf("expected ErrWorkspaceConfirmNameMismatch, got %v", err)
}
if _, err := repo.GetWorkspace(ctx, "ws-delete"); err != nil {
t.Fatalf("workspace should remain: %v", err)
}
if _, err := repo.GetTask(ctx, "task-delete"); err != nil {
t.Fatalf("workspace task should remain: %v", err)
}
if _, err := repo.GetWorkflow(ctx, "wf-delete"); err != nil {
t.Fatalf("workspace workflow should remain: %v", err)
}
}
func TestService_DeleteWorkspaceWithConfirmNameReturnsMissingWorkspaceError(t *testing.T) {
svc, _, _ := createTestService(t)
ctx := context.Background()
err := svc.DeleteWorkspaceWithConfirmName(ctx, "ws-missing", "Missing")
if err == nil {
t.Fatalf("expected missing workspace error")
}
if errors.Is(err, ErrWorkspaceConfirmNameMismatch) {
t.Fatalf("expected missing workspace error, got confirm-name mismatch")
}
if !errors.Is(err, repository.ErrWorkspaceNotFound) {
t.Fatalf("expected ErrWorkspaceNotFound, got %v", err)
}
if !strings.Contains(err.Error(), "workspace not found") {
t.Fatalf("expected workspace not found error, got %v", err)
}
}
func TestService_DeleteWorkspaceWithConfirmNameRejectsFinalNameMismatch(t *testing.T) {
svc, _, repo := createTestService(t)
ctx := context.Background()
_ = repo.CreateWorkspace(ctx, &models.Workspace{ID: "ws-delete", Name: "Delete Me"})
_ = repo.CreateWorkflow(ctx, &models.Workflow{ID: "wf-delete", WorkspaceID: "ws-delete", Name: "Doomed"})
if err := repo.CreateTask(ctx, &models.Task{
ID: "task-delete",
WorkspaceID: "ws-delete",
WorkflowID: "wf-delete",
WorkflowStepID: "step-delete",
Title: "Delete task",
}); err != nil {
t.Fatalf("CreateTask: %v", err)
}
svc.workspaces = renameBeforeConfirmedDeleteRepo{WorkspaceRepository: repo}
err := svc.DeleteWorkspaceWithConfirmName(ctx, "ws-delete", "Delete Me")
if !errors.Is(err, ErrWorkspaceConfirmNameMismatch) {
t.Fatalf("expected ErrWorkspaceConfirmNameMismatch, got %v", err)
}
workspace, err := repo.GetWorkspace(ctx, "ws-delete")
if err != nil {
t.Fatalf("workspace should remain: %v", err)
}
if workspace.Name != "Renamed" {
t.Fatalf("workspace should keep concurrent rename, got %q", workspace.Name)
}
if _, err := repo.GetTask(ctx, "task-delete"); err != nil {
t.Fatalf("workspace task should remain: %v", err)
}
if _, err := repo.GetWorkflow(ctx, "wf-delete"); err != nil {
t.Fatalf("workspace workflow should remain: %v", err)
}
}
// TestService_DeleteWorkflow_ArchivesChildTasks verifies the cascade fix for
// issue #1279: workflow deletion archives any active child tasks instead of
// leaving them with a dangling workflow_id (tasks.workflow_id has no FK, so
@@ -1012,27 +1012,36 @@ func (s *Service) runAsyncTaskCleanup(
envCleanup taskEnvironmentCleanup,
stopReason, stopFailMsg, cleanupMsg string,
) {
go func() {
cleanupStart := time.Now()
cleanupCtx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
defer cancel()
go s.runTaskCleanup(id, sessions, worktrees, stopTargets, envCleanup, stopReason, stopFailMsg, cleanupMsg)
}
failedStops := s.stopTaskRuntimeTargets(cleanupCtx, id, stopTargets, stopReason, stopFailMsg)
func (s *Service) runTaskCleanup(
id string,
sessions []*models.TaskSession,
worktrees []*worktree.Worktree,
stopTargets []taskStopTarget,
envCleanup taskEnvironmentCleanup,
stopReason, stopFailMsg, cleanupMsg string,
) {
cleanupStart := time.Now()
cleanupCtx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
defer cancel()
cleanupErrors := s.performTaskCleanup(cleanupCtx, id, sessions, worktrees, stopTargets, envCleanup, failedStops)
failedStops := s.stopTaskRuntimeTargets(cleanupCtx, id, stopTargets, stopReason, stopFailMsg)
if len(cleanupErrors) > 0 {
s.logger.Warn(cleanupMsg+" with errors",
zap.String("task_id", id),
zap.Int("error_count", len(cleanupErrors)),
zap.Duration("duration", time.Since(cleanupStart)))
} else {
s.logger.Info(cleanupMsg,
zap.String("task_id", id),
zap.Duration("duration", time.Since(cleanupStart)))
}
s.signalCleanupDoneForTest()
}()
cleanupErrors := s.performTaskCleanup(cleanupCtx, id, sessions, worktrees, stopTargets, envCleanup, failedStops)
if len(cleanupErrors) > 0 {
s.logger.Warn(cleanupMsg+" with errors",
zap.String("task_id", id),
zap.Int("error_count", len(cleanupErrors)),
zap.Duration("duration", time.Since(cleanupStart)))
} else {
s.logger.Info(cleanupMsg,
zap.String("task_id", id),
zap.Duration("duration", time.Since(cleanupStart)))
}
s.signalCleanupDoneForTest()
}
// isCleanableSessionState reports whether a session has no running agent process
@@ -704,8 +704,9 @@ func TestService_DeleteTaskCleansSuccessfulSessionResourcesOnPartialStopFailure(
if _, err := os.Stat(filepath.Join(quickChatDir, "session-failed")); err != nil {
t.Fatalf("failed session quick-chat directory should remain: %v", err)
}
if len(cleanup.cleaned) != 1 || cleanup.cleaned[0].ID != "wt-ok" {
t.Fatalf("expected only successful session worktree cleanup, got %#v", cleanup.cleaned)
cleanedIDs := cleanup.cleanedIDs()
if len(cleanedIDs) != 1 || cleanedIDs[0] != "wt-ok" {
t.Fatalf("expected only successful session worktree cleanup, got %#v", cleanedIDs)
}
if _, err := repo.GetExecutorRunningBySessionID(ctx, "session-failed"); err != nil {
t.Fatalf("failed session executor row should remain retryable: %v", err)
@@ -897,8 +898,8 @@ func TestService_CleanupTaskResourcesFailsClosedWhenRuntimeInventoryFails(t *tes
if _, err := os.Stat(sessionDir); err != nil {
t.Fatalf("quick-chat directory should remain when runtime inventory fails: %v", err)
}
if len(cleanup.cleaned) != 0 {
t.Fatalf("worktrees should not be cleaned when runtime inventory fails, got %#v", cleanup.cleaned)
if cleanedIDs := cleanup.cleanedIDs(); len(cleanedIDs) != 0 {
t.Fatalf("worktrees should not be cleaned when runtime inventory fails, got %#v", cleanedIDs)
}
}
@@ -975,23 +976,42 @@ func (r failingExecutorRepository) ListExecutorsRunningByTaskID(context.Context,
}
type recordingWorktreeCleanup struct {
worktrees []*worktree.Worktree
cleaned []*worktree.Worktree
mu sync.Mutex
worktrees []*worktree.Worktree
worktreesByTaskID map[string][]*worktree.Worktree
cleaned []*worktree.Worktree
}
func (c *recordingWorktreeCleanup) OnTaskDeleted(context.Context, string) error {
return nil
}
func (c *recordingWorktreeCleanup) GetAllByTaskID(context.Context, string) ([]*worktree.Worktree, error) {
func (c *recordingWorktreeCleanup) GetAllByTaskID(_ context.Context, taskID string) ([]*worktree.Worktree, error) {
if c.worktreesByTaskID != nil {
return c.worktreesByTaskID[taskID], nil
}
return c.worktrees, nil
}
func (c *recordingWorktreeCleanup) CleanupWorktrees(_ context.Context, worktrees []*worktree.Worktree) error {
c.mu.Lock()
defer c.mu.Unlock()
c.cleaned = append(c.cleaned, worktrees...)
return nil
}
func (c *recordingWorktreeCleanup) cleanedIDs() []string {
c.mu.Lock()
defer c.mu.Unlock()
ids := make([]string, 0, len(c.cleaned))
for _, wt := range c.cleaned {
if wt != nil {
ids = append(ids, wt.ID)
}
}
return ids
}
func waitForCleanupDone(t *testing.T, svc *Service) {
t.Helper()
select {
@@ -254,6 +254,54 @@ type DockviewDesktopLayoutProps = {
compact?: boolean;
};
type ReadyDockviewLayoutSetup = {
buildDefaultLayout: (api: DockviewReadyEvent["api"], intentName?: string) => void;
compact: boolean;
initialLayout?: string | null;
};
type ReadyDockviewRefs = {
envIdRef: React.MutableRefObject<string | null>;
readyDisposersRef: React.MutableRefObject<Array<() => void>>;
saveTimerRef: React.MutableRefObject<ReturnType<typeof setTimeout> | null>;
setApi: (api: DockviewReadyEvent["api"] | null) => void;
};
type ReadyDockviewSetup = {
api: DockviewReadyEvent["api"];
appStore: ReturnType<typeof useAppStoreApi>;
layout: ReadyDockviewLayoutSetup;
refs: ReadyDockviewRefs;
};
function setupReadyDockview({ api, appStore, layout, refs }: ReadyDockviewSetup): void {
refs.setApi(api);
const currentEnvId = refs.envIdRef.current;
const restored =
!layout.initialLayout && restoreEnvLayout(api, currentEnvId, appStore, VALID_COMPONENTS);
if (!restored) {
layout.buildDefaultLayout(
api,
layout.initialLayout ?? (layout.compact ? "compact" : undefined),
);
}
useDockviewStore.setState({ currentLayoutEnvId: currentEnvId });
refs.readyDisposersRef.current.push(setupGroupTracking(api));
const sessionTabSyncDisposable = setupSessionTabSync(api, appStore);
refs.readyDisposersRef.current.push(() => sessionTabSyncDisposable.dispose());
const chatPanelSafetyNetDisposable = setupChatPanelSafetyNet(api, appStore);
refs.readyDisposersRef.current.push(() => chatPanelSafetyNetDisposable.dispose());
refs.readyDisposersRef.current.push(
setupLayoutPersistence(api, refs.saveTimerRef, refs.envIdRef),
);
setupPortalCleanup(api, appStore);
refs.readyDisposersRef.current.push(setupContainerResizeSync(api));
refs.readyDisposersRef.current.push(setupSashDragCapToggle(api));
}
export const DockviewDesktopLayout = memo(function DockviewDesktopLayout({
sessionId,
repository,
@@ -290,27 +338,12 @@ export const DockviewDesktopLayout = memo(function DockviewDesktopLayout({
const onReady = useCallback(
(event: DockviewReadyEvent) => {
const api = event.api;
setApi(api);
const currentEnvId = envIdRef.current;
const restored =
!initialLayout && restoreEnvLayout(api, currentEnvId, appStore, VALID_COMPONENTS);
if (!restored) {
buildDefaultLayout(api, initialLayout ?? (compact ? "compact" : undefined));
}
useDockviewStore.setState({ currentLayoutEnvId: currentEnvId });
readyDisposersRef.current.push(setupGroupTracking(api));
const sessionTabSyncDisposable = setupSessionTabSync(api, appStore);
readyDisposersRef.current.push(() => sessionTabSyncDisposable.dispose());
const chatPanelSafetyNetDisposable = setupChatPanelSafetyNet(api, appStore);
readyDisposersRef.current.push(() => chatPanelSafetyNetDisposable.dispose());
readyDisposersRef.current.push(setupLayoutPersistence(api, saveTimerRef, envIdRef));
setupPortalCleanup(api, appStore);
readyDisposersRef.current.push(setupContainerResizeSync(api));
readyDisposersRef.current.push(setupSashDragCapToggle(api));
setupReadyDockview({
api: event.api,
appStore,
layout: { buildDefaultLayout, compact, initialLayout },
refs: { envIdRef, readyDisposersRef, saveTimerRef, setApi },
});
},
[setApi, buildDefaultLayout, initialLayout, compact, appStore],
);