mirror of
https://github.com/paperclipai/paperclip.git
synced 2026-11-21 10:52:06 +01:00
## Thinking Path > - Paperclip is the open source app people use to manage AI agents for work. > - The task composer holds messages that an agent has not consumed yet. > - A board operator needs to remove an agent-authored pending message before it starts more work. > - The queue currently grants discard only to the human author, so these messages have a disabled trash button and the API rejects the board user. > - This change derives the board discard permission in the queue snapshot and uses that same permission under the existing issue lock. > - The route checks task access before it changes the queue. The benefit is a working discard action with the existing company, privacy, revision, and dispatch guards. ## Linked Issues or Issue Description Fixes #15464. Supersedes #15465 with an independent implementation and red/green regression evidence. Thanks to @MMTE for identifying the gap and proposing a fix. Related: #18958 addresses deletion of comments that have already been delivered; this change covers pending queue entries. ## What Changed - Queue responses grant board users discard permission for agent-authored messages. Editing and other human authors' messages retain their existing permissions. - The discard use case honors the actor-specific permission rebuilt under the queue lock. Author agents keep their existing cancellation path. - The board discard route checks private-task access before deletion. The denial for a non-author agent now points to the board action instead of saying that no board action exists. - Tests cover queue states, cancellation of an empty continuation, persistence, queue linkage, audit attribution, private-task denial, and cross-company denial. The API reference describes the supported action. ## Verification - Red before the fix: the two snapshot regressions returned `canDiscard: false`; the discard regression threw `QueuedCommentMutationForbiddenError`. The route regressions also caught the disabled permission, missing private-task guard, and stale agent denial text. - Green after the fix: 30 queue snapshot and use-case tests; all five focused route regressions with real disposable Postgres; six Postgres adapter tests; 42 existing queue UI tests. - Server typecheck: `cd server && node scripts/typecheck-layers.mjs` passes. `node scripts/check-module-boundaries.mjs` and `git diff --check` pass. - The [complete PR workflow](https://github.com/paperclipai/paperclip/actions/runs/43484735280) passes on head `164200602828e23f01a8b209ff954821c5e14e9a`. [Greptile reports 5/5](https://github.com/paperclipai/paperclip/pull/21458#issuecomment-6861824451) on that same head with no open review threads. - Local scope: the 83 focused snapshot, use-case, route, adapter, and UI checks pass. The existing queue UI suite has 42 tests. The new route cases use real disposable Postgres and verify the resulting database state after reload. - Additional local full-suite attempt: 174 tests passed and 13 approval-related tests failed with cleanup timeouts, Postgres deadlocks, and duplicate-prefix errors after cleanup failed. The first failure, `queues request_confirmation resolution while its legacy source run is still running`, also fails on unchanged base code with the same 30-second `afterEach` and `afterAll` timeouts. This broader local run is not counted as a pass. No test timeout or assertion was weakened. CI supplies the broad passing result for the committed head. - `node scripts/local-verify.mjs --explain` returned exit 2 because the API documentation is a global CI input; all of its required CI lanes passed. The initial adapter attempt could not initialize local Postgres under the sandbox; the same six checks passed with local-process access. The initial cross-company fixture was corrected to use a distinct company prefix. ## Risks - This grants board operators a new action on agent-authored pending messages. The route must pass company membership and private-task access checks; the mutation retains its transaction, revision, and dispatch protections. - No schema or migration is required. The UI uses its existing discard control and error handling. - The staging task was inspected to confirm the cause. No staging data was deleted, and a deployed UI retest is not claimed by these local and CI checks. ## Model Used - OpenAI Codex, GPT-6, with reasoning, repository inspection, tool use, and code execution. The exact runtime model ID and context limit are not exposed in this session. ## Checklist - [x] I have included a thinking path that traces from project context to this change - [x] I have specified the model used (with version and capability details) - [x] I have checked ROADMAP.md and confirmed this PR does not duplicate planned core work - [x] I have searched GitHub for duplicate or related PRs and linked them above - [x] I have either (a) linked existing issues with `Fixes: #` / `Closes #` / `Refs #` OR (b) described the issue in-PR following the relevant issue template - [x] I have not referenced internal/instance-local Paperclip issues or links (only public GitHub `#NNN` / `github.com/paperclipai/paperclip` URLs) - [x] My branch name describes the change (e.g. `docs/...`, `fix/...`) and contains no internal Paperclip ticket id or instance-derived details - [x] I have run tests locally and they pass — the focused regression, adapter, and UI checks listed above; the additional broad local cleanup failure is documented separately - [x] I have added or updated tests where applicable - [x] I have updated relevant documentation to reflect my changes - [x] I have considered and documented any risks above - [x] All Paperclip CI gates are green - [x] Greptile is 5/5 with no open P2s, recommendations, or follow-ups - [x] I will address all Greptile and reviewer comments before requesting merge Co-authored-by: Paperclip <noreply@paperclip.ing>
594 lines
24 KiB
TypeScript
594 lines
24 KiB
TypeScript
import express from "express";
|
|
import request from "supertest";
|
|
import { beforeEach, describe, expect, it, vi } from "vitest";
|
|
import type { LogActivityInput } from "../services/activity-log.js";
|
|
import { hoistModuleGraph } from "./helpers/hoist-module-graph.js";
|
|
|
|
const mockIssueService = vi.hoisted(() => ({
|
|
getById: vi.fn(),
|
|
assertCheckoutOwner: vi.fn(),
|
|
getComment: vi.fn(),
|
|
removeComment: vi.fn(),
|
|
tombstoneComment: vi.fn(),
|
|
}));
|
|
|
|
const mockAccessService = vi.hoisted(() => ({
|
|
decide: vi.fn(async ({ action }: { action: string }) => ({
|
|
action, allowed: action === "issue:read", reason: "allow_default", explanation: "Fixture task is readable",
|
|
})),
|
|
canUser: vi.fn(),
|
|
hasPermission: vi.fn(),
|
|
}));
|
|
|
|
const mockHeartbeatService = vi.hoisted(() => ({
|
|
getRun: vi.fn(async (): Promise<unknown> => null),
|
|
getActiveRunForAgent: vi.fn(async () => null),
|
|
getQueuedAssignmentRunForIssue: vi.fn(async () => null),
|
|
}));
|
|
const mockAuthoritativeQueueWakes = vi.hoisted(() => [] as Array<Record<string, unknown>>);
|
|
|
|
const mockLogActivity = vi.hoisted(() => vi.fn(async (_db: unknown, _input: LogActivityInput) => undefined));
|
|
const mockFeedbackService = vi.hoisted(() => ({
|
|
listIssueVotesForUser: vi.fn(async () => []),
|
|
saveIssueVote: vi.fn(async () => ({ vote: null, consentEnabledNow: false, sharingEnabled: false })),
|
|
}));
|
|
const mockInstanceSettingsService = vi.hoisted(() => ({
|
|
get: vi.fn(async () => ({
|
|
id: "instance-settings-1",
|
|
general: {
|
|
censorUsernameInLogs: false,
|
|
feedbackDataSharingPreference: "prompt",
|
|
},
|
|
})),
|
|
getExperimental: vi.fn(async () => ({
|
|
enableExternalObjects: false,
|
|
})),
|
|
listCompanyIds: vi.fn(async () => ["company-1"]),
|
|
}));
|
|
const mockIssueThreadInteractionService = vi.hoisted(() => ({
|
|
expirePendingInteractionsForTerminalIssue: vi.fn(async () => []),
|
|
expireRequestConfirmationsSupersededByComment: vi.fn(async () => []),
|
|
expireStaleRequestConfirmationsForIssueDocument: vi.fn(async () => []),
|
|
}));
|
|
const mockDocumentAnnotationService = vi.hoisted(() => ({
|
|
cleanupForIssueCommentDeletion: vi.fn(async () => ({ deletedCommentIds: [] as string[], resolvedThreadIds: [] as string[] })),
|
|
remapOpenThreadsForDocument: vi.fn(async () => []),
|
|
}));
|
|
const mockDecisionTrainingService = vi.hoisted(() => ({
|
|
scrubDeletedComments: vi.fn(async () => ({ updatedCount: 0 })),
|
|
}));
|
|
const mockIssueReferenceService = vi.hoisted(() => ({
|
|
deleteCommentSource: vi.fn(async () => undefined),
|
|
deleteDocumentSource: vi.fn(async () => undefined),
|
|
diffIssueReferenceSummary: vi.fn(() => ({
|
|
addedReferencedIssues: [],
|
|
removedReferencedIssues: [],
|
|
currentReferencedIssues: [],
|
|
})),
|
|
emptySummary: vi.fn(() => ({ outbound: [], inbound: [] })),
|
|
listIssueReferenceSummary: vi.fn(async () => ({ outbound: [], inbound: [] })),
|
|
syncComment: vi.fn(async () => undefined),
|
|
syncDocument: vi.fn(async () => undefined),
|
|
syncIssue: vi.fn(async () => undefined),
|
|
}));
|
|
const mockExternalObjectService = vi.hoisted(() => ({
|
|
getIssueSummaries: vi.fn(async () => ({ summaries: {} })),
|
|
getIssueSummary: vi.fn(async () => ({
|
|
authRequiredCount: 0,
|
|
byLiveness: {},
|
|
byStatusCategory: {},
|
|
highestSeverity: "muted",
|
|
objects: [],
|
|
staleCount: 0,
|
|
total: 0,
|
|
unreachableCount: 0,
|
|
})),
|
|
listForIssue: vi.fn(async () => []),
|
|
refreshIssueObjects: vi.fn(async () => []),
|
|
syncCommentSafely: vi.fn(async () => undefined),
|
|
syncDocumentSafely: vi.fn(async () => undefined),
|
|
syncIssueSafely: vi.fn(async () => undefined),
|
|
}));
|
|
|
|
function registerModuleMocks() {
|
|
vi.doMock("@paperclipai/shared/telemetry", () => ({
|
|
trackAgentTaskCompleted: vi.fn(),
|
|
trackErrorHandlerCrash: vi.fn(),
|
|
}));
|
|
|
|
vi.doMock("../telemetry.js", () => ({
|
|
getTelemetryClient: vi.fn(() => ({ track: vi.fn() })),
|
|
}));
|
|
|
|
vi.doMock("../services/access.js", () => ({
|
|
accessService: () => mockAccessService,
|
|
}));
|
|
|
|
vi.doMock("../services/activity-log.js", () => ({
|
|
logActivity: mockLogActivity,
|
|
}));
|
|
|
|
vi.doMock("../services/decision-training.js", () => ({
|
|
decisionTrainingService: () => mockDecisionTrainingService,
|
|
}));
|
|
|
|
vi.doMock("../services/feedback.js", () => ({
|
|
feedbackService: () => mockFeedbackService,
|
|
}));
|
|
|
|
vi.doMock("../services/heartbeat.js", () => ({
|
|
heartbeatService: () => mockHeartbeatService,
|
|
}));
|
|
|
|
vi.doMock("../services/instance-settings.js", () => ({
|
|
instanceSettingsService: () => mockInstanceSettingsService,
|
|
}));
|
|
|
|
vi.doMock("../services/issues.js", () => ({
|
|
issueService: () => mockIssueService,
|
|
}));
|
|
|
|
vi.doMock("../services/external-objects.js", () => ({
|
|
externalObjectService: () => mockExternalObjectService,
|
|
}));
|
|
|
|
vi.doMock("../services/index.js", () => ({
|
|
companyService: () => ({
|
|
getById: vi.fn(async () => ({ id: "company-1" })),
|
|
}),
|
|
accessService: () => mockAccessService,
|
|
agentService: () => ({ getById: vi.fn(async () => null) }),
|
|
companySkillService: () => ({
|
|
completeTestRunForIssue: vi.fn(async () => null),
|
|
}),
|
|
documentAnnotationService: () => mockDocumentAnnotationService,
|
|
documentService: () => ({}),
|
|
executionWorkspaceService: () => ({}),
|
|
feedbackService: () => mockFeedbackService,
|
|
goalService: () => ({}),
|
|
heartbeatService: () => mockHeartbeatService,
|
|
instanceSettingsService: () => mockInstanceSettingsService,
|
|
issueApprovalService: () => ({}),
|
|
issueRecoveryActionService: () => ({
|
|
getActiveForIssue: vi.fn(async () => null),
|
|
listActiveForIssues: vi.fn(async () => new Map()),
|
|
}),
|
|
issueReferenceService: () => mockIssueReferenceService,
|
|
issueService: () => mockIssueService,
|
|
issueThreadInteractionService: () => mockIssueThreadInteractionService,
|
|
logActivity: mockLogActivity,
|
|
projectService: () => ({}),
|
|
routineService: () => ({ syncRunStatusForIssue: vi.fn(async () => undefined) }),
|
|
workProductService: () => ({}),
|
|
}));
|
|
}
|
|
|
|
let lastErrorContext: unknown;
|
|
|
|
function describeResponse(res: request.Response) {
|
|
return JSON.stringify({ body: res.body, errorContext: lastErrorContext });
|
|
}
|
|
|
|
function makeIssue() {
|
|
return {
|
|
id: "11111111-1111-4111-8111-111111111111",
|
|
companyId: "company-1",
|
|
status: "in_progress",
|
|
assigneeAgentId: "22222222-2222-4222-8222-222222222222",
|
|
assigneeUserId: null,
|
|
executionRunId: "run-1",
|
|
identifier: "PAP-1353",
|
|
title: "Queued cancel",
|
|
};
|
|
}
|
|
|
|
const finalDenial = "Only the author of a queued comment can discard it, from that queued message's menu on [PAP-1353](/PAP/issues/PAP-1353). "
|
|
+ "This denial is final: no board, admin or agent override exists, so do not try other routes. Tell the author to discard it there.";
|
|
|
|
function makeComment(overrides: Record<string, unknown> = {}) {
|
|
return {
|
|
id: "comment-1",
|
|
companyId: "company-1",
|
|
issueId: "11111111-1111-4111-8111-111111111111",
|
|
authorAgentId: null,
|
|
authorUserId: "local-board",
|
|
body: "Queued follow-up",
|
|
createdAt: new Date("2026-04-11T15:01:00.000Z"),
|
|
updatedAt: new Date("2026-04-11T15:01:00.000Z"),
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
describe("issue comment cancel routes", () => {
|
|
const routeModules = hoistModuleGraph(registerModuleMocks, async () => {
|
|
const [{ issueRoutes }, { errorHandler }] = await Promise.all([
|
|
vi.importActual<typeof import("../routes/issues.js")>("../routes/issues.js"),
|
|
vi.importActual<typeof import("../middleware/index.js")>("../middleware/index.js"),
|
|
]);
|
|
return { issueRoutes, errorHandler };
|
|
});
|
|
|
|
function installActor(app: express.Express, actor?: Record<string, unknown>) {
|
|
const { issueRoutes, errorHandler } = routeModules.value;
|
|
|
|
app.use((req, res, next) => {
|
|
res.on("finish", () => {
|
|
lastErrorContext = (res as any).__errorContext ?? null;
|
|
});
|
|
(req as any).actor = actor ?? {
|
|
type: "board",
|
|
userId: "local-board",
|
|
companyIds: ["company-1"],
|
|
source: "local_implicit",
|
|
isInstanceAdmin: false,
|
|
};
|
|
next();
|
|
});
|
|
const db = {
|
|
select: vi.fn(() => ({
|
|
from: vi.fn(() => ({
|
|
where: vi.fn(() => ({
|
|
orderBy: vi.fn(async () => mockAuthoritativeQueueWakes),
|
|
// Agent mutation guards read a single row (no task-watchdog run here).
|
|
then: (resolve: (rows: unknown[]) => unknown, reject?: (error: unknown) => unknown) =>
|
|
Promise.resolve([]).then(resolve, reject),
|
|
})),
|
|
})),
|
|
})),
|
|
};
|
|
app.use("/api", issueRoutes(db as any, {} as any));
|
|
app.use(errorHandler);
|
|
return app;
|
|
}
|
|
|
|
function createApp() {
|
|
const app = express();
|
|
app.use(express.json());
|
|
return app;
|
|
}
|
|
|
|
beforeEach(() => {
|
|
lastErrorContext = undefined;
|
|
vi.clearAllMocks();
|
|
mockIssueService.getById.mockResolvedValue(makeIssue());
|
|
mockIssueService.assertCheckoutOwner.mockResolvedValue({ adoptedFromRunId: null });
|
|
mockIssueService.getComment.mockResolvedValue(makeComment());
|
|
mockIssueService.removeComment.mockResolvedValue(makeComment());
|
|
mockIssueService.tombstoneComment.mockImplementation(async (_commentId, _actor, options) => {
|
|
const deleted = makeComment({
|
|
body: "",
|
|
metadata: null,
|
|
deletedAt: new Date("2026-04-11T15:05:00.000Z"),
|
|
deletedByType: "user",
|
|
deletedByAgentId: null,
|
|
deletedByUserId: "local-board",
|
|
deletedByRunId: null,
|
|
});
|
|
await options?.afterTombstone?.(deleted, "tx");
|
|
return deleted;
|
|
});
|
|
mockAccessService.decide.mockImplementation(async ({ action }: { action: string }) => ({
|
|
action, allowed: action === "issue:read", reason: "allow_default", explanation: "Fixture task is readable",
|
|
}));
|
|
mockAccessService.canUser.mockResolvedValue(false);
|
|
mockAccessService.hasPermission.mockResolvedValue(false);
|
|
mockFeedbackService.listIssueVotesForUser.mockResolvedValue([]);
|
|
mockFeedbackService.saveIssueVote.mockResolvedValue({
|
|
vote: null,
|
|
consentEnabledNow: false,
|
|
sharingEnabled: false,
|
|
});
|
|
mockHeartbeatService.getRun.mockResolvedValue({
|
|
id: "run-1",
|
|
companyId: "company-1",
|
|
agentId: "22222222-2222-4222-8222-222222222222",
|
|
status: "running",
|
|
startedAt: new Date("2026-04-11T15:00:00.000Z"),
|
|
createdAt: new Date("2026-04-11T14:59:00.000Z"),
|
|
});
|
|
mockHeartbeatService.getActiveRunForAgent.mockResolvedValue(null);
|
|
mockAuthoritativeQueueWakes.length = 0;
|
|
mockInstanceSettingsService.get.mockResolvedValue({
|
|
id: "instance-settings-1",
|
|
general: {
|
|
censorUsernameInLogs: false,
|
|
feedbackDataSharingPreference: "prompt",
|
|
},
|
|
});
|
|
mockInstanceSettingsService.getExperimental.mockResolvedValue({
|
|
enableExternalObjects: false,
|
|
});
|
|
mockInstanceSettingsService.listCompanyIds.mockResolvedValue(["company-1"]);
|
|
mockLogActivity.mockResolvedValue(undefined);
|
|
mockDocumentAnnotationService.cleanupForIssueCommentDeletion.mockResolvedValue({
|
|
deletedCommentIds: [],
|
|
resolvedThreadIds: [],
|
|
});
|
|
mockIssueReferenceService.deleteCommentSource.mockResolvedValue(undefined);
|
|
mockIssueReferenceService.syncComment.mockResolvedValue(undefined);
|
|
mockExternalObjectService.syncCommentSafely.mockResolvedValue(undefined);
|
|
});
|
|
|
|
it("cancels a queued comment from its author and restores the deleted body", async () => {
|
|
const res = await request(await installActor(createApp()))
|
|
.delete("/api/issues/11111111-1111-4111-8111-111111111111/comments/comment-1?mode=cancel");
|
|
|
|
expect(res.status, JSON.stringify({
|
|
body: res.body,
|
|
tombstoneCalls: mockIssueService.tombstoneComment.mock.calls,
|
|
activityCalls: mockLogActivity.mock.calls,
|
|
})).toBe(200);
|
|
expect(res.body).toMatchObject({
|
|
id: "comment-1",
|
|
body: "Queued follow-up",
|
|
});
|
|
expect(mockIssueService.removeComment).toHaveBeenCalledWith("comment-1");
|
|
expect(mockLogActivity).toHaveBeenCalledWith(
|
|
expect.anything(),
|
|
expect.objectContaining({
|
|
action: "issue.comment_cancelled",
|
|
details: expect.objectContaining({
|
|
commentId: "comment-1",
|
|
source: "queue_cancel",
|
|
queueTargetRunId: "run-1",
|
|
}),
|
|
}),
|
|
);
|
|
});
|
|
|
|
it("rejects stale queued cancellation after the active run is gone", async () => {
|
|
mockHeartbeatService.getRun.mockResolvedValue(null);
|
|
|
|
const res = await request(await installActor(createApp()))
|
|
.delete("/api/issues/11111111-1111-4111-8111-111111111111/comments/comment-1?mode=cancel");
|
|
|
|
expect(res.status).toBe(409);
|
|
expect(res.body.error).toBe("Queued comment can no longer be canceled");
|
|
expect(mockIssueService.removeComment).not.toHaveBeenCalled();
|
|
expect(mockIssueService.tombstoneComment).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("rejects canceling comments that are no longer queued", async () => {
|
|
mockIssueService.getComment.mockResolvedValue(
|
|
makeComment({
|
|
createdAt: new Date("2026-04-11T14:58:00.000Z"),
|
|
updatedAt: new Date("2026-04-11T14:58:00.000Z"),
|
|
}),
|
|
);
|
|
|
|
const res = await request(await installActor(createApp()))
|
|
.delete("/api/issues/11111111-1111-4111-8111-111111111111/comments/comment-1?mode=cancel");
|
|
|
|
expect(res.status).toBe(409);
|
|
expect(res.body.error).toBe("Only queued comments can be canceled");
|
|
expect(mockIssueService.removeComment).not.toHaveBeenCalled();
|
|
expect(mockIssueService.tombstoneComment).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("rejects canceling another actor's queued comment", async () => {
|
|
mockIssueService.getComment.mockResolvedValue(
|
|
makeComment({
|
|
authorUserId: "someone-else",
|
|
}),
|
|
);
|
|
|
|
const res = await request(await installActor(createApp()))
|
|
.delete("/api/issues/11111111-1111-4111-8111-111111111111/comments/comment-1?mode=cancel");
|
|
|
|
expect(res.status).toBe(403);
|
|
expect(res.body.error).toBe(finalDenial);
|
|
expect(mockIssueService.removeComment).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("tells an agent that discarding a person's queued comment is author-only and final, with the task link", async () => {
|
|
const agent = { type: "agent", agentId: "22222222-2222-4222-8222-222222222222", companyId: "company-1", runId: "run-1", source: "agent_key" };
|
|
const res = await request(await installActor(createApp(), agent))
|
|
.delete("/api/issues/11111111-1111-4111-8111-111111111111/queued-comments/comment-1")
|
|
.send({ queueId: "queue-1", revision: "revision-1" });
|
|
|
|
expect(res.status).toBe(403);
|
|
expect(res.body.error).toBe(finalDenial);
|
|
expect(res.body.error).not.toBe("Board access required");
|
|
expect(mockIssueService.removeComment).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("points a non-author agent at a board user for an agent-authored queued message", async () => {
|
|
mockIssueService.getComment.mockResolvedValue(makeComment({
|
|
authorUserId: null, authorAgentId: "33333333-3333-4333-8333-333333333333",
|
|
}));
|
|
const agent = { type: "agent", agentId: "22222222-2222-4222-8222-222222222222", companyId: "company-1", runId: "run-1", source: "agent_key" };
|
|
const res = await request(await installActor(createApp(), agent))
|
|
.delete("/api/issues/11111111-1111-4111-8111-111111111111/queued-comments/comment-1")
|
|
.send({ queueId: "queue-1", revision: "revision-1" });
|
|
|
|
expect(res.status).toBe(403);
|
|
expect(res.body.error).toContain("board user with access");
|
|
expect(res.body.error).toContain("[PAP-1353](/PAP/issues/PAP-1353)");
|
|
expect(res.body.error).not.toContain("no board, admin or agent override");
|
|
expect(mockIssueService.removeComment).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("returns 404 without task details when the agent cannot read the private task", async () => {
|
|
mockAccessService.decide.mockImplementation(async ({ action }: { action: string }) => ({
|
|
action, allowed: false, reason: "deny_issue_private", explanation: "Private task",
|
|
}));
|
|
const agent = { type: "agent", agentId: "33333333-3333-4333-8333-333333333333", companyId: "company-1", runId: "run-9", source: "agent_key" };
|
|
const res = await request(await installActor(createApp(), agent))
|
|
.delete("/api/issues/11111111-1111-4111-8111-111111111111/queued-comments/comment-1")
|
|
.send({ queueId: "queue-1", revision: "revision-1" });
|
|
|
|
expect(res.status).toBe(404);
|
|
expect(JSON.stringify(res.body)).not.toContain("PAP-1353");
|
|
});
|
|
|
|
it("points an author agent at the cancel route it can use instead of claiming no route exists", async () => {
|
|
mockIssueService.getComment.mockResolvedValue(makeComment({ authorUserId: null, authorAgentId: "33333333-3333-4333-8333-333333333333" }));
|
|
const agent = { type: "agent", agentId: "33333333-3333-4333-8333-333333333333", companyId: "company-1", runId: "run-9", source: "agent_key" };
|
|
const res = await request(await installActor(createApp(), agent))
|
|
.delete("/api/issues/11111111-1111-4111-8111-111111111111/queued-comments/comment-1")
|
|
.send({ queueId: "queue-1", revision: "revision-1" });
|
|
|
|
expect(res.status).toBe(403);
|
|
expect(res.body.error).toContain("/api/issues/11111111-1111-4111-8111-111111111111/comments/comment-1?mode=cancel");
|
|
expect(res.body.error).not.toContain("final");
|
|
});
|
|
|
|
it("lets an author agent discard its own queued comment through the cancel route", async () => {
|
|
// Another agent queued this comment behind the assignee's active run; it can read and write the task.
|
|
mockAccessService.decide.mockImplementation(async ({ action }: { action: string }) => ({
|
|
action, allowed: true, reason: "allow_default", explanation: "Assignee task",
|
|
}));
|
|
mockIssueService.getComment.mockResolvedValue(makeComment({ authorUserId: null, authorAgentId: "33333333-3333-4333-8333-333333333333" }));
|
|
mockIssueService.removeComment.mockResolvedValue(makeComment({ authorUserId: null, authorAgentId: "33333333-3333-4333-8333-333333333333" }));
|
|
const agent = { type: "agent", agentId: "33333333-3333-4333-8333-333333333333", companyId: "company-1", runId: "run-9", source: "agent_key" };
|
|
const res = await request(await installActor(createApp(), agent))
|
|
.delete("/api/issues/11111111-1111-4111-8111-111111111111/comments/comment-1?mode=cancel");
|
|
|
|
expect(res.status, JSON.stringify(res.body)).toBe(200);
|
|
expect(mockIssueService.removeComment).toHaveBeenCalledWith("comment-1");
|
|
});
|
|
|
|
it("returns 404 instead of the author-only denial when a non-author cannot read the task", async () => {
|
|
mockIssueService.getComment.mockResolvedValue(makeComment({ authorUserId: "someone-else" }));
|
|
mockAccessService.decide.mockImplementation(async ({ action }: { action: string }) => ({
|
|
action, allowed: false, reason: "deny_issue_private", explanation: "Private task",
|
|
}));
|
|
const res = await request(await installActor(createApp()))
|
|
.delete("/api/issues/11111111-1111-4111-8111-111111111111/comments/comment-1?mode=cancel");
|
|
|
|
expect(res.status).not.toBe(403);
|
|
expect(JSON.stringify(res.body)).not.toContain("PAP-1353");
|
|
expect(mockIssueService.removeComment).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("does not reveal another company's task through the agent queued-comment denial", async () => {
|
|
mockIssueService.getById.mockResolvedValue({ ...makeIssue(), companyId: "company-2" });
|
|
const agent = { type: "agent", agentId: "22222222-2222-4222-8222-222222222222", companyId: "company-1", runId: "run-1", source: "agent_key" };
|
|
const res = await request(await installActor(createApp(), agent))
|
|
.delete("/api/issues/11111111-1111-4111-8111-111111111111/queued-comments/comment-1")
|
|
.send({ queueId: "queue-1", revision: "revision-1" });
|
|
|
|
expect(res.status).toBe(404);
|
|
expect(JSON.stringify(res.body)).not.toContain("PAP-1353");
|
|
});
|
|
|
|
it("deletes a normal authored comment as a tombstone without returning the original body", async () => {
|
|
mockIssueService.getComment.mockResolvedValue(
|
|
makeComment({
|
|
body: "Sensitive original comment body",
|
|
metadata: { version: 1, sections: [{ rows: [{ type: "text", text: "Sensitive metadata copy" }] }] },
|
|
createdAt: new Date("2026-04-11T14:58:00.000Z"),
|
|
updatedAt: new Date("2026-04-11T14:58:00.000Z"),
|
|
}),
|
|
);
|
|
mockDocumentAnnotationService.cleanupForIssueCommentDeletion.mockResolvedValue({
|
|
deletedCommentIds: ["annotation-comment-1"],
|
|
resolvedThreadIds: ["annotation-thread-1"],
|
|
});
|
|
|
|
const res = await request(await installActor(createApp()))
|
|
.delete("/api/issues/11111111-1111-4111-8111-111111111111/comments/comment-1");
|
|
|
|
expect(res.status, describeResponse(res)).toBe(200);
|
|
expect(res.body).toMatchObject({
|
|
id: "comment-1",
|
|
body: "",
|
|
metadata: null,
|
|
deletedByType: "user",
|
|
deletedByUserId: "local-board",
|
|
});
|
|
expect(JSON.stringify(res.body)).not.toContain("Sensitive original comment body");
|
|
expect(JSON.stringify(res.body)).not.toContain("Sensitive metadata copy");
|
|
expect(mockIssueService.removeComment).not.toHaveBeenCalled();
|
|
expect(mockIssueService.tombstoneComment).toHaveBeenCalledWith(
|
|
"comment-1",
|
|
{
|
|
actorType: "user",
|
|
agentId: null,
|
|
userId: "local-board",
|
|
runId: null,
|
|
},
|
|
expect.objectContaining({ afterTombstone: expect.any(Function) }),
|
|
);
|
|
expect(mockIssueReferenceService.syncComment).toHaveBeenCalledWith("comment-1", "tx");
|
|
expect(mockExternalObjectService.syncCommentSafely).toHaveBeenCalledWith("comment-1", "tx");
|
|
expect(mockDocumentAnnotationService.cleanupForIssueCommentDeletion).toHaveBeenCalledWith(
|
|
"11111111-1111-4111-8111-111111111111",
|
|
"comment-1",
|
|
expect.objectContaining({
|
|
actorType: "user",
|
|
userId: "local-board",
|
|
}),
|
|
"tx",
|
|
);
|
|
expect(mockIssueReferenceService.deleteCommentSource).toHaveBeenCalledWith("annotation-comment-1", "tx");
|
|
expect(mockExternalObjectService.syncCommentSafely).toHaveBeenCalledWith("annotation-comment-1", "tx");
|
|
expect(mockDecisionTrainingService.scrubDeletedComments).toHaveBeenCalledWith({
|
|
companyId: "company-1",
|
|
issueId: "11111111-1111-4111-8111-111111111111",
|
|
commentIds: ["comment-1", "annotation-comment-1"],
|
|
deletedAt: new Date("2026-04-11T15:05:00.000Z"),
|
|
}, "tx");
|
|
const deletedActivity = mockLogActivity.mock.calls.find((call) => call[1]?.action === "issue.comment_deleted")?.[1];
|
|
expect(deletedActivity).toEqual(expect.objectContaining({
|
|
action: "issue.comment_deleted",
|
|
details: expect.objectContaining({
|
|
deletedAnnotationCommentIds: ["annotation-comment-1"],
|
|
resolvedAnnotationThreadIds: ["annotation-thread-1"],
|
|
}),
|
|
}));
|
|
expect(deletedActivity?.details).toEqual(expect.not.objectContaining({
|
|
bodySnippet: expect.anything(),
|
|
}));
|
|
expect(JSON.stringify(deletedActivity?.details ?? {})).not.toContain("Sensitive original comment body");
|
|
expect(JSON.stringify(deletedActivity?.details ?? {})).not.toContain("Sensitive metadata copy");
|
|
});
|
|
|
|
it("tombstones normally after the comment's queued wake has completed", async () => {
|
|
mockHeartbeatService.getRun.mockResolvedValue(null);
|
|
mockAuthoritativeQueueWakes.push({
|
|
id: "wake-1",
|
|
companyId: "company-1",
|
|
agentId: "22222222-2222-4222-8222-222222222222",
|
|
runId: "run-1",
|
|
status: "succeeded",
|
|
payload: {
|
|
issueId: "11111111-1111-4111-8111-111111111111",
|
|
_paperclipWakeContext: {
|
|
wakeCommentIds: ["comment-1"],
|
|
},
|
|
},
|
|
requestedAt: new Date("2026-04-11T15:02:00.000Z"),
|
|
});
|
|
|
|
const res = await request(await installActor(createApp()))
|
|
.delete("/api/issues/11111111-1111-4111-8111-111111111111/comments/comment-1");
|
|
|
|
expect(res.status, describeResponse(res)).toBe(200);
|
|
expect(mockIssueService.tombstoneComment).toHaveBeenCalledWith(
|
|
"comment-1",
|
|
expect.anything(),
|
|
expect.objectContaining({ afterTombstone: expect.any(Function) }),
|
|
);
|
|
expect(mockIssueService.removeComment).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("rejects deleting another actor's normal comment", async () => {
|
|
mockIssueService.getComment.mockResolvedValue(
|
|
makeComment({
|
|
authorUserId: "someone-else",
|
|
createdAt: new Date("2026-04-11T14:58:00.000Z"),
|
|
updatedAt: new Date("2026-04-11T14:58:00.000Z"),
|
|
}),
|
|
);
|
|
|
|
const res = await request(await installActor(createApp()))
|
|
.delete("/api/issues/11111111-1111-4111-8111-111111111111/comments/comment-1");
|
|
|
|
expect(res.status).toBe(403);
|
|
expect(res.body.error).toBe("Only the comment author can delete comments");
|
|
expect(mockIssueService.removeComment).not.toHaveBeenCalled();
|
|
expect(mockIssueService.tombstoneComment).not.toHaveBeenCalled();
|
|
});
|
|
});
|