Skip to content

Self-hosted workflows for coding-agent delivery. Orchestrate CodeBuddy, Codex and Claude Code with scripts and human approval gates. Includes Local workflows for coding assistants.

feat(issues): allow force deletion of settled execution history (#210)

crispinhu27a7c6f15cb8ff
diff --git a/design.md b/design.md
index 0fedebbf..e2505c61 100644
--- a/design.md
+++ b/design.md
@@ -170,7 +170,7 @@
- 当前环节使用 Status Badge,颜色由环节类型和文字共同决定:运行中蓝色呼吸点、排队中蓝色时钟、待澄清与待确认琥珀色、失败红色、已合入与已完成绿色、已关闭与未开始灰色。映射在 `issueStageTone()`。
- 四个筛选由 `hui-select.js` 以触发器模式增强为 Harness Selector:原生 `select` 仍在 DOM 中负责取值和 `change`,增强层通过 MutationObserver 和 `value` 写入同步选项与文字。选项超过 5 个时显示搜索框,选了非默认值时触发器显示淡紫底。
- 「更多」菜单、筛选面板和行内「⋯」共用同一套面板规格:8px 圆角、细边框、面板阴影,选项 36px,同一时刻只开一个浮层。
-- 需求的「删除需求」入口始终保留;不可删除时置灰,在菜单和详情中直接显示后端返回的具体原因,并提供查看澄清、相关运行或需求详情的入口。批量选择禁用不可删项,同时提供可展开的原因列表;未知删除条件提示刷新,不猜测执行历史。删除限制和服务端最终校验保持不变。
+- 需求的菜单和详情显示「删除需求」。有已结束的任务或运行记录、或需求已完成时,入口显示「强制删除」,危险操作确认框说明会一并清理执行数据。批量删除包含这类需求时,确认框显示需要强制删除的条数。澄清或执行尚未结束时,入口置灰并显示后端返回的原因和处理入口。未知删除条件提示刷新,服务端按完整历史校验。
- 优先级使用信号格图标,紧急使用闪电图标;责任人前显示首字头像,Agent 用机器人图标,未指定用人像占位。超长编号单行截断,列宽上限 120px,悬停显示完整编号。
- 窗口 1200px 以下搜索框、筛选按钮和项目数据块同步收窄,1024px 下筛选栏保持一行;960px 以下标题区、项目条和筛选栏改为上下堆叠。
diff --git a/e2e/README.md b/e2e/README.md
index 625dfc55..6cc2f32e 100644
--- a/e2e/README.md
+++ b/e2e/README.md
@@ -50,7 +50,7 @@ API Token 和 UI 登录账号应属于同一用户。模型 Key 在平台个人
- `api/00-smoke`:健康、匿名和伪造身份拒绝、Token 权限边界及约 40 个读取接口。
- `api/10-catalog`:规则、技能文件、MCP、环境、沙箱、角色和 SOP CRUD,修订/恢复/克隆、引用保护、模板采用、仓库登记。
-- `api/20-issues`:需求、评论、审计、澄清门禁、派发、关闭与重开、删除(已有成功运行或执行中拒绝,取消的执行记录随需求一起删除)。
+- `api/20-issues`:需求、评论、审计、澄清门禁、派发、关闭与重开、删除(已有执行记录需确认强制删除,执行中拒绝,已结束的执行记录可强制删除)。
- `api/30-runs`:脚本执行、产物与工作区、审批/驳回、返工、重试、暂停/恢复、取消、子 SOP 与 SSE。
- `api/30-runs`、`api/35-runner-mode` 里的“带代码仓库的子 SOP”:父流程写文件 → 子 SOP 读到并再写一个 → 父流程读到;同时检查节点没有提交、远端没被推送,分别覆盖平台本机和执行机器。
- `api/35-runner-mode`:下载、启动并绑定真实 Runner,验证跨节点产物交接和失败场景,结束后恢复默认执行机器。
diff --git a/e2e/api/20-issues.test.mjs b/e2e/api/20-issues.test.mjs
index 171d64b6..83aeceec 100644
--- a/e2e/api/20-issues.test.mjs
+++ b/e2e/api/20-issues.test.mjs
@@ -1,6 +1,6 @@
// Requirement lifecycle: create, list/filter/paginate, edit, comment,
// clarification, SOP binding, dispatch into a real run, close and reopen, and
-// deleting a local requirement (refused while its run waits, history kept).
+// deleting a local requirement and its settled execution history.
import { test, before, after } from 'node:test';
import assert from 'node:assert/strict';
import { api, get, post, put, list, track, cleanup, ensureProject, waitFor, waitRun } from '../lib/api.mjs';
@@ -17,11 +17,10 @@ before(async () => {
});
after(cleanup);
-// Local requirements are deleted afterwards; a delivered, busy or half-deleted
-// one is closed so its SOP binding is released before the workflow is deleted.
+// Clean up the test's own requirements, including their execution history.
function removeLater(id) {
track(`issue ${id}`, async () => {
- const res = await api('DELETE', `/api/issues/${id}`, undefined, { expect: [204, 400, 404, 409], raw: true });
+ const res = await api('DELETE', `/api/issues/${id}?force=true`, undefined, { expect: [204, 400, 404, 409], raw: true });
if (res.status === 400 || res.status === 409) await post(`/api/issues/${id}/close`, {}, { expect: [200, 400, 404, 409] });
});
}
@@ -155,24 +154,20 @@ async function waitingIssue(label) {
return { id: created.id, runId };
}
-test('delete: refused once a run succeeded or while one waits; a cancelled attempt goes with the requirement', {
+test('delete: execution history requires force; a waiting run blocks deletion', {
todo: 'POST /api/runs/:id/cancel tears the sandbox down inside the request (docker rm -f of the agentflow-run-*-scripts sidecar, up to dockerTeardownTimeout=60s); under nested Docker that rm hangs, so the call outlives the 60s client timeout',
}, async () => {
- // A requirement that delivered (its dispatched run succeeded) is history.
- // Listing settles task status before the detail reason is shown.
+ // Listing settles task status before the detail affordance is shown.
await get(`/api/issues?projectId=${P}`);
const deliveredDetail = await detailOf(issue.id);
- assert.equal(deliveredDetail.issue.deletionAllowed, false);
- assert.equal(deliveredDetail.issue.deletionBlock?.code, 'succeeded');
- assert.ok(deliveredDetail.issue.deletionBlock?.runId, `succeeded history has no run: ${JSON.stringify(deliveredDetail.issue.deletionBlock)}`);
- assert.match(deliveredDetail.issue.deletionBlock.reason, /已有成功执行记录/);
+ assert.equal(deliveredDetail.issue.deletionAllowed, true);
+ assert.equal(deliveredDetail.issue.deletionRequiresForce, true);
+ assert.equal(deliveredDetail.issue.deletionBlock ?? null, null);
const listed = list(await get(`/api/issues?projectId=${P}`)).find(i => i.id === issue.id);
- assert.equal(listed?.deletionBlock?.reason, deliveredDetail.issue.deletionBlock.reason);
- assert.equal(listed?.deletionBlock?.runId, deliveredDetail.issue.deletionBlock.runId);
+ assert.equal(listed?.deletionRequiresForce, true);
+ assert.equal(listed?.deletionAllowed, true);
const delivered = await api('DELETE', `/api/issues/${issue.id}`, undefined, { expect: 409 });
- assert.equal(delivered.error, deliveredDetail.issue.deletionBlock.reason);
- assert.equal(delivered.deletionBlock?.code, 'succeeded');
- assert.equal(delivered.deletionBlock?.runId, deliveredDetail.issue.deletionBlock.runId);
+ assert.equal(delivered.deletionRequiresForce, true);
const doomed = await waitingIssue('issue-delete');
await post(`/api/issues/${doomed.id}/comments`, { body: 'e2e 删除前的评论' });
@@ -181,9 +176,10 @@ test('delete: refused once a run succeeded or while one waits; a cancelled attem
assert.equal(waiting.issue.deletionBlock?.code, 'active');
assert.equal(waiting.issue.deletionBlock?.runId, doomed.runId);
assert.match(waiting.issue.deletionBlock.reason, /未结束的运行/);
- const busy = await api('DELETE', `/api/issues/${doomed.id}`, undefined, { expect: 409 });
+ const busy = await api('DELETE', `/api/issues/${doomed.id}?force=true`, undefined, { expect: 409 });
assert.equal(busy.error, waiting.issue.deletionBlock.reason);
assert.equal(busy.deletionBlock?.runId, doomed.runId);
+ assert.notEqual(busy.deletionRequiresForce, true);
assert.equal((await get(`/api/issues/${doomed.id}`)).issue.id, doomed.id);
await post(`/api/runs/${doomed.runId}/cancel`, {});
@@ -192,7 +188,7 @@ test('delete: refused once a run succeeded or while one waits; a cancelled attem
// always lists before offering 删除 (see the todo below for the bare API).
await waitFor('requirement deletable', async () => {
await get(`/api/issues?projectId=${P}`);
- return (await api('DELETE', `/api/issues/${doomed.id}`, undefined, { expect: [204, 409], raw: true })).status === 204 || null;
+ return (await api('DELETE', `/api/issues/${doomed.id}?force=true`, undefined, { expect: [204, 409], raw: true })).status === 204 || null;
}, { timeoutMs: 30_000 });
await api('GET', `/api/issues/${doomed.id}`, undefined, { expect: 404 });
await api('DELETE', `/api/issues/${doomed.id}`, undefined, { expect: 404 });
@@ -206,5 +202,5 @@ test('delete right after the run is cancelled, without listing issues first', as
const doomed = await waitingIssue('issue-delete-now');
await post(`/api/runs/${doomed.runId}/cancel`, {});
await waitRun(doomed.runId, r => r.status === 'cancelled', { label: 'cancelled' });
- await api('DELETE', `/api/issues/${doomed.id}`, undefined, { expect: 204 });
+ await api('DELETE', `/api/issues/${doomed.id}?force=true`, undefined, { expect: 204 });
});
diff --git a/internal/application/operations.go b/internal/application/operations.go
index 548bdc02..d68b3dd3 100644
--- a/internal/application/operations.go
+++ b/internal/application/operations.go
@@ -37,7 +37,7 @@ func PublicOperations() []Operation {
{Name: "issues_list", Description: "List issues and requirements. Query: projectId, status, source, q, limit, offset. Omit limit to get Issue[]; with limit returns {items,total,offset,limit,hasMore} (max 200).", Method: "GET", Path: "/api/issues", ReadOnly: true},
{Name: "issues_save", Description: "Create or update an issue or requirement", Method: "PUT", Path: "/api/issues"},
{Name: "issues_get", Description: "Get one issue and its comments", Method: "GET", Path: "/api/issues/{id}", ReadOnly: true},
- {Name: "issues_delete", Description: "Delete a local issue and failed/cancelled execution history; reject successful or active runs", Method: "DELETE", Path: "/api/issues/{id}"},
+ {Name: "issues_delete", Description: "Delete a local issue. Query force=true also deletes settled execution history, including successful runs, and is required for issues with history or a completed status. Active work blocks deletion.", Method: "DELETE", Path: "/api/issues/{id}"},
{Name: "issues_comments_add", Description: "Add a comment to an issue", Method: "POST", Path: "/api/issues/{id}/comments"},
{Name: "issues_runs_list", Description: "List runs belonging to an issue", Method: "GET", Path: "/api/issues/{id}/runs", ReadOnly: true},
{Name: "issues_chat_clarify", Description: "Run AI clarification for an existing issue. The job keeps running after the client disconnects; GET the same path with Accept: text/event-stream to resume SSE.", Method: "POST", Path: "/api/issues/{id}/chat-clarify"},
diff --git a/internal/engine/delete_run_test.go b/internal/engine/delete_run_test.go
index ea0b4877..7a75074c 100644
--- a/internal/engine/delete_run_test.go
+++ b/internal/engine/delete_run_test.go
@@ -4,6 +4,7 @@ import (
"context"
"os"
"path/filepath"
+ "strings"
"testing"
"agentflow/internal/domain"
@@ -66,6 +67,33 @@ func TestDeleteFailedRunDestroysLocalWorkspace(t *testing.T) {
}
}
+func TestDeleteRunRefusesTerminalRunWithUnfinishedNode(t *testing.T) {
+ t.Parallel()
+ for _, nodeStatus := range []string{"running", "pending_input"} {
+ t.Run(nodeStatus, func(t *testing.T) {
+ st, err := repo.OpenTest()
+ if err != nil {
+ t.Fatal(err)
+ }
+ t.Cleanup(st.Close)
+ e := New(st, runtime.NewManager(t.TempDir()))
+ run := domain.Run{ID: "failed-with-" + nodeStatus, Status: "failed", Nodes: map[string]*domain.NodeRun{
+ "done": {Status: "succeeded"},
+ "busy": {Status: nodeStatus},
+ }}
+ if err := st.PutRun(run); err != nil {
+ t.Fatal(err)
+ }
+ if err := e.DeleteRun(run.ID); err == nil || !strings.Contains(err.Error(), "仍有未结束的节点") {
+ t.Fatalf("DeleteRun error = %v, want unfinished node refusal", err)
+ }
+ if _, ok := st.Run(run.ID); !ok {
+ t.Fatal("run with an unfinished node was deleted")
+ }
+ })
+ }
+}
+
func TestDeleteRunPreservesTerminalTaskOutcome(t *testing.T) {
t.Parallel()
for _, tc := range []struct {
diff --git a/internal/engine/workspace_cleanup.go b/internal/engine/workspace_cleanup.go
index 56187dfd..047659d5 100644
--- a/internal/engine/workspace_cleanup.go
+++ b/internal/engine/workspace_cleanup.go
@@ -314,6 +314,9 @@ func (e *Engine) DeleteRun(runID string) error {
if run.Status == "running" || run.Status == "waiting" || run.Status == "queued" {
return fmt.Errorf("run %s is %s: cancel it before deleting", runID, run.Status)
}
+ if hasRunningNode(run) {
+ return fmt.Errorf("运行 %s 仍有未结束的节点,请先停止后再删除", runID)
+ }
token, err := e.beginWorkspaceUseAfterCleanup(context.Background(), runID)
if err != nil {
return err
@@ -358,8 +361,7 @@ func (e *Engine) settleDeletedRunTasks(run domain.Run) error {
if task.Status == status {
continue
}
- task.Status = status
- if err := e.repo.PutTask(task); err != nil {
+ if err := e.repo.UpdateTaskStatus(task, status); err != nil {
return fmt.Errorf("settle task %s before deleting run %s: %w", task.ID, run.ID, err)
}
}
diff --git a/internal/httpapi/assistant_conversation_cleanup.go b/internal/httpapi/assistant_conversation_cleanup.go
index ff71fb14..9eaa364b 100644
--- a/internal/httpapi/assistant_conversation_cleanup.go
+++ b/internal/httpapi/assistant_conversation_cleanup.go
@@ -5,6 +5,7 @@ import (
"strings"
"agentflow/internal/domain"
+ "agentflow/internal/repo"
)
// deleteConversation deletes a conversation together with what it left
@@ -98,7 +99,7 @@ func (h *assistantHandlers) deleteConversationIssue(issue domain.Issue) {
}
return
}
- runIDs, err := h.repo.IssueDeletionRuns(issue.ID)
+ runIDs, err := h.repo.IssueDeletionRuns(issue.ID, repo.IssueDeleteUnsuccessful)
if err != nil {
log.Printf("keep requirement %s of a deleted conversation: %v", issue.ID, err)
return
diff --git a/internal/httpapi/dispatch.go b/internal/httpapi/dispatch.go
index 0e9cd6e7..040a767e 100644
--- a/internal/httpapi/dispatch.go
+++ b/internal/httpapi/dispatch.go
@@ -2,6 +2,7 @@ package httpapi
import (
"crypto/sha256"
+ "errors"
"fmt"
"net/http"
"strings"
@@ -30,8 +31,16 @@ func dispatchIssue(d *deps, req dispatchRequest) (domain.Task, error) {
return domain.Task{}, HTTPError{http.StatusConflict, err.Error()}
}
if issue.AssigneeUserID == 0 {
- issue.AssigneeUserID = responsible.ID
- if err := d.repo.PutIssue(issue); err != nil {
+ issue, err = d.repo.PatchIssue(issue.ID, func(current *domain.Issue) error {
+ if current.AssigneeUserID == 0 {
+ current.AssigneeUserID = responsible.ID
+ }
+ return nil
+ })
+ if err != nil {
+ if errors.Is(err, repo.ErrIssueNotFound) {
+ return domain.Task{}, HTTPError{http.StatusNotFound, err.Error()}
+ }
return domain.Task{}, err
}
}
@@ -172,8 +181,11 @@ func dispatchIssue(d *deps, req dispatchRequest) (domain.Task, error) {
displayRepository = repositories[0]
}
task := domain.Task{ID: taskID, IssueID: issue.ID, AgentID: issue.AssigneeID, WorkflowID: workflowID, Status: "queued", Repository: displayRepository, DispatchMode: dispatchMode, ScheduleJobID: strings.TrimSpace(req.ScheduleJobID), TriggerOrigin: triggerOrigin}
- stored, created, err := d.repo.CreateTask(task)
+ stored, created, err := d.repo.ReserveIssueDispatch(task)
if err != nil {
+ if errors.Is(err, repo.ErrIssueNotFound) {
+ return domain.Task{}, HTTPError{http.StatusNotFound, err.Error()}
+ }
return domain.Task{}, err
}
if !created {
diff --git a/internal/httpapi/dispatch_domains_cases_test.go b/internal/httpapi/dispatch_domains_cases_test.go
index 0ac93f9b..e2ecbf89 100644
--- a/internal/httpapi/dispatch_domains_cases_test.go
+++ b/internal/httpapi/dispatch_domains_cases_test.go
@@ -37,6 +37,28 @@ func TestDispatchEarlyErrorsAndHandoff(t *testing.T) {
if _, err := dispatchIssue(d, dispatchRequest{IssueID: invalidRepo.ID}); cvBHTTPStatusRound2(err) != http.StatusBadRequest {
t.Fatalf("invalid repository = %v", err)
}
+ // 存量需求没有责任人(保存与项目设 Owner 都会回填,这里直接清空列模拟旧数据):
+ // 派发时按项目 Owner 回填责任人(PatchIssue 写回已存在的行)。
+ if err := f.s.PutProject(domain.Project{ID: "cvb-r2-owned", Name: "Owned", OwnerID: f.user.ID}); err != nil {
+ t.Fatal(err)
+ }
+ unassigned := domain.Issue{ID: "cvb-r2-unassigned", ProjectID: "cvb-r2-owned", Title: "Unassigned", Status: "todo",
+ Kind: "bug", WorkflowID: "default", RepositoryIDs: []string{"missing"}}
+ if err := f.s.PutIssue(unassigned); err != nil {
+ t.Fatal(err)
+ }
+ if err := f.s.DB.Table("issues").Where("id = ?", unassigned.ID).Update("assignee_user_id", nil).Error; err != nil {
+ t.Fatal(err)
+ }
+ if stored, _ := f.s.Issue(unassigned.ID); stored.AssigneeUserID != 0 {
+ t.Fatalf("precondition: legacy issue assignee = %d", stored.AssigneeUserID)
+ }
+ if _, err := dispatchIssue(d, dispatchRequest{IssueID: unassigned.ID}); cvBHTTPStatusRound2(err) != http.StatusBadRequest {
+ t.Fatalf("unassigned issue with invalid repository = %v", err)
+ }
+ if stored, ok := f.s.Issue(unassigned.ID); !ok || stored.AssigneeUserID != f.user.ID {
+ t.Fatalf("dispatch assignee = %+v (found=%v), want project owner %d", stored.AssigneeUserID, ok, f.user.ID)
+ }
rerun := invalidRepo
rerun.ID, rerun.RepositoryIDs = "cvb-r2-rerun", nil
if err := f.s.PutIssue(rerun); err != nil {
diff --git a/internal/httpapi/issue_deletion_view.go b/internal/httpapi/issue_deletion_view.go
index 786f10b2..73fda2e8 100644
--- a/internal/httpapi/issue_deletion_view.go
+++ b/internal/httpapi/issue_deletion_view.go
@@ -9,17 +9,14 @@ import (
type issueDeletionView struct {
domain.Issue
- DeletionAllowed bool `json:"deletionAllowed"`
- DeletionBlock *repo.IssueDeletionBlock `json:"deletionBlock,omitempty"`
- ClosureAllowed bool `json:"closureAllowed"`
+ DeletionAllowed bool `json:"deletionAllowed"`
+ DeletionRequiresForce bool `json:"deletionRequiresForce,omitempty"`
+ DeletionBlock *repo.IssueDeletionBlock `json:"deletionBlock,omitempty"`
+ ClosureAllowed bool `json:"closureAllowed"`
}
func (h issuesHandlers) issueDeletionViews(issues []domain.Issue) ([]issueDeletionView, error) {
- blocks, err := h.repo.IssueDeletionBlocks(issues)
- if err != nil {
- return nil, err
- }
- closed, err := h.repo.IssueClosureAllowed(issues)
+ states, err := h.repo.IssueDeletionStates(issues)
if err != nil {
return nil, err
}
@@ -28,12 +25,14 @@ func (h issuesHandlers) issueDeletionViews(issues []domain.Issue) ([]issueDeleti
}
out := make([]issueDeletionView, 0, len(issues))
for _, issue := range issues {
- view := issueDeletionView{Issue: issue, DeletionAllowed: true, ClosureAllowed: closed[issue.ID]}
- if block, ok := blocks[issue.ID]; ok {
- view.DeletionAllowed = false
- view.DeletionBlock = &block
- }
- out = append(out, view)
+ state := states[issue.ID]
+ out = append(out, issueDeletionView{
+ Issue: issue,
+ DeletionAllowed: state.Block == nil,
+ DeletionRequiresForce: state.RequiresForce(),
+ DeletionBlock: state.Block,
+ ClosureAllowed: state.Block == nil,
+ })
}
return out, nil
}
diff --git a/internal/httpapi/issue_routes.go b/internal/httpapi/issue_routes.go
index 9019e21d..9b270cd6 100644
--- a/internal/httpapi/issue_routes.go
+++ b/internal/httpapi/issue_routes.go
@@ -327,14 +327,18 @@ func (h issuesHandlers) dispatchIssueRoute(c *gin.Context, issue domain.Issue) {
c.JSON(201, publicTask(task))
}
-// deleteIssue checks the complete history before cleaning failed/cancelled runs.
+// deleteIssue checks all execution history before cleaning any settled run.
func (h issuesHandlers) deleteIssue(c *gin.Context, issue domain.Issue) {
+ mode := repo.IssueDeleteNormal
+ if c.Query("force") == "true" {
+ mode = repo.IssueDeleteForce
+ }
// Same as close: Task status trails a just-cancelled Run until the next
// sync, which would answer 409 "正在执行 SOP" for a stopped requirement.
if h.tasks != nil {
h.tasks.settleIssueTasks(issue.ID)
}
- ids, err := h.repo.IssueDeletionRuns(issue.ID)
+ ids, err := h.repo.IssueDeletionRuns(issue.ID, mode)
if err == nil {
for _, id := range ids {
if err = h.engine.DeleteRun(id); err != nil {
@@ -343,17 +347,21 @@ func (h issuesHandlers) deleteIssue(c *gin.Context, issue domain.Issue) {
}
}
if err == nil {
- err = h.repo.DeleteIssue(issue.ID)
+ err = h.repo.DeleteIssueAfterRunCleanup(issue.ID, mode)
}
if err != nil {
switch {
- case errors.Is(err, repo.ErrIssueBusy), errors.Is(err, repo.ErrIssueSucceeded):
+ case errors.Is(err, repo.ErrIssueForceRequired):
+ c.JSON(http.StatusConflict, gin.H{"error": err.Error(), "deletionRequiresForce": true})
+ case errors.Is(err, repo.ErrIssueBusy):
// Report the same concrete reason shown by list/detail affordances,
// including when execution history changed after the menu was opened.
- if blocks, checkErr := h.repo.IssueDeletionBlocks([]domain.Issue{issue}); checkErr == nil {
- if block, ok := blocks[issue.ID]; ok {
- c.JSON(http.StatusConflict, gin.H{"error": block.Reason, "deletionBlock": block})
- return
+ if current, ok := h.repo.Issue(issue.ID); ok {
+ if states, checkErr := h.repo.IssueDeletionStates([]domain.Issue{current}); checkErr == nil {
+ if block := states[issue.ID].Block; block != nil {
+ c.JSON(http.StatusConflict, gin.H{"error": block.Reason, "deletionBlock": block})
+ return
+ }
}
}
c.JSON(http.StatusConflict, gin.H{"error": err.Error()})
diff --git a/internal/httpapi/issues_close_test.go b/internal/httpapi/issues_close_test.go
index fe52c3dc..fc46f503 100644
--- a/internal/httpapi/issues_close_test.go
+++ b/internal/httpapi/issues_close_test.go
@@ -238,7 +238,7 @@ func TestDeleteIssueSeesRunThatWasJustCancelled(t *testing.T) {
if err := st.PutRun(domain.Run{ID: "delete-after-cancel-run", Status: "cancelled"}); err != nil {
t.Fatal(err)
}
- req := httptest.NewRequest(http.MethodDelete, "/api/issues/delete-after-cancel", nil)
+ req := httptest.NewRequest(http.MethodDelete, "/api/issues/delete-after-cancel?force=true", nil)
rec := httptest.NewRecorder()
h.ServeHTTP(rec, req)
if rec.Code != http.StatusNoContent {
diff --git a/internal/httpapi/issues_delete_test.go b/internal/httpapi/issues_delete_test.go
index 3c5f7ae1..a3dcd0f9 100644
--- a/internal/httpapi/issues_delete_test.go
+++ b/internal/httpapi/issues_delete_test.go
@@ -1,16 +1,17 @@
package httpapi
import (
+ "net/http"
+ "net/http/httptest"
+ "os"
+ "path/filepath"
+ "testing"
+
"agentflow/internal/domain"
"agentflow/internal/engine"
"agentflow/internal/repo"
"agentflow/internal/runtime"
"agentflow/internal/tracker"
- "net/http"
- "net/http/httptest"
- "path/filepath"
- "strings"
- "testing"
)
func TestDeleteIssueEndpoint(t *testing.T) {
@@ -20,103 +21,148 @@ func TestDeleteIssueEndpoint(t *testing.T) {
}
defer st.Close()
h := New(st, engine.New(st, runtime.NewManager(filepath.Join(t.TempDir(), "ws"))), tracker.NewService(), "", "")
- for _, analyzing := range []bool{true, false} {
- issue := domain.Issue{ID: "delete-api", ProjectID: "platform", Title: "delete", Status: "backlog"}
- if analyzing {
- issue.Clarification.Status = "analyzing"
- }
- if err := st.PutIssue(issue); err != nil {
- t.Fatal(err)
- }
- rr := httptest.NewRecorder()
- h.ServeHTTP(rr, httptest.NewRequest(http.MethodDelete, "/api/issues/delete-api", nil))
- expected := http.StatusNoContent
- if analyzing {
- expected = http.StatusConflict
- }
- if rr.Code != expected {
- t.Fatalf("status=%d body=%s", rr.Code, rr.Body.String())
+ issue := domain.Issue{ID: "delete-api", ProjectID: "platform", Title: "delete", Status: "backlog"}
+ issue.Clarification.Status = "analyzing"
+ if err := st.PutIssue(issue); err != nil {
+ t.Fatal(err)
+ }
+ for _, query := range []string{"", "?force=true"} {
+ conflict := requestEmptyJSON[struct {
+ Block *repo.IssueDeletionBlock `json:"deletionBlock"`
+ }](t, h, http.MethodDelete, "/api/issues/delete-api"+query, http.StatusConflict)
+ if conflict.Block == nil || conflict.Block.Code != "clarifying" {
+ t.Fatalf("missing clarification block: %+v", conflict)
}
}
- rr := httptest.NewRecorder()
- h.ServeHTTP(rr, httptest.NewRequest(http.MethodGet, "/api/issues/delete-api", nil))
- if rr.Code != http.StatusNotFound {
- t.Fatalf("deleted issue GET=%d", rr.Code)
+ issue.Clarification.Status = ""
+ if err := st.PutIssue(issue); err != nil {
+ t.Fatal(err)
+ }
+ rec := httptest.NewRecorder()
+ h.ServeHTTP(rec, httptest.NewRequest(http.MethodDelete, "/api/issues/delete-api", nil))
+ if rec.Code != http.StatusNoContent {
+ t.Fatalf("status=%d body=%s", rec.Code, rec.Body.String())
}
+ requestEmptyJSON[map[string]string](t, h, http.MethodGet, "/api/issues/delete-api", http.StatusNotFound)
}
func TestDeleteIssueExecutionHistory(t *testing.T) {
- for _, success := range []bool{false, true} {
- t.Run(map[bool]string{false: "cascade", true: "success blocks all cleanup"}[success], func(t *testing.T) {
+ for _, withSuccess := range []bool{false, true} {
+ t.Run(map[bool]string{false: "failed and cancelled", true: "including success"}[withSuccess], func(t *testing.T) {
st, err := repo.OpenTest()
if err != nil {
t.Fatal(err)
}
defer st.Close()
- h := New(st, engine.New(st, runtime.NewManager(filepath.Join(t.TempDir(), "ws"))), tracker.NewService(), "", "")
- if err := st.PutIssue(domain.Issue{ID: "history", ProjectID: "platform", Title: "history", Status: "backlog"}); err != nil {
+ sandboxes := runtime.NewManager(filepath.Join(t.TempDir(), "ws"))
+ h := New(st, engine.New(st, sandboxes), tracker.NewService(), "", "")
+ const issueID, path = "force-delete-history", "/api/issues/force-delete-history"
+ issue := domain.Issue{ID: issueID, ProjectID: "platform", Title: "history", Status: "backlog"}
+ issue.Clarification.Summary = "summary"
+ if err := st.PutIssue(issue); err != nil {
+ t.Fatal(err)
+ }
+ if err := st.PutComment(domain.IssueComment{ID: issueID + "-comment", IssueID: issueID, Body: "comment"}); err != nil {
t.Fatal(err)
}
statuses := []string{"failed", "cancelled"}
- if success {
+ if withSuccess {
statuses = append(statuses, "succeeded")
}
+ runIDs := make([]string, 0, len(statuses))
for _, status := range statuses {
- if err := st.PutTask(domain.Task{ID: status, IssueID: "history", RunID: status, Status: status}); err != nil {
+ id := issueID + "-" + status
+ runIDs = append(runIDs, id)
+ if err := st.PutTask(domain.Task{ID: id, IssueID: issueID, RunID: id, Status: taskStatusFromRun(status)}); err != nil {
t.Fatal(err)
}
- // The cancelled run has no issue context: deletion must find it via its Task.
- ctx := domain.TelemetryContext{IssueID: "history", TaskID: status}
+ ctx := domain.TelemetryContext{IssueID: issueID, TaskID: id}
if status == "cancelled" {
- ctx.IssueID = ""
+ ctx.IssueID = "" // legacy task-linked run
+ }
+ if err := st.PutRun(domain.Run{
+ ID: id, Status: status, ExecutionContext: ctx,
+ Nodes: map[string]*domain.NodeRun{"work": {NodeID: "work", Status: status}},
+ Logs: []domain.LogRecord{{ID: id + "-log", Sequence: 1, Body: "log"}},
+ Events: []domain.RunEvent{{ID: id + "-event", RunID: id, Type: "test"}},
+ Artifacts: []domain.Artifact{{ID: id + "-artifact", RunID: id, Name: "test.txt", Content: "artifact"}},
+ }); err != nil {
+ t.Fatal(err)
}
- if err := st.PutRun(domain.Run{ID: status, Status: status, ExecutionContext: ctx, Nodes: map[string]*domain.NodeRun{"work": {NodeID: "work", Status: status}}, Logs: []domain.LogRecord{{ID: status + "-log", Body: "log"}}, Events: []domain.RunEvent{{ID: status + "-event", RunID: status, Type: "test"}}, Artifacts: []domain.Artifact{{ID: status + "-artifact", RunID: status, Name: "test.txt", Content: "artifact"}}}); err != nil {
+ if err := os.MkdirAll(sandboxes.RunWorkspace(id), 0700); err != nil {
t.Fatal(err)
}
}
- detail := requestJSON[struct {
+ const unrelatedRun = "unrelated-to-force-delete"
+ if err := st.PutRun(domain.Run{ID: unrelatedRun, Status: "succeeded", ExecutionContext: domain.TelemetryContext{IssueID: "other"}}); err != nil {
+ t.Fatal(err)
+ }
+ detail := requestEmptyJSON[struct {
Issue issueDeletionView `json:"issue"`
- }](t, h, http.MethodGet, "/api/issues/history", nil, http.StatusOK)
- list := requestJSON[[]issueDeletionView](t, h, http.MethodGet, "/api/issues", nil, http.StatusOK)
- if detail.Issue.DeletionAllowed == success || len(list) != 1 || list[0].DeletionAllowed == success {
- t.Fatal("incorrect deletion affordance")
- }
- if success {
- for _, view := range []issueDeletionView{detail.Issue, list[0]} {
- if view.DeletionBlock == nil || view.DeletionBlock.Code != "succeeded" || view.DeletionBlock.RunID != "succeeded" {
- t.Fatalf("missing deletion reason/destination: %+v", view.DeletionBlock)
- }
+ }](t, h, http.MethodGet, path, http.StatusOK)
+ list := requestEmptyJSON[[]issueDeletionView](t, h, http.MethodGet, "/api/issues", http.StatusOK)
+ if len(list) != 1 {
+ t.Fatalf("incorrect issue list: %+v", list)
+ }
+ for _, view := range []issueDeletionView{detail.Issue, list[0]} {
+ if !view.DeletionAllowed || !view.DeletionRequiresForce || view.DeletionBlock != nil {
+ t.Fatalf("incorrect deletion affordance: %+v", view)
+ }
+ }
+ conflict := requestEmptyJSON[struct {
+ RequiresForce bool `json:"deletionRequiresForce"`
+ }](t, h, http.MethodDelete, path, http.StatusConflict)
+ if !conflict.RequiresForce {
+ t.Fatal("missing force confirmation requirement")
+ }
+ const waitingRun = "force-delete-history-waiting"
+ if err := st.PutRun(domain.Run{ID: waitingRun, Status: "waiting", ExecutionContext: domain.TelemetryContext{IssueID: issueID}}); err != nil {
+ t.Fatal(err)
+ }
+ busy := requestEmptyJSON[struct {
+ Block *repo.IssueDeletionBlock `json:"deletionBlock"`
+ }](t, h, http.MethodDelete, path+"?force=true", http.StatusConflict)
+ if busy.Block == nil || busy.Block.RunID != waitingRun {
+ t.Fatalf("missing active run conflict: %+v", busy)
+ }
+ for _, id := range runIDs {
+ _, hasRun := st.Run(id)
+ _, hasTask := st.Task(id)
+ _, err := os.Stat(sandboxes.RunWorkspace(id))
+ if !hasRun || !hasTask || err != nil {
+ t.Fatalf("conflict removed history for %s: run=%v task=%v workspace=%v", id, hasRun, hasTask, err)
}
- } else if detail.Issue.DeletionBlock != nil || list[0].DeletionBlock != nil {
- t.Fatal("deletable issue has a stale block")
}
- rr := httptest.NewRecorder()
- h.ServeHTTP(rr, httptest.NewRequest(http.MethodDelete, "/api/issues/history", nil))
- expected := http.StatusNoContent
- if success {
- expected = http.StatusConflict
+ if err := st.PutRun(domain.Run{ID: waitingRun, Status: "cancelled", ExecutionContext: domain.TelemetryContext{IssueID: issueID}}); err != nil {
+ t.Fatal(err)
}
- if rr.Code != expected {
- t.Fatalf("status %d: %s", rr.Code, rr.Body.String())
+ runIDs = append(runIDs, waitingRun)
+ rec := httptest.NewRecorder()
+ h.ServeHTTP(rec, httptest.NewRequest(http.MethodDelete, path+"?force=true", nil))
+ if rec.Code != http.StatusNoContent {
+ t.Fatalf("status %d: %s", rec.Code, rec.Body.String())
}
- if success && !strings.Contains(rr.Body.String(), detail.Issue.DeletionBlock.Reason) {
- t.Fatalf("delete conflict disagrees with list/detail: %s", rr.Body.String())
+ requestEmptyJSON[map[string]string](t, h, http.MethodGet, path, http.StatusNotFound)
+ if comments := st.Comments(issueID); len(comments) != 0 {
+ t.Fatalf("remaining comments: %+v", comments)
}
- for _, status := range statuses {
- _, runExists := st.Run(status)
- _, taskExists := st.Task(status)
- if runExists != success || taskExists != success {
- t.Fatalf("unexpected remaining history: run=%v task=%v", runExists, taskExists)
+ for _, id := range runIDs {
+ _, hasRun := st.Run(id)
+ _, hasTask := st.Task(id)
+ _, err := os.Stat(sandboxes.RunWorkspace(id))
+ if hasRun || hasTask || !os.IsNotExist(err) {
+ t.Fatalf("remaining history for %s: run=%v task=%v workspace=%v", id, hasRun, hasTask, err)
}
}
- if !success {
- for _, table := range []string{"run_nodes", "run_events", "run_telemetry", "run_logs", "run_artifacts", "run_evals"} {
- var n int64
- if err := st.DB.Table(table).Count(&n).Error; err != nil || n != 0 {
- t.Fatalf("remaining %s: %d %v", table, n, err)
- }
+ for _, table := range []string{"run_nodes", "run_events", "run_telemetry", "run_logs", "run_artifacts", "run_evals"} {
+ var n int64
+ if err := st.DB.Table(table).Where("run_id IN ?", runIDs).Count(&n).Error; err != nil || n != 0 {
+ t.Fatalf("remaining %s: %d %v", table, n, err)
}
}
+ if _, ok := st.Run(unrelatedRun); !ok {
+ t.Fatal("force deleted an unrelated run")
+ }
})
}
}
diff --git a/internal/httpapi/tasks.go b/internal/httpapi/tasks.go
index 1af3a998..59bbce78 100644
--- a/internal/httpapi/tasks.go
+++ b/internal/httpapi/tasks.go
@@ -59,8 +59,7 @@ func (h *tasksHandlers) settleIssueTasks(issueID string) {
if (status != "completed" && status != "failed" && status != "cancelled") || status == task.Status {
continue
}
- task.Status = status
- _ = h.repo.PutTask(task)
+ _ = h.repo.UpdateTaskStatus(task, status)
}
}
@@ -85,9 +84,8 @@ func (h *tasksHandlers) syncTasks() {
// run that can never appear. A non-empty missing RunID is terminal;
// converge active task states so the issue can be dispatched again.
if strings.TrimSpace(task.RunID) != "" && (task.Status == "queued" || task.Status == "dispatched" || task.Status == "running") {
- task.Status = "cancelled"
- _ = h.repo.PutTask(task)
- tasks[i] = task
+ _ = h.repo.UpdateTaskStatus(task, "cancelled")
+ tasks[i].Status = "cancelled"
}
continue
}
@@ -98,9 +96,8 @@ func (h *tasksHandlers) syncTasks() {
if status == "" || status == task.Status {
continue
}
- task.Status = status
- _ = h.repo.PutTask(task)
- tasks[i] = task
+ _ = h.repo.UpdateTaskStatus(task, status)
+ tasks[i].Status = status
}
latest := map[string]domain.Task{}
for _, task := range tasks {
@@ -123,7 +120,11 @@ func (h *tasksHandlers) syncTasks() {
if next.LatestTaskID == issue.LatestTaskID && next.Status == issue.Status {
continue
}
- _ = h.repo.PutIssue(next)
+ _, _ = h.repo.PatchIssue(issue.ID, func(current *domain.Issue) error {
+ current.LatestTaskID = task.ID
+ current.Status = issueStatusFromLatestTask(*current, task.Status)
+ return nil
+ })
}
}
diff --git a/internal/repo/issues.go b/internal/repo/issues.go
index 5b6fbe33..db9f45c2 100644
--- a/internal/repo/issues.go
+++ b/internal/repo/issues.go
@@ -8,6 +8,8 @@ import (
"time"
"agentflow/internal/domain"
+
+ "gorm.io/gorm"
)
// ---------- Issues ----------
@@ -166,13 +168,36 @@ func (r *IssuesRepo) PutIssue(v domain.Issue) error {
return r.putIssueLocked(v)
}
+// ReserveIssueDispatch holds the issue row lock through task reservation so
+// dispatch and the final delete cannot both succeed.
+func (r *IssuesRepo) ReserveIssueDispatch(task domain.Task) (domain.Task, bool, error) {
+ var stored domain.Task
+ var created bool
+ err := r.DB.Transaction(func(tx *gorm.DB) error {
+ var issue issueRow
+ err := r.locking(tx).Select("id").Where("id = ?", task.IssueID).Take(&issue).Error
+ if errors.Is(err, gorm.ErrRecordNotFound) {
+ return ErrIssueNotFound
+ }
+ if err != nil {
+ return err
+ }
+ stored, created, err = r.tasks.createTask(tx, task)
+ return err
+ })
+ if err != nil {
+ return domain.Task{}, false, err
+ }
+ return stored, created, nil
+}
+
// PutSyncedIssue refreshes tracker data without changing an existing issue's
// local lifecycle. Reload under the write lock so an edit made after the
// tracker snapshot was read is preserved too.
func (r *IssuesRepo) PutSyncedIssue(v domain.Issue) error {
r.mu.Lock()
defer r.mu.Unlock()
- return r.saveIssueLocked(v, true)
+ return r.saveIssueLocked(v, true, false)
}
// PatchIssue loads the current row, applies fn, and writes it back under the
@@ -189,12 +214,12 @@ func (r *IssuesRepo) PatchIssue(id string, fn func(*domain.Issue) error) (domain
defer r.mu.Unlock()
issue, ok := r.Issue(id)
if !ok {
- return domain.Issue{}, errors.New("issue not found")
+ return domain.Issue{}, ErrIssueNotFound
}
if err := fn(&issue); err != nil {
return issue, err
}
- if err := r.putIssueLocked(issue); err != nil {
+ if err := r.saveIssueLocked(issue, false, true); err != nil {
return issue, err
}
stored, ok := r.Issue(id)
@@ -205,12 +230,15 @@ func (r *IssuesRepo) PatchIssue(id string, fn func(*domain.Issue) error) (domain
}
func (r *IssuesRepo) putIssueLocked(v domain.Issue) error {
- return r.saveIssueLocked(v, false)
+ return r.saveIssueLocked(v, false, false)
}
-func (r *IssuesRepo) saveIssueLocked(v domain.Issue, fromSync bool) error {
+func (r *IssuesRepo) saveIssueLocked(v domain.Issue, fromSync, existingOnly bool) error {
now := time.Now().UTC()
old, ok := r.Issue(v.ID)
+ if existingOnly && !ok {
+ return ErrIssueNotFound
+ }
preserveStatus := fromSync && ok
if ok {
if preserveStatus {
@@ -290,10 +318,21 @@ func (r *IssuesRepo) saveIssueLocked(v domain.Issue, fromSync bool) error {
}
bindDefaultWorkflow(&v, r.projectWorkflowID(v.ProjectID), r.projectIssueWorkflowID(v.ProjectID))
v.UpdatedAt = now
+ if existingOnly {
+ result := r.DB.Model(&issueRow{}).Where("id = ?", v.ID).Updates(issueValues(v))
+ if result.Error == nil && result.RowsAffected == 0 {
+ return ErrIssueNotFound
+ }
+ return result.Error
+ }
return r.writeIssue(v)
}
func (r *IssuesRepo) writeIssue(v domain.Issue) error {
+ return upsert(r.DB, "issues", issueValues(v))
+}
+
+func issueValues(v domain.Issue) map[string]any {
ext := ""
if v.ExternalRef != nil {
ext = v.ExternalRef.ExternalID
@@ -302,12 +341,12 @@ func (r *IssuesRepo) writeIssue(v domain.Issue) error {
if v.AssigneeUserID > 0 {
assignee = v.AssigneeUserID
}
- return upsert(r.DB, "issues", map[string]any{
+ return map[string]any{
"id": v.ID, "project_id": v.ProjectID, "number": v.Number, "title": v.Title,
"status": v.Status, "kind": v.Kind, "source": v.Source, "workflow_id": v.WorkflowID,
"assignee_user_id": assignee, "external_id": ext, "payload": mustJSON(v),
"created_at": timePtr(v.CreatedAt), "updated_at": timePtr(v.UpdatedAt),
- })
+ }
}
// ResponsibleUser resolves the explicit issue responsibility first and falls
diff --git a/internal/repo/issues_delete.go b/internal/repo/issues_delete.go
index adaa0148..15a15d0e 100644
--- a/internal/repo/issues_delete.go
+++ b/internal/repo/issues_delete.go
@@ -1,28 +1,40 @@
package repo
import (
- "agentflow/internal/domain"
"errors"
"fmt"
+
+ "agentflow/internal/domain"
+
"gorm.io/gorm"
)
var ErrIssueBusy = errors.New("需求正在澄清或执行 SOP,请先停止后再删除")
var ErrIssueSucceeded = errors.New("需求已有成功运行记录,不允许删除")
+var ErrIssueForceRequired = errors.New("需求已有执行记录或已完成,请确认强制删除")
var ErrIssueNotFound = errors.New("issue not found")
+type IssueDeletionMode int
+
+const (
+ IssueDeleteNormal IssueDeletionMode = iota
+ IssueDeleteForce
+ // IssueDeleteUnsuccessful preserves the cleanup policy of internal callers.
+ IssueDeleteUnsuccessful
+)
+
// IssueDeletionRuns checks every linked run before any destructive cleanup.
-func (r *IssuesRepo) IssueDeletionRuns(id string) ([]string, error) {
+func (r *IssuesRepo) IssueDeletionRuns(id string, mode IssueDeletionMode) ([]string, error) {
var ids []string
err := r.DB.Transaction(func(tx *gorm.DB) error {
var err error
- ids, err = r.issueDeletionRuns(tx, id)
+ ids, err = r.issueDeletionRuns(tx, id, mode)
return err
})
return ids, err
}
-func (r *IssuesRepo) issueDeletionRuns(tx *gorm.DB, id string) ([]string, error) {
+func (r *IssuesRepo) issueDeletionRuns(tx *gorm.DB, id string, mode IssueDeletionMode) ([]string, error) {
var row issueRow
if err := r.locking(tx.Where("id = ?", id)).Take(&row).Error; err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
@@ -34,56 +46,35 @@ func (r *IssuesRepo) issueDeletionRuns(tx *gorm.DB, id string) ([]string, error)
if err := jsonUnmarshal(row.Payload, &issue); err != nil {
return nil, err
}
- if issue.Status == "done" {
- return nil, ErrIssueSucceeded
- }
- if issue.Clarification.Status == "analyzing" {
- return nil, ErrIssueBusy
- }
- var tasks []taskRow
- if err := tx.Where("issue_id = ?", id).Find(&tasks).Error; err != nil {
+ states, err := r.issueDeletionStates(tx, []domain.Issue{issue})
+ if err != nil {
return nil, err
}
- for _, task := range tasks {
- if task.Status == "completed" || task.Status == "succeeded" {
- return nil, ErrIssueSucceeded
- }
- if task.Status != "failed" && task.Status != "cancelled" {
- return nil, ErrIssueBusy
- }
- }
- expr := "json_extract(execution_context, '$.issueId')"
- if r.isMySQL() {
- expr = "JSON_UNQUOTE(JSON_EXTRACT(execution_context, '$.issueId'))"
+ state := states[issue.ID]
+ if state.Block != nil {
+ return nil, ErrIssueBusy
}
- // Include legacy runs associated only through their Task's RunID.
- q := tx.Where(expr+" = ?", id).Or("id IN (?)", tx.Table("tasks").Select("run_id").Where("issue_id = ? AND run_id <> ''", id))
- var runs []runRow
- if err := q.Find(&runs).Error; err != nil {
- return nil, err
+ if mode == IssueDeleteNormal && state.RequiresForce() {
+ return nil, ErrIssueForceRequired
}
- for _, run := range runs {
- if run.Status == "succeeded" {
- return nil, ErrIssueSucceeded
- }
- }
- ids := make([]string, 0, len(runs))
- for _, run := range runs {
- if run.Status != "failed" && run.Status != "cancelled" {
- return nil, ErrIssueBusy
- }
- ids = append(ids, run.ID)
+ if mode == IssueDeleteUnsuccessful && state.successful {
+ return nil, ErrIssueSucceeded
}
- return ids, nil
+ return state.runIDs, nil
}
-// DeleteIssue removes the issue, comments and failed/cancelled tasks atomically
-// after the engine has cleaned every linked run and execution environment.
+// DeleteIssue keeps the conservative policy used by sync and conversation cleanup.
func (r *IssuesRepo) DeleteIssue(id string) error {
+ return r.DeleteIssueAfterRunCleanup(id, IssueDeleteUnsuccessful)
+}
+
+// DeleteIssueAfterRunCleanup rechecks the deletion conditions and removes the
+// issue, comments and tasks atomically after the engine has cleaned all runs.
+func (r *IssuesRepo) DeleteIssueAfterRunCleanup(id string, mode IssueDeletionMode) error {
r.mu.Lock()
defer r.mu.Unlock()
return r.DB.Transaction(func(tx *gorm.DB) error {
- ids, err := r.issueDeletionRuns(tx, id)
+ ids, err := r.issueDeletionRuns(tx, id, mode)
if err != nil {
return err
}
@@ -100,13 +91,7 @@ func (r *IssuesRepo) DeleteIssue(id string) error {
})
}
-// IssueDeletionAllowed computes list affordances from complete execution history
-// in two bulk queries, including runs omitted from the paginated UI run list.
-func (r *IssuesRepo) IssueDeletionAllowed(issues []domain.Issue) (map[string]bool, error) {
- return r.issueActionAllowed(issues, false)
-}
-
-// IssueDeletionBlock explains a restriction using the complete execution history.
+// IssueDeletionBlock explains active work that prevents deleting a requirement.
// RunID is only populated for an existing run, including legacy task-linked runs.
type IssueDeletionBlock struct {
Code string `json:"code"`
@@ -115,104 +100,118 @@ type IssueDeletionBlock struct {
TaskID string `json:"taskId,omitempty"`
}
-func (r *IssuesRepo) IssueDeletionBlocks(issues []domain.Issue) (map[string]IssueDeletionBlock, error) {
- return r.issueActionBlocks(issues, false)
+type IssueDeletionState struct {
+ Block *IssueDeletionBlock
+ hasHistory bool
+ successful bool
+ runIDs []string
}
-// IssueClosureAllowed permits settled execution history, but no active work.
-func (r *IssuesRepo) IssueClosureAllowed(issues []domain.Issue) (map[string]bool, error) {
- return r.issueActionAllowed(issues, true)
+func (s *IssueDeletionState) RequiresForce() bool {
+ return s.Block == nil && (s.hasHistory || s.successful)
}
-func (r *IssuesRepo) issueActionAllowed(issues []domain.Issue, allowSuccess bool) (map[string]bool, error) {
- blocks, err := r.issueActionBlocks(issues, allowSuccess)
- if err != nil {
- return nil, err
- }
- allowed := map[string]bool{}
- for _, issue := range issues {
- _, blocked := blocks[issue.ID]
- allowed[issue.ID] = !blocked
- }
- return allowed, nil
+// IssueDeletionStates checks complete execution history in two bulk queries.
+func (r *IssuesRepo) IssueDeletionStates(issues []domain.Issue) (map[string]*IssueDeletionState, error) {
+ return r.issueDeletionStates(r.DB, issues)
}
-func (r *IssuesRepo) issueActionBlocks(issues []domain.Issue, allowSuccess bool) (map[string]IssueDeletionBlock, error) {
- blocks := map[string]IssueDeletionBlock{}
- // Prefer actionable temporary blockers, then historical success, then status.
- priority := map[string]int{"completed": 1, "succeeded": 2, "active": 3, "clarifying": 4}
- block := func(id string, next IssueDeletionBlock) {
- prev := blocks[id]
- if priority[next.Code] > priority[prev.Code] || (next.Code == prev.Code && prev.RunID == "" && next.RunID != "") {
- blocks[id] = next
- }
+func (r *IssuesRepo) issueDeletionStates(db *gorm.DB, issues []domain.Issue) (map[string]*IssueDeletionState, error) {
+ states := make(map[string]*IssueDeletionState, len(issues))
+ if len(issues) == 0 {
+ return states, nil
}
ids := make([]string, 0, len(issues))
- issueIDs := map[string]bool{}
for _, issue := range issues {
ids = append(ids, issue.ID)
- issueIDs[issue.ID] = true
- if !allowSuccess && issue.Status == "done" {
- block(issue.ID, IssueDeletionBlock{Code: "completed", Reason: "需求已完成,当前不支持删除"})
- }
+ state := &IssueDeletionState{successful: issue.Status == "done"}
if issue.Clarification.Status == "analyzing" {
- block(issue.ID, IssueDeletionBlock{Code: "clarifying", Reason: "正在澄清,请先停止澄清后再删除"})
+ state.Block = &IssueDeletionBlock{Code: "clarifying", Reason: "正在澄清,请先停止澄清后再删除"}
}
- }
- if len(ids) == 0 {
- return blocks, nil
+ states[issue.ID] = state
}
var tasks []taskRow
- if err := r.DB.Select("id", "issue_id", "run_id", "status").Where("issue_id IN ?", ids).Find(&tasks).Error; err != nil {
+ if err := db.Select("id", "issue_id", "run_id", "status").Where("issue_id IN ?", ids).Find(&tasks).Error; err != nil {
return nil, err
}
- runIssues := map[string][]string{}
- runIDs := []string{}
+ // Legacy runs can be linked solely by their Task's RunID.
+ runIssues := map[string]map[string]bool{}
+ var runIDs []string
for _, task := range tasks {
- if task.Status != "failed" && task.Status != "cancelled" && !(allowSuccess && (task.Status == "completed" || task.Status == "succeeded")) {
- restriction := IssueDeletionBlock{Code: "active", Reason: "仍有未结束的任务,请先处理或停止后再删除", TaskID: task.ID}
- if task.Status == "completed" || task.Status == "succeeded" {
- restriction = IssueDeletionBlock{Code: "succeeded", Reason: "已有成功执行记录,当前不支持删除", TaskID: task.ID}
+ state := states[task.IssueID]
+ if state == nil {
+ return nil, fmt.Errorf("执行任务 %s 的需求编号与记录不一致", task.ID)
+ }
+ state.hasHistory = true
+ switch task.Status {
+ case "completed", "succeeded":
+ state.successful = true
+ case "failed", "cancelled":
+ default:
+ if state.Block == nil {
+ state.Block = &IssueDeletionBlock{Code: "active", Reason: "仍有未结束的任务,请先处理或停止后再删除", TaskID: task.ID}
}
- block(task.IssueID, restriction)
}
if task.RunID != "" {
- runIssues[task.RunID] = append(runIssues[task.RunID], task.IssueID)
- runIDs = append(runIDs, task.RunID)
+ if runIssues[task.RunID] == nil {
+ runIssues[task.RunID] = map[string]bool{}
+ runIDs = append(runIDs, task.RunID)
+ }
+ runIssues[task.RunID][task.IssueID] = true
}
}
+
expr := "json_extract(execution_context, '$.issueId')"
if r.isMySQL() {
expr = "JSON_UNQUOTE(JSON_EXTRACT(execution_context, '$.issueId'))"
}
- q := r.DB.Select("id", "status", "execution_context").Where(expr+" IN ?", ids)
+ type linkedRun struct {
+ ID, Status, IssueID string
+ ActiveNodes bool
+ }
+ q := db.Table("runs").Select("id, status, "+expr+" AS issue_id, "+
+ "EXISTS (SELECT 1 FROM run_nodes WHERE run_id = runs.id AND status IN ('running', 'pending_input')) AS active_nodes").
+ Where(expr+" IN ?", ids)
if len(runIDs) > 0 {
q = q.Or("id IN ?", runIDs)
}
- var runs []runRow
+ var runs []linkedRun
if err := q.Find(&runs).Error; err != nil {
return nil, err
}
- for _, run := range runs {
- if run.Status == "failed" || run.Status == "cancelled" || (allowSuccess && run.Status == "succeeded") {
- continue
+ addRun := func(state *IssueDeletionState, run linkedRun) {
+ state.hasHistory = true
+ state.successful = state.successful || run.Status == "succeeded"
+ state.runIDs = append(state.runIDs, run.ID)
+ if domain.TerminalRunStatus(run.Status) && !run.ActiveNodes {
+ return
}
- restriction := IssueDeletionBlock{Code: "active", Reason: "仍有未结束的运行,请先处理或停止后再删除", RunID: run.ID}
- if run.Status == "succeeded" {
- restriction = IssueDeletionBlock{Code: "succeeded", Reason: "已有成功执行记录,当前不支持删除", RunID: run.ID}
- }
- var ctx domain.TelemetryContext
- if len(run.ExecutionContext) > 0 {
- if err := jsonUnmarshal(run.ExecutionContext, &ctx); err != nil {
- return nil, err
- }
+ // Prefer linking to the active run when the earlier reason was a task.
+ if state.Block == nil || (state.Block.Code == "active" && state.Block.RunID == "") {
+ state.Block = &IssueDeletionBlock{Code: "active", Reason: "仍有未结束的运行,请先处理或停止后再删除", RunID: run.ID}
}
- if issueIDs[ctx.IssueID] {
- block(ctx.IssueID, restriction)
+ }
+ for _, run := range runs {
+ linked := runIssues[run.ID]
+ for id := range linked {
+ addRun(states[id], run)
}
- for _, id := range runIssues[run.ID] {
- block(id, restriction)
+ if state := states[run.IssueID]; state != nil && !linked[run.IssueID] {
+ addRun(state, run)
}
}
- return blocks, nil
+ return states, nil
+}
+
+// IssueClosureAllowed permits settled execution history, but no active work.
+func (r *IssuesRepo) IssueClosureAllowed(issues []domain.Issue) (map[string]bool, error) {
+ states, err := r.IssueDeletionStates(issues)
+ if err != nil {
+ return nil, err
+ }
+ allowed := make(map[string]bool, len(states))
+ for id, state := range states {
+ allowed[id] = state.Block == nil
+ }
+ return allowed, nil
}
diff --git a/internal/repo/issues_delete_test.go b/internal/repo/issues_delete_test.go
index dfd9e221..1249a5ff 100644
--- a/internal/repo/issues_delete_test.go
+++ b/internal/repo/issues_delete_test.go
@@ -61,40 +61,28 @@ func TestDeleteIssue(t *testing.T) {
t.Fatal(err)
}
}
- eligibility, err := s.IssueDeletionAllowed([]domain.Issue{issue})
+ states, err := s.IssueDeletionStates([]domain.Issue{issue})
if err != nil {
t.Fatal(err)
}
- expected := status == "idle" || status == "closed" || status == "failed" || status == "cancelled"
- if eligibility[id] != expected {
- t.Fatalf("delete visibility for %s: %v", status, eligibility[id])
+ state := states[id]
+ busy := status == "analyzing" || status == "queued" || status == "running" || status == "waiting"
+ if (state.Block != nil) != busy || state.RequiresForce() != (!busy && status != "idle" && status != "closed") {
+ t.Fatalf("incorrect deletion state for %s: %+v", status, state)
}
- blocks, err := s.IssueDeletionBlocks([]domain.Issue{issue})
- if err != nil {
- t.Fatal(err)
- }
- block, blocked := blocks[id]
- if blocked == expected {
- t.Fatalf("block and eligibility disagree: %+v", block)
- }
- if blocked {
+ if busy {
+ block := state.Block
code := "active"
if status == "analyzing" {
code = "clarifying"
}
- if status == "done" {
- code = "completed"
- }
- if status == "completed" || status == "succeeded" {
- code = "succeeded"
- }
if block.Code != code || block.Reason == "" {
t.Fatalf("incorrect block for %s: %+v", status, block)
}
- if (status == "running" || status == "waiting" || status == "succeeded") && block.RunID != id+"-run" {
+ if (status == "running" || status == "waiting") && block.RunID != id+"-run" {
t.Fatalf("missing run destination: %+v", block)
}
- if (status == "queued" || status == "completed") && (block.RunID != "" || block.TaskID != id+"-task") {
+ if status == "queued" && (block.RunID != "" || block.TaskID != id+"-task") {
t.Fatalf("task-only block points to a missing run: %+v", block)
}
}
@@ -102,21 +90,25 @@ func TestDeleteIssue(t *testing.T) {
if err != nil {
t.Fatal(err)
}
- expectedClose := expected || status == "completed" || status == "succeeded" || status == "done"
- if closeAllowed[id] != expectedClose {
+ if closeAllowed[id] == busy {
t.Fatalf("closure visibility for %s: %v", status, closeAllowed[id])
}
- ids, err := s.IssueDeletionRuns(id)
if status == "succeeded" || status == "completed" || status == "done" {
- if !errors.Is(err, ErrIssueSucceeded) {
- t.Fatalf("expected successful guard: %v", err)
- }
- if err = s.DeleteIssue(id); !errors.Is(err, ErrIssueSucceeded) {
+ if err := s.DeleteIssue(id); !errors.Is(err, ErrIssueSucceeded) {
t.Fatal(err)
}
- return
}
- if status != "idle" && status != "closed" && status != "failed" && status != "cancelled" {
+ if state.RequiresForce() {
+ if _, err := s.IssueDeletionRuns(id, IssueDeleteNormal); !errors.Is(err, ErrIssueForceRequired) {
+ t.Fatalf("delete without confirmation: %v", err)
+ }
+ }
+ mode := IssueDeleteNormal
+ if state.RequiresForce() || busy {
+ mode = IssueDeleteForce
+ }
+ ids, err := s.IssueDeletionRuns(id, mode)
+ if busy {
if !errors.Is(err, ErrIssueBusy) {
t.Fatalf("expected busy: %v", err)
}
@@ -128,12 +120,15 @@ func TestDeleteIssue(t *testing.T) {
if err != nil {
t.Fatal(err)
}
+ if len(ids) > 0 && s.DeleteIssueAfterRunCleanup(id, mode) == nil {
+ t.Fatal("deleted issue before run cleanup")
+ }
for _, runID := range ids {
if err := s.DeleteRun(runID); err != nil {
t.Fatal(err)
}
}
- if err := s.DeleteIssue(id); err != nil {
+ if err := s.DeleteIssueAfterRunCleanup(id, mode); err != nil {
t.Fatal(err)
}
if _, ok := s.Issue(id); ok || len(s.Comments(id)) != 0 {
@@ -145,6 +140,15 @@ func TestDeleteIssue(t *testing.T) {
if err := s.DeleteIssue(id); !errors.Is(err, ErrIssueNotFound) {
t.Fatal(err)
}
+ if _, _, err := s.ReserveIssueDispatch(domain.Task{ID: id + "-task", IssueID: id, Status: "queued"}); !errors.Is(err, ErrIssueNotFound) {
+ t.Fatalf("reserved a task for a deleted issue: %v", err)
+ }
+ if err := s.UpdateTaskStatus(domain.Task{ID: id + "-task", IssueID: id, RunID: id + "-run"}, "completed"); err != nil {
+ t.Fatal(err)
+ }
+ if _, ok := s.Task(id + "-task"); ok {
+ t.Fatal("reconciliation recreated a deleted task")
+ }
if err := s.PutIssue(issue); err != nil {
t.Fatal(err)
}
@@ -153,11 +157,37 @@ func TestDeleteIssue(t *testing.T) {
}
})
}
+ t.Run("concurrent dispatch", func(t *testing.T) {
+ const id = "delete-racing-dispatch"
+ if err := s.PutIssue(domain.Issue{ID: id, ProjectID: "platform", Status: "todo"}); err != nil {
+ t.Fatal(err)
+ }
+ t.Cleanup(func() {
+ s.DB.Where("issue_id = ?", id).Delete(&taskRow{})
+ s.DB.Where("id = ?", id).Delete(&issueRow{})
+ })
+ reservation := make(chan error, 1)
+ go func() {
+ _, _, err := s.ReserveIssueDispatch(domain.Task{ID: id + "-task", IssueID: id, Status: "queued"})
+ reservation <- err
+ }()
+ deleteErr := s.DeleteIssueAfterRunCleanup(id, IssueDeleteNormal)
+ dispatchErr := <-reservation
+ if deleteErr == nil && errors.Is(dispatchErr, ErrIssueNotFound) {
+ if _, exists := s.Task(id + "-task"); exists {
+ t.Fatal("deleted issue has an orphaned task")
+ }
+ return
+ }
+ if !errors.Is(deleteErr, ErrIssueBusy) || dispatchErr != nil {
+ t.Fatalf("concurrent deletion: %v, reservation: %v", deleteErr, dispatchErr)
+ }
+ })
})
}
}
-func TestIssueDeletionBlocksHistory(t *testing.T) {
+func TestIssueDeletionStatesHistory(t *testing.T) {
for _, driver := range []string{"sqlite", "mysql"} {
t.Run(driver, func(t *testing.T) {
var s *Store
@@ -184,8 +214,7 @@ func TestIssueDeletionBlocksHistory(t *testing.T) {
s.DB.Where("id IN ?", []string{"delete-history-old", "delete-history-latest", "delete-history-active"}).Delete(&runRow{})
s.DB.Where("id = ?", issue.ID).Delete(&issueRow{})
})
- // A legacy success is linked only by a cancelled task; the latest
- // directly linked run failed and must not hide the historical blocker.
+ // The old success is linked only by its Task's RunID.
if err := s.PutRun(domain.Run{ID: "delete-history-old", Status: "succeeded"}); err != nil {
t.Fatal(err)
}
@@ -195,21 +224,34 @@ func TestIssueDeletionBlocksHistory(t *testing.T) {
if err := s.PutRun(domain.Run{ID: "delete-history-latest", Status: "failed", ExecutionContext: domain.TelemetryContext{IssueID: issue.ID}}); err != nil {
t.Fatal(err)
}
+ ids, err := s.IssueDeletionRuns(issue.ID, IssueDeleteForce)
+ if err != nil || len(ids) != 2 {
+ t.Fatalf("incorrect execution history: %v, %v", ids, err)
+ }
+ if _, err := s.IssueDeletionRuns(issue.ID, IssueDeleteUnsuccessful); !errors.Is(err, ErrIssueSucceeded) {
+ t.Fatalf("internal cleanup allowed legacy success: %v", err)
+ }
check := func(code, runID string) {
t.Helper()
- blocks, err := s.IssueDeletionBlocks([]domain.Issue{issue})
+ states, err := s.IssueDeletionStates([]domain.Issue{issue})
if err != nil {
t.Fatal(err)
}
- if got := blocks[issue.ID]; got.Code != code || got.RunID != runID {
+ if got := states[issue.ID].Block; got == nil || got.Code != code || got.RunID != runID {
t.Fatalf("wrong historical blocker: %+v", got)
}
}
- check("succeeded", "delete-history-old")
- if err := s.PutRun(domain.Run{ID: "delete-history-active", Status: "running", ExecutionContext: domain.TelemetryContext{IssueID: issue.ID}}); err != nil {
+ if err := s.PutRun(domain.Run{
+ ID: "delete-history-active", Status: "failed", ExecutionContext: domain.TelemetryContext{IssueID: issue.ID},
+ Nodes: map[string]*domain.NodeRun{"pending": {NodeID: "pending", Status: "pending_input"}},
+ }); err != nil {
t.Fatal(err)
}
+ t.Cleanup(func() { s.DB.Where("run_id = ?", "delete-history-active").Delete(&runNodeRow{}) })
check("active", "delete-history-active")
+ if _, err := s.IssueDeletionRuns(issue.ID, IssueDeleteForce); !errors.Is(err, ErrIssueBusy) {
+ t.Fatalf("force allowed a run with an active node: %v", err)
+ }
issue.Clarification.Status = "analyzing"
check("clarifying", "")
})
diff --git a/internal/repo/task_idempotency_test.go b/internal/repo/task_idempotency_test.go
index a8602ef6..4c054b3a 100644
--- a/internal/repo/task_idempotency_test.go
+++ b/internal/repo/task_idempotency_test.go
@@ -14,12 +14,15 @@ func TestCreateTaskUsesTaskIDAsAtomicIdempotencyKey(t *testing.T) {
t.Fatal(err)
}
t.Cleanup(st.Close)
+ if err := st.PutIssue(domain.Issue{ID: "issue-1", ProjectID: "platform", Title: "dispatch target"}); err != nil {
+ t.Fatal(err)
+ }
first := domain.Task{ID: "task-primary-fixed", IssueID: "issue-1", Status: "queued", DispatchMode: "scheduled", ScheduleJobID: "job-1"}
- stored, created, err := st.CreateTask(first)
+ stored, created, err := st.ReserveIssueDispatch(first)
if err != nil || !created || stored.ID != first.ID {
t.Fatalf("first reservation: created=%t task=%+v err=%v", created, stored, err)
}
- duplicate, created, err := st.CreateTask(domain.Task{ID: first.ID, IssueID: "issue-1", Status: "queued"})
+ duplicate, created, err := st.ReserveIssueDispatch(domain.Task{ID: first.ID, IssueID: "issue-1", Status: "queued"})
if err != nil || created || duplicate.ScheduleJobID != "job-1" {
t.Fatalf("duplicate reservation: created=%t task=%+v err=%v", created, duplicate, err)
}
@@ -31,15 +34,18 @@ func TestCreateTaskConcurrentPrimaryReservationHasOneWinner(t *testing.T) {
t.Fatal(err)
}
t.Cleanup(st.Close)
+ if err := st.PutIssue(domain.Issue{ID: "issue-1", ProjectID: "platform", Title: "dispatch target"}); err != nil {
+ t.Fatal(err)
+ }
var winners atomic.Int32
var wg sync.WaitGroup
for i := 0; i < 20; i++ {
wg.Add(1)
go func() {
defer wg.Done()
- _, created, err := st.CreateTask(domain.Task{ID: "task-primary-concurrent", IssueID: "issue-1", Status: "queued"})
+ _, created, err := st.ReserveIssueDispatch(domain.Task{ID: "task-primary-concurrent", IssueID: "issue-1", Status: "queued"})
if err != nil {
- t.Errorf("CreateTask: %v", err)
+ t.Errorf("ReserveIssueDispatch: %v", err)
return
}
if created {
diff --git a/internal/repo/tasks.go b/internal/repo/tasks.go
index 66ffa2d3..8d834c62 100644
--- a/internal/repo/tasks.go
+++ b/internal/repo/tasks.go
@@ -37,15 +37,22 @@ func (r *TasksRepo) PutTask(v domain.Task) error {
})
}
-// CreateTask inserts a task exactly once. Primary dispatches use a stable task
-// ID, so the tasks primary key is also the cross-instance idempotency key.
-func (r *TasksRepo) CreateTask(v domain.Task) (domain.Task, bool, error) {
+// UpdateTaskStatus reconciles an existing task without re-creating it if its
+// issue and execution history were deleted in the meantime.
+func (r *TasksRepo) UpdateTaskStatus(v domain.Task, status string) error {
+ v.Status, v.UpdatedAt = status, time.Now().UTC()
+ return r.DB.Model(&taskRow{}).Where("id = ? AND issue_id = ? AND COALESCE(run_id, '') = ?", v.ID, v.IssueID, v.RunID).
+ Updates(map[string]any{"status": v.Status, "payload": mustJSON(v), "updated_at": timePtr(v.UpdatedAt)}).Error
+}
+
+// createTask uses the task's primary key as the cross-instance idempotency key.
+func (r *TasksRepo) createTask(tx *gorm.DB, v domain.Task) (domain.Task, bool, error) {
if strings.TrimSpace(v.ID) == "" || strings.TrimSpace(v.IssueID) == "" {
return domain.Task{}, false, fmt.Errorf("task id and issue id are required")
}
now := time.Now().UTC()
v.CreatedAt, v.UpdatedAt = now, now
- created, err := insertIgnore(r.DB, "tasks", map[string]any{
+ created, err := insertIgnore(tx, "tasks", map[string]any{
"id": v.ID, "issue_id": v.IssueID, "run_id": v.RunID, "status": v.Status,
"payload": mustJSON(v), "created_at": timePtr(v.CreatedAt), "updated_at": timePtr(v.UpdatedAt),
})
@@ -55,7 +62,7 @@ func (r *TasksRepo) CreateTask(v domain.Task) (domain.Task, bool, error) {
if err != nil && !errors.Is(err, gorm.ErrDuplicatedKey) {
return domain.Task{}, false, err
}
- existing, ok := r.Task(v.ID)
+ existing, ok := payloadOne[domain.Task](tx, "tasks", v.ID)
if !ok {
return domain.Task{}, false, fmt.Errorf("task reservation was not persisted")
}
diff --git a/web/app/issue-bulk-delete.js b/web/app/issue-bulk-delete.js
index f3c856bb..06663352 100644
--- a/web/app/issue-bulk-delete.js
+++ b/web/app/issue-bulk-delete.js
@@ -45,7 +45,8 @@ function renderIssueBulkActions(visibleIssues){
if(!state.issueSelectionMode){host.innerHTML='';return}
const selected=state.issueSelection.size,busy=state.issueBulkDeleting,progress=state.issueBulkDeleteProgress,result=state.issueBulkDeleteResult;
const scope=state.issueView==='kanban'?'全选当前可删除需求':'全选本页可删除需求';
- const buttonText=busy?(progress?`正在删除 ${progress.completed}/${progress.total}…`:'等待确认…'):'删除所选';
+ const force=(state.data.issues||[]).some(i=>state.issueSelection.has(i.id)&&i.deletionRequiresForce===true);
+ const buttonText=busy?(progress?`正在删除 ${progress.completed}/${progress.total}…`:'等待确认…'):force?'强制删除所选':'删除所选';
const blocked=visibleIssues.filter(i=>!issueCanDelete(i));
const reasonsOpen=host.querySelector('.issue-bulk-blocked')?.open;
host.innerHTML=`<div class="issue-bulk-toolbar">
@@ -100,11 +101,14 @@ async function deleteSelectedIssues(){
const issues=filtered.filter(i=>state.issueSelection.has(i.id));
if(!issues.length)return toast('请先选择可删除的需求');
const scope=issueSelectionFilterKey(),external=issues.some(i=>i.source==='tapd'||i.source==='gongfeng');
+ const forceIDs=new Set(issues.filter(i=>i.deletionRequiresForce===true).map(i=>i.id));
const names=issues.slice(0,5).map(i=>`「${i.title||i.id}」`).join('、')+(issues.length>5?'等':'');
+ const forceNotice=forceIDs.size?`其中 ${forceIDs.size} 条已有执行记录或已完成,将强制删除。`:'';
state.issueBulkDeleting=true;
renderIssues();
try{
- if(!await afConfirm({title:'批量删除需求',message:`确定删除选中的 ${issues.length} 条需求(${names})?需求、评论、澄清记录以及失败/取消的历史任务、运行记录、日志、产物和执行工作区将一并清理,且不可恢复。澄清或执行中、已有成功运行的需求不允许删除。${external?'此操作仅删除本地记录,不会删除 TAPD/工蜂原单,后续同步可能重新导入。':''}`,danger:true,confirmText:`确认删除 ${issues.length} 条需求`}))return;
+ const action=forceIDs.size?'确认强制删除':'确认删除';
+ if(!await afConfirm({title:'批量删除需求',message:`确定删除选中的 ${issues.length} 条需求(${names})?${forceNotice}${issueDeletionWarning(forceIDs.size>0,external)}`,danger:true,confirmText:`${action} ${issues.length} 条需求`}))return;
if(scope!==issueSelectionFilterKey())return toast('筛选条件已变化,请重新选择需求','info');
const result={deleted:0,failures:[]};
state.issueBulkDeleteResult=result;
@@ -113,7 +117,7 @@ async function deleteSelectedIssues(){
// checks and full engine cleanup. One conflict must not abort the batch.
for(const issue of issues){
try{
- await api(`/api/issues/${encodeURIComponent(issue.id)}`,{method:'DELETE'});
+ await api(issueDeletePath(issue.id,forceIDs.has(issue.id)),{method:'DELETE'});
result.deleted++;
state.issueSelection.delete(issue.id);
state.data.issues=(state.data.issues||[]).filter(i=>i.id!==issue.id);
diff --git a/web/app/issue-drawer.js b/web/app/issue-drawer.js
index a3826d17..a5a759ce 100644
--- a/web/app/issue-drawer.js
+++ b/web/app/issue-drawer.js
@@ -27,7 +27,7 @@ async function openIssueDetail(id,tab){
const detail=await api(`/api/issues/${encodeURIComponent(issueId)}`);const issue=detail.issue;const comments=detail.comments||[];
const localIssue=(state.data.issues||[]).find(i=>i.id===issueId);
// Keep local view state, but deletion feedback must come from this fresh detail response.
- const permissions={deletionAllowed:issue.deletionAllowed,deletionBlock:issue.deletionBlock,closureAllowed:issue.closureAllowed};
+ const permissions={deletionAllowed:issue.deletionAllowed,deletionRequiresForce:issue.deletionRequiresForce,deletionBlock:issue.deletionBlock,closureAllowed:issue.closureAllowed};
if(localIssue){Object.assign(issue,localIssue,permissions);Object.assign(localIssue,permissions)}
const task=latestIssueTask(issue);
const runId=task?.runId||latestIssueRun(issue, task)?.id;
@@ -931,10 +931,12 @@ async function deleteIssueById(issueId){
const issue=(state.data.issues||[]).find(i=>i.id===issueId)||state.issueDetailData?.issue;
if(!issue||issue.id!==issueId)return toast('未找到需求单');
if(!issueCanDelete(issue))return toast(issueDeletionBlock(issue).reason,'err');
+ const force=issue.deletionRequiresForce===true;
+ const title=force?'强制删除需求':'删除需求';
const external=issue.source==='tapd'||issue.source==='gongfeng';
- if(!await afConfirm({title:'删除需求',message:`确定删除需求「${issue.title||issue.id}」?需求、评论、澄清记录以及失败/取消的历史任务、运行记录、日志、产物和执行工作区将一并清理,且不可恢复。已有成功运行的需求不允许删除。${external?'此操作仅删除本地记录,不会删除 TAPD/工蜂原单,后续同步可能重新导入。':''}`,danger:true,confirmText:'确认删除'}))return;
+ if(!await afConfirm({title,message:`确定${title}「${issue.title||issue.id}」?${issueDeletionWarning(force,external)}`,danger:true,confirmText:force?'确认强制删除':'确认删除'}))return;
try{
- await api(`/api/issues/${encodeURIComponent(issueId)}`,{method:'DELETE'});
+ await api(issueDeletePath(issueId,force),{method:'DELETE'});
state.data.issues=(state.data.issues||[]).filter(i=>i.id!==issueId);
state.issueSelection?.delete(issueId);
if(state.issueDetailData?.issue?.id===issueId){closeIssueDrawer();state.issueDetailData=null;state.selectedIssue=null;}
@@ -942,7 +944,10 @@ async function deleteIssueById(issueId){
await refreshRuns();
renderIssues();
toast('需求已删除','ok');
- }catch(err){toast(err.message,'err')}
+ }catch(err){
+ toast(err.message,'err');
+ await refreshIssues();
+ }
}
// Association does not expose private conversations to other project members.
diff --git a/web/app/issue-model.js b/web/app/issue-model.js
index 0542534e..994c0144 100644
--- a/web/app/issue-model.js
+++ b/web/app/issue-model.js
@@ -9,6 +9,12 @@ function issueDeletionBlock(issue){
if(issueCanDelete(issue))return null;
return issue?.deletionBlock?.reason?issue.deletionBlock:{code:'unknown',reason:'暂时无法确认删除条件,请刷新后重试'};
}
+function issueDeletePath(id,force){
+ return `/api/issues/${encodeURIComponent(id)}${force?'?force=true':''}`;
+}
+function issueDeletionWarning(force,external){
+ return `需求、评论和澄清记录将被删除。${force?'关联的任务、运行记录、日志、产物和执行工作区将一并清理。':''}删除后无法恢复。${external?'外部原单会保留,后续同步可能重新导入。':''}`;
+}
function issueDeletionContextHTML(issue,{menu=false}={}){
const block=issueDeletionBlock(issue);
if(!block)return '';
@@ -18,7 +24,8 @@ function issueDeletionContextHTML(issue,{menu=false}={}){
function issueDeleteControlHTML(issue,{menu=false}={}){
const block=issueDeletionBlock(issue),cls=menu?'issue-popover-item':'button ghost small';
const reasonId=`issue-delete-reason-${menu?'menu':'detail'}-${issue.id}`;
- const button=`<button type="button" class="${cls}${block?'':' danger'}" ${menu?'data-action="delete"':`data-delete-issue="${escapeHTML(issue.id)}"`}${block?` disabled aria-describedby="${escapeHTML(reasonId)}"`:''}>${menu?huiIcon('trash','popover-icon'):''}删除需求</button>`;
+ const label=!block&&issue.deletionRequiresForce?'强制删除':'删除需求';
+ const button=`<button type="button" class="${cls}${block?'':' danger'}" ${menu?'data-action="delete"':`data-delete-issue="${escapeHTML(issue.id)}"`}${block?` disabled aria-describedby="${escapeHTML(reasonId)}"`:''}>${menu?huiIcon('trash','popover-icon'):''}${label}</button>`;
if(!block)return button;
return `<div class="issue-delete-control">${button}<p class="issue-delete-reason" id="${escapeHTML(reasonId)}">${escapeHTML(block.reason)}</p>${issueDeletionContextHTML(issue,{menu})}</div>`;
}
diff --git a/web/i18n-en.js b/web/i18n-en.js
index 05980321..ad820cdf 100644
--- a/web/i18n-en.js
+++ b/web/i18n-en.js
@@ -169,3 +169,14 @@ Object.assign(window.LF_I18N_EN,{
"请输入有效的 GitHub 链接或 Git SSH 克隆地址。CNB 只支持 HTTPS + 访问令牌。":"Enter a GitHub link or a Git SSH clone address. CNB supports HTTPS with an access token.",
"粘贴 GitHub 链接或 Git SSH 地址":"Paste a GitHub link or Git SSH address"
});
+Object.assign(window.LF_I18N_EN,{
+ "强制删除":"Force delete",
+ "强制删除需求":"Force-delete requirement",
+ "强制删除所选":"Force-delete selected",
+ "确认强制删除":"Force delete",
+ "需求、评论和澄清记录将被删除。":"The requirement, its comments, and clarification history will be deleted.",
+ "关联的任务、运行记录、日志、产物和执行工作区将一并清理。":"Linked tasks, runs, logs, outputs, and workspaces will be removed as well.",
+ "删除后无法恢复。":"This cannot be undone.",
+ "外部原单会保留,后续同步可能重新导入。":"The original external record is kept, and a later sync may import it again.",
+ "需求已有执行记录或已完成,请确认强制删除":"This requirement has execution history or is already completed. Confirm force deletion."
+});
diff --git a/web/issue_bulk_delete_test.js b/web/issue_bulk_delete_test.js
index 228eabf5..29693684 100644
--- a/web/issue_bulk_delete_test.js
+++ b/web/issue_bulk_delete_test.js
@@ -2,6 +2,8 @@ const fs = require('fs');
const vm = require('vm');
const assert = require('assert/strict');
const source = fs.readFileSync(process.argv[2], 'utf8');
+const model = fs.readFileSync(require('path').join(require('path').dirname(process.argv[2]), 'issue-model.js'), 'utf8');
+const helpers = model.slice(model.indexOf('function issueDeletePath('), model.indexOf('function issueDeletionContextHTML('));
const issue = (id, extra = {}) => ({id, title: `需求 ${id}`, deletionAllowed: true, ...extra});
const ids = items => Array.from(items, i => typeof i === 'string' ? i : i.id);
const escapeHTML = value => String(value).replace(/[&<>"']/g, c => ({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[c]));
@@ -26,7 +28,7 @@ function setup(items, options = {}) {
api:async (path,opts) => {calls.push([path,opts.method]);if(options.fail?.(path)) throw new Error('<conflict>');},
refreshRuns:async () => calls.push(['refresh']), closeIssueDrawer:() => calls.push(['close'])};
vm.createContext(c);
- vm.runInContext(source,c);
+ vm.runInContext(helpers+'\n'+source,c);
c.renderIssues = () => {c.syncIssueSelection(c.filteredIssues()); c.renderIssueBulkActions(c.filteredIssues());};
c.renderIssues();
return {c,state,calls,notices,host,root,buttons};
@@ -97,13 +99,14 @@ const deletes = f => f.calls.filter(call => call[1] === 'DELETE');
assert.equal(f.state.issueSelectionMode,true, 'cancelling confirmation preserves multi-select');
// One confirmation deletes all selected items, encodes IDs, and refreshes history once.
- f = setup([issue('a/1',{source:'tapd'}),issue('b'),issue('keep')]);select(f,'a/1','b');
+ f = setup([issue('a/1',{source:'tapd',deletionRequiresForce:true}),issue('b'),issue('keep')]);select(f,'a/1','b');
f.state.issueDetailData={issue:f.state.data.issues[0]};f.state.selectedIssue='a/1';
await f.c.deleteSelectedIssues();
- assert.deepEqual(deletes(f),[['/api/issues/a%2F1','DELETE'],['/api/issues/b','DELETE']]);
+ assert.deepEqual(deletes(f),[['/api/issues/a%2F1?force=true','DELETE'],['/api/issues/b','DELETE']]);
assert.equal(f.calls.filter(c => c[0] === 'confirm').length,1);
assert.match(f.calls[0][1].message,/后续同步可能重新导入/);
- assert.match(f.calls[0][1].confirmText,/2 条需求/);
+ assert.match(f.calls[0][1].message,/其中 1 条.*工作区将一并清理/);
+ assert.equal(f.calls[0][1].confirmText,'确认强制删除 2 条需求');
assert.equal(f.calls.filter(c => c[0] === 'refresh').length,1);
assert.equal(f.calls.filter(c => c[0] === 'close').length,1);
assert.equal(f.state.issueDetailData,null);
diff --git a/web/issue_delete_test.js b/web/issue_delete_test.js
index 19b5fdc2..944c5f8c 100644
--- a/web/issue_delete_test.js
+++ b/web/issue_delete_test.js
@@ -6,6 +6,7 @@ const start = bundle.indexOf('async function deleteIssueById(');
assert(start >= 0);
const end = bundle.indexOf('\n}', start) + 2;
const code = bundle.slice(start, end);
+const helpers = bundle.slice(bundle.indexOf('function issueDeletePath('), bundle.indexOf('function issueDeletionContextHTML('));
const visibilityStart = bundle.indexOf('function issueCanDelete(');
const visibilityEnd = bundle.indexOf('\n}', visibilityStart) + 2;
const visibility = {issueClarifying: id => id === 'busy'};
@@ -21,16 +22,26 @@ vm.runInContext(bundle.slice(closeStart, closeEnd), visibility);
assert.equal(visibility.issueCanClose({id:'settled',closureAllowed:true}),true);
assert.equal(visibility.issueCanClose({id:'active',closureAllowed:false}),false);
assert.equal(visibility.issueCanClose({id:'busy',closureAllowed:true}),false);
-async function run({confirm=true, busy=false, fail=false, batch=false}={}) {
- const issue={id:'issue/1',title:'测试需求',source:'tapd',deletionAllowed:true};
+async function run({confirm=true, busy=false, fail=false, batch=false, force=false, historyChanged=false}={}) {
+ const issue={id:'issue/1',title:'测试需求',source:'tapd',deletionAllowed:true,deletionRequiresForce:force};
const calls=[];
const state={data:{issues:[issue,{id:'other'}]},issueDetailData:{issue},selectedIssue:issue.id,issueBulkDeleting:batch,issueSelection:new Set([issue.id,'other'])};
- const context={state,issueCanDelete:()=>!busy,issueDeletionBlock:()=>({reason:'正在澄清'}),toast:()=>{},refreshRuns:async()=>{},renderIssues:()=>calls.push('render'),closeIssueDrawer:()=>calls.push('close'),afConfirm:async opts=>{assert(opts.message.includes('后续同步可能重新导入'));return confirm;},api:async(path,opts)=>{calls.push([path,opts.method]);if(fail)throw new Error('conflict');}};
- vm.createContext(context);vm.runInContext(code,context);
+ const context={state,issueCanDelete:()=>!busy,issueDeletionBlock:()=>({reason:'正在澄清'}),toast:()=>{},refreshRuns:async()=>{},refreshIssues:async()=>calls.push('refresh issues'),renderIssues:()=>calls.push('render'),closeIssueDrawer:()=>calls.push('close'),
+ afConfirm:async opts=>{
+ assert(opts.message.includes('后续同步可能重新导入'));
+ assert.equal(opts.message.includes('任务、运行记录、日志、产物和执行工作区'),force);
+ assert.equal(opts.confirmText,force?'确认强制删除':'确认删除');
+ if(historyChanged)issue.deletionRequiresForce=true;
+ return confirm;
+ },
+ api:async(path,opts)=>{calls.push([path,opts.method]);if(fail)throw new Error('conflict');}};
+ vm.createContext(context);vm.runInContext(helpers+'\n'+code,context);
await context.deleteIssueById(issue.id);
return {state,calls};
}
(async()=>{
let out=await run();assert.deepStrictEqual(out.calls,[['/api/issues/issue%2F1','DELETE'],'close','render']);assert.equal(out.state.data.issues.length,1);assert.equal(out.state.issueDetailData,null);assert.equal(out.state.issueSelection.has('issue/1'),false);assert.equal(out.state.issueSelection.has('other'),true);
- for(const opts of [{confirm:false},{busy:true},{fail:true},{batch:true}]){out=await run(opts);assert.equal(out.state.data.issues.length,2);assert(out.state.issueDetailData);assert(!out.calls.includes('close'));}
+ out=await run({force:true});assert.deepStrictEqual(out.calls,[['/api/issues/issue%2F1?force=true','DELETE'],'close','render']);
+ out=await run({historyChanged:true,fail:true});assert.deepStrictEqual(out.calls,[['/api/issues/issue%2F1','DELETE'],'refresh issues']);
+ for(const opts of [{confirm:false,force:true},{busy:true},{fail:true},{batch:true}]){out=await run(opts);assert.equal(out.state.data.issues.length,2);assert(out.state.issueDetailData);assert(!out.calls.includes('close'));}
})().catch(err=>{console.error(err);process.exit(1);});
diff --git a/webtest/tests/issue-deletion-feedback.test.mjs b/webtest/tests/issue-deletion-feedback.test.mjs
index c03b48ca..c273ab3e 100644
--- a/webtest/tests/issue-deletion-feedback.test.mjs
+++ b/webtest/tests/issue-deletion-feedback.test.mjs
@@ -2,12 +2,12 @@ import test from 'node:test';
import assert from 'node:assert/strict';
import { loadApp, settle } from '../lib/load-app.mjs';
-const reason = '已有成功执行记录,当前不支持删除';
+const reason = '仍有未结束的运行,请先处理或停止后再删除';
const blockedIssue = {
id: 'delete-feedback', projectId: 'project-1', title: '国际站套餐支持升级',
status: 'closed', closeSource: 'manual', source: 'local', priority: 'medium',
- deletionAllowed: false, closureAllowed: true,
- deletionBlock: { code: 'succeeded', reason, runId: 'old-success' },
+ deletionAllowed: false, closureAllowed: false,
+ deletionBlock: { code: 'active', reason, runId: 'active-run' },
};
function showMenu(app, issue) {
@@ -21,7 +21,7 @@ function showMenu(app, issue) {
return app.document.querySelector('#issueActionPopover');
}
-test('closed issue keeps a disabled delete entry, visible reason, and the exact historical run link', async t => {
+test('closed issue with active work shows the reason and links to the active run', async t => {
const app = await loadApp();
t.after(app.close);
app.evaluate(`openRunFromId=(id,opts)=>window.deletionDestination={id,opts}`);
@@ -37,24 +37,26 @@ test('closed issue keeps a disabled delete entry, visible reason, and the exact
assert.equal(app.document.activeElement, menu.querySelector('[data-issue-deletion-context]'));
menu.querySelector('[data-issue-deletion-context]').click();
assert.deepEqual(structuredClone(app.evaluate('window.deletionDestination')), {
- id: 'old-success', opts: { forceRuns: true },
+ id: 'active-run', opts: { forceRuns: true },
});
assert.equal(menu.hidden, true);
assert.equal(app.router.calls.some(c => c.method === 'DELETE'), false);
});
-test('allowed, live clarification, completed, and unknown deletion states have honest feedback', async t => {
+test('ordinary, forced, clarifying, and unknown deletion states are shown in the menu', async t => {
const app = await loadApp();
t.after(app.close);
let menu = showMenu(app, { ...blockedIssue, deletionAllowed: true, deletionBlock: undefined });
assert.equal(menu.querySelector('[data-action="delete"]').disabled, false);
+ assert.equal(menu.querySelector('[data-action="delete"]').textContent, '删除需求');
assert.equal(menu.querySelector('.issue-delete-reason'), null);
menu = showMenu(app, { ...blockedIssue, deletionAllowed: true, clarification: { status: 'analyzing' } });
assert.equal(menu.querySelector('[data-action="delete"]').disabled, true);
assert.match(menu.querySelector('.issue-delete-reason').textContent, /正在澄清/);
assert.match(menu.querySelector('[data-issue-deletion-context]').textContent, /查看澄清/);
- menu = showMenu(app, { ...blockedIssue, status: 'done', deletionBlock: {code: 'completed', reason: '需求已完成,当前不支持删除'} });
- assert.match(menu.textContent, /需求已完成/);
+ menu = showMenu(app, { ...blockedIssue, status: 'done', deletionAllowed: true, deletionRequiresForce: true, deletionBlock: undefined });
+ assert.equal(menu.querySelector('[data-action="delete"]').textContent, '强制删除');
+ assert.equal(menu.querySelector('[data-action="delete"]').disabled, false);
menu = showMenu(app, { ...blockedIssue, deletionAllowed: undefined, deletionBlock: undefined });
assert.match(menu.querySelector('.issue-delete-reason').textContent, /刷新后重试/);
assert.doesNotMatch(menu.querySelector('.issue-delete-reason').textContent, /成功/);
@@ -63,11 +65,12 @@ test('allowed, live clarification, completed, and unknown deletion states have h
test('drawer uses fresh server restrictions and displays the task that prevents deletion', async t => {
const app = await loadApp();
t.after(app.close);
- const issue = { ...blockedIssue, deletionBlock: { code: 'succeeded', reason, taskId: 'historical-task' } };
+ const taskReason = '仍有未结束的任务,请先处理或停止后再删除';
+ const issue = { ...blockedIssue, deletionBlock: { code: 'active', reason: taskReason, taskId: 'queued-task' } };
app.router.get('/api/issues/delete-feedback', { issue, comments: [] });
app.router.get('/api/issues/delete-feedback/requirement', {});
- app.router.get('/api/tasks/historical-task', {
- id: 'historical-task', issueId: issue.id, status: 'completed', createdAt: '2026-01-01T00:00:00Z',
+ app.router.get('/api/tasks/queued-task', {
+ id: 'queued-task', issueId: issue.id, status: 'queued', createdAt: '2026-01-01T00:00:00Z',
});
app.evaluate(`state.data.issues=[${JSON.stringify({ ...issue, deletionAllowed: true, deletionBlock: undefined })}];state.data.tasks=[];state.data.runs=[]`);
await app.evaluate(`openIssueDetail('delete-feedback','overview')`);
@@ -75,21 +78,35 @@ test('drawer uses fresh server restrictions and displays the task that prevents
assert.equal(app.evaluate('state.data.issues[0].deletionAllowed'), false);
const drawer = app.document.querySelector('#issueDetailBody');
assert.equal(drawer.querySelector('[data-delete-issue]').disabled, true);
- assert.equal(drawer.querySelector('.issue-delete-reason').textContent, reason);
+ assert.equal(drawer.querySelector('.issue-delete-reason').textContent, taskReason);
drawer.querySelector('[data-issue-deletion-context]').click();
await settle(4);
assert.equal(app.evaluate('state.issueDetailTab'), 'activity');
assert.match(drawer.textContent, /阻止删除的任务/);
- assert.match(drawer.textContent, /historical-task/);
- assert.match(drawer.textContent, /已完成/);
+ assert.match(drawer.textContent, /queued-task/);
+ assert.match(drawer.textContent, /排队中/);
await app.evaluate(`deleteIssueById('delete-feedback')`);
assert.equal(app.router.calls.some(c => c.method === 'DELETE'), false);
- app.router.get('/api/issues/delete-feedback', { issue: { ...issue, deletionAllowed: true, deletionBlock: undefined }, comments: [] });
+ app.router.get('/api/issues/delete-feedback', { issue: { ...issue, deletionAllowed: true, deletionRequiresForce: true, deletionBlock: undefined }, comments: [] });
await app.evaluate(`openIssueDetail('delete-feedback','overview')`);
assert.equal(app.evaluate('state.issueDetailData.issue.deletionAllowed'), true);
- assert.equal(drawer.querySelector('[data-delete-issue]').disabled, false);
+ const force = drawer.querySelector('[data-delete-issue]');
+ assert.equal(force.disabled, false);
+ assert.equal(force.textContent, '强制删除');
assert.equal(drawer.querySelector('.issue-delete-reason'), null);
+ force.click();
+ assert.equal(app.document.querySelector('#confirmTitle').textContent, '强制删除需求');
+ assert.match(app.document.querySelector('#confirmMessage').textContent, /日志、产物和执行工作区.*无法恢复/);
+ assert.doesNotMatch(app.document.querySelector('#confirmMessage').textContent, /TAPD|工蜂/);
+ app.document.querySelector('#confirmCancelBtn').click();
+ await settle(4);
+ assert.equal(app.router.calls.some(c => c.method === 'DELETE'), false);
+
+ force.click();
+ app.document.querySelector('#confirmOkBtn').click();
+ await settle(4);
+ assert.equal(app.router.calls.find(c => c.method === 'DELETE')?.search, '?force=true');
});
test('bulk selection explains protected rows and escapes server-provided reasons', async t => {