import { randomUUID } from "node:crypto"; import { and, eq, sql } from "drizzle-orm"; import { afterAll, beforeAll, describe, expect, it, vi } from "vitest"; import { agents, companies, createDb, documents, heartbeatRuns, issueComments, issueThreadInteractions, issueWorkProducts, issues, EMBEDDED_POSTGRES_TEST_TIMEOUT_MS } from "@paperclipai/db"; import { buildAgentMentionHref } from "@paperclipai/shared"; import { startEmbeddedPostgresTestDatabase } from "./helpers/embedded-postgres.js"; import { issueService } from "../services/issues.js"; import { documentService } from "../services/documents.js"; import { workProductService } from "../services/work-products.js"; import { buildHostServices } from "../services/plugin-host-services.js"; import { withPluginInteractionOrigin } from "../services/plugin-interaction-context.js"; import { issueThreadInteractionService } from "../services/issue-thread-interactions.js"; import { PaperclipRunnerToolAuthority } from "../services/native-runtime/paperclip-runner-tool-authority.js"; describe("agent interaction mutation boundaries", () => { let database: Awaited>; let db: ReturnType; beforeAll(async () => { database = await startEmbeddedPostgresTestDatabase("agent-interaction-mutations-"); db = createDb(database.connectionString); }, EMBEDDED_POSTGRES_TEST_TIMEOUT_MS); afterAll(async () => { await db?.$client.end(); await database?.cleanup(); }); async function seed() { const companyId = randomUUID(), sender = randomUUID(), recipient = randomUUID(), issueId = randomUUID(); await db.insert(companies).values({ id: companyId, name: "Interactions", issuePrefix: `I${companyId.slice(0, 6)}` }); await db.insert(agents).values([ { id: sender, companyId, name: "Sender", adapterType: "process", status: "idle", permissions: {} }, { id: recipient, companyId, name: "Recipient", adapterType: "process", status: "idle", permissions: {} }, ]); await db.insert(issues).values({ id: issueId, companyId, title: "Original", status: "todo", assigneeAgentId: recipient }); return { companyId, sender, recipient, issueId }; } async function restrict(agentId: string, interactions: Record) { await db.update(agents).set({ permissions: { interactions } }).where(eq(agents.id, agentId)); } const denied = (permission: string) => ({ status: 403, details: expect.objectContaining({ code: "agent_interaction_denied", permission }) }); it("keeps unrestricted peer comments and edits working without persisting defaults", async () => { const f = await seed(), svc = issueService(db); await svc.addComment(f.issueId, "Peer reply", { agentId: f.sender }); await svc.update(f.issueId, { title: "Edited", actorAgentId: f.sender }); const [task] = await db.select().from(issues).where(eq(issues.id, f.issueId)); const rows = await db.select().from(agents).where(eq(agents.companyId, f.companyId)); expect(task.title).toBe("Edited"); expect(rows.every(row => Object.keys(row.permissions).length === 0)).toBe(true); }); it("blocks incoming comments before saving anything, including through plugin host services", async () => { const f = await seed(); await restrict(f.recipient, { canReceiveCommentsFromAgents: false }); const services = buildHostServices(db, "interaction-test", "interaction-test", { forPlugin: () => ({ emit: vi.fn(), subscribe: vi.fn(), clear: vi.fn() }), } as any); try { await expect(services.issues.createComment({ companyId: f.companyId, issueId: f.issueId, body: "Blocked plugin reply", authorAgentId: f.sender })).rejects.toMatchObject(denied("canReceiveCommentsFromAgents")); expect(await db.select().from(issueComments).where(eq(issueComments.issueId, f.issueId))).toEqual([]); } finally { services.dispose(); } }); it("rejects an outgoing comment on an unassigned task but permits self comments", async () => { const f = await seed(), svc = issueService(db); await restrict(f.sender, { canCommentOnOtherTasks: false }); await db.update(issues).set({ assigneeAgentId: null }).where(eq(issues.id, f.issueId)); await expect(svc.addComment(f.issueId, "No", { agentId: f.sender })).rejects.toMatchObject(denied("canCommentOnOtherTasks")); await db.update(issues).set({ assigneeAgentId: f.sender }).where(eq(issues.id, f.issueId)); await svc.addComment(f.issueId, "Own work", { agentId: f.sender }); expect(await db.select().from(issueComments).where(eq(issueComments.issueId, f.issueId))).toHaveLength(1); }); it("rejects structured forbidden mentions even on the sender's own task", async () => { const f = await seed(), svc = issueService(db); await db.update(issues).set({ assigneeAgentId: f.sender }).where(eq(issues.id, f.issueId)); await restrict(f.recipient, { canReceiveMentionsFromAgents: false }); const mention = `[@Recipient](${buildAgentMentionHref(f.recipient)})`; await expect(svc.addComment(f.issueId, mention, { agentId: f.sender })).rejects.toMatchObject(denied("canReceiveMentionsFromAgents")); await expect(svc.update(f.issueId, { description: mention, actorAgentId: f.sender })).rejects.toMatchObject(denied("canReceiveMentionsFromAgents")); const [task] = await db.select().from(issues).where(eq(issues.id, f.issueId)); expect(task.description).toBeNull(); expect(await db.select().from(issueComments).where(eq(issueComments.issueId, f.issueId))).toEqual([]); await svc.addComment(f.issueId, "Plain prose about Recipient", { agentId: f.sender }); }); it("blocks peer edits and reassignment-to-self against the current owner", async () => { const f = await seed(), svc = issueService(db); await restrict(f.recipient, { canReceiveTaskEditsFromAgents: false }); await expect(svc.update(f.issueId, { description: "New instructions", actorAgentId: f.sender })).rejects.toMatchObject(denied("canReceiveTaskEditsFromAgents")); await expect(svc.update(f.issueId, { assigneeAgentId: f.sender, actorAgentId: f.sender })).rejects.toMatchObject(denied("canReceiveTaskEditsFromAgents")); expect((await db.select().from(issues).where(eq(issues.id, f.issueId)))[0].assigneeAgentId).toBe(f.recipient); }); it("keeps comments independent from task-edit permission", async () => { const f = await seed(), svc = issueService(db); await restrict(f.sender, { canEditOtherTasks: false }); await svc.addComment(f.issueId, "Allowed comment", { agentId: f.sender }); await svc.update(f.issueId, { actorAgentId: f.sender }); await expect(svc.update(f.issueId, { title: "No", actorAgentId: f.sender })).rejects.toMatchObject(denied("canEditOtherTasks")); }); it("rejects creating work for a protected recipient without inserting a task", async () => { const f = await seed(); await restrict(f.recipient, { canReceiveAssignmentsFromAgents: false }); await expect(issueService(db).create(f.companyId, { title: "Blocked new work", createdByAgentId: f.sender, assigneeAgentId: f.recipient, status: "todo" })).rejects.toMatchObject(denied("canReceiveAssignmentsFromAgents")); expect(await db.select().from(issues).where(eq(issues.companyId, f.companyId))).toHaveLength(1); }); it("allows initial plan content under assignment authority without requiring peer edit permission", async () => { const f = await seed(); await restrict(f.sender, { canEditOtherTasks: false }); await restrict(f.recipient, { canReceiveTaskEditsFromAgents: false }); const created = await issueService(db).create(f.companyId, { title: "New assigned work", createdByAgentId: f.sender, assigneeAgentId: f.recipient, initialPlan: "Initial instructions", status: "todo" }); expect((await documentService(db).getIssueDocumentByKey(created.id, "plan"))?.body).toBe("Initial instructions"); await expect(documentService(db).upsertIssueDocument({ issueId: created.id, key: "notes", format: "markdown", body: "Later instructions", createdByAgentId: f.sender })).rejects.toMatchObject(denied("canEditOtherTasks")); }); it("checks assignment restrictions on native create_task before saving tasks or enqueueing wakes", async () => { const f = await seed(), runId = randomUUID(), wakes = vi.fn(); await db.update(issues).set({ assigneeAgentId: f.sender, status: "in_progress" }).where(eq(issues.id, f.issueId)); await db.update(agents).set({ adapterType: "paperclip_runner", status: "active" }).where(eq(agents.id, f.sender)); await db.insert(heartbeatRuns).values({ id: runId, companyId: f.companyId, agentId: f.sender, status: "running", runtimeMode: "native", nativeIssueId: f.issueId, invocationSource: "assignment", triggerDetail: "system", contextSnapshot: { issueId: f.issueId } }); await db.update(issues).set({ executionRunId: runId }).where(eq(issues.id, f.issueId)); await restrict(f.recipient, { canReceiveAssignmentsFromAgents: false }); const authority = new PaperclipRunnerToolAuthority(db, { companyId: f.companyId, agentId: f.sender, issueId: f.issueId, runId, enqueueWakeup: wakes }); await expect(authority.execute({ tool: "create_task", callId: randomUUID(), arguments: { idempotencyKey: "protected-recipient", title: "Delegated", assigneeActorId: f.recipient, } })).rejects.toMatchObject(denied("canReceiveAssignmentsFromAgents")); expect(await db.select().from(issues).where(eq(issues.companyId, f.companyId))).toHaveLength(1); expect(wakes).not.toHaveBeenCalled(); }); it("treats an agent-addressed review as assignment even when task ownership stays unchanged", async () => { const f = await seed(); await db.update(issues).set({ assigneeAgentId: f.sender }).where(eq(issues.id, f.issueId)); await restrict(f.recipient, { canReceiveAssignmentsFromAgents: false }); await expect(issueThreadInteractionService(db).create({ id: f.issueId, companyId: f.companyId }, { kind: "ask_user_questions", resolverPolicy: "board_or_agents", addresseeAgentId: f.recipient, continuationPolicy: "wake_assignee", payload: { version: 1, questions: [{ id: "review", prompt: "Review?", selectionMode: "single", options: [{ id: "yes", label: "Yes" }] }] }, }, { agentId: f.sender })).rejects.toMatchObject(denied("canReceiveAssignmentsFromAgents")); expect(await db.select().from(issueThreadInteractions).where(eq(issueThreadInteractions.issueId, f.issueId))).toEqual([]); }); it("rejects a native reassignment reason before stopping the currently running recipient", async () => { const f = await seed(), runId = randomUUID(), targetRunId = randomUUID(), stop = vi.fn(), wake = vi.fn(); await db.update(issues).set({ assigneeAgentId: f.sender, status: "in_progress" }).where(eq(issues.id, f.issueId)); await db.update(agents).set({ adapterType: "paperclip_runner", status: "active" }).where(eq(agents.id, f.sender)); const [target] = await db.insert(issues).values({ companyId: f.companyId, title: "Running peer task", status: "in_progress", assigneeAgentId: f.recipient }).returning(); await db.insert(heartbeatRuns).values([ { id: runId, companyId: f.companyId, agentId: f.sender, status: "running", runtimeMode: "native", nativeIssueId: f.issueId, invocationSource: "assignment", triggerDetail: "system", contextSnapshot: { issueId: f.issueId } }, { id: targetRunId, companyId: f.companyId, agentId: f.recipient, status: "running", runtimeMode: "native", nativeIssueId: target.id, invocationSource: "assignment", triggerDetail: "system", contextSnapshot: { issueId: target.id } }, ]); await db.update(issues).set({ executionRunId: runId }).where(eq(issues.id, f.issueId)); await db.update(issues).set({ executionRunId: targetRunId }).where(eq(issues.id, target.id)); await restrict(f.recipient, { canReceiveCommentsFromAgents: false }); const authority = new PaperclipRunnerToolAuthority(db, { companyId: f.companyId, agentId: f.sender, issueId: f.issueId, runId, enqueueWakeup: wake, stopTaskForReassignment: stop }); await expect(authority.execute({ tool: "reassign_task", callId: randomUUID(), arguments: { idempotencyKey: "protected-reason", taskId: target.id, assigneeActorId: f.sender, expectedAssigneeActorId: f.recipient, expectedAssigneeUserId: null, expectedStatusVersion: target.statusVersion, reason: "Taking over your task", } })).rejects.toMatchObject(denied("canReceiveCommentsFromAgents")); expect(stop).not.toHaveBeenCalled(); expect(wake).not.toHaveBeenCalled(); expect((await db.select().from(heartbeatRuns).where(eq(heartbeatRuns.id, targetRunId)))[0].status).toBe("running"); expect((await db.select().from(issues).where(eq(issues.id, target.id)))[0].assigneeAgentId).toBe(f.recipient); expect(await db.select().from(issueComments).where(eq(issueComments.issueId, target.id))).toEqual([]); }); it("protects peer configuration suggestions before creating a confirmation card", async () => { const f = await seed(); await db.update(issues).set({ assigneeAgentId: f.sender }).where(eq(issues.id, f.issueId)); await restrict(f.recipient, { canReceiveConfigurationChangesFromAgents: false }); await expect(issueThreadInteractionService(db).create({ id: f.issueId, companyId: f.companyId }, { kind: "request_confirmation", payload: { version: 1, prompt: "Change instructions?", target: { type: "custom", key: `agent:${f.recipient}:instructions`, revisionId: "proposed" } }, }, { agentId: f.sender })).rejects.toMatchObject(denied("canReceiveConfigurationChangesFromAgents")); expect(await db.select().from(issueThreadInteractions).where(eq(issueThreadInteractions.issueId, f.issueId))).toEqual([]); }); it("preserves trusted plugin origin despite a supplied human comment actor", async () => { const f = await seed(); const write = () => withPluginInteractionOrigin({ companyId: f.companyId, agentId: f.sender }, () => issueService(db).addComment(f.issueId, "Plugin reply", { userId: "local-board" })); const comment = await write(); expect(comment.authorAgentId).toBe(f.sender); expect(comment.authorUserId).toBeNull(); await restrict(f.recipient, { canReceiveCommentsFromAgents: false }); await expect(write()).rejects.toMatchObject(denied("canReceiveCommentsFromAgents")); expect(await db.select().from(issueComments).where(eq(issueComments.issueId, f.issueId))).toHaveLength(1); }); it("blocks plugin authorization-policy writes to a protected task", async () => { const f = await seed(); await restrict(f.recipient, { canReceiveTaskEditsFromAgents: false }); const services = buildHostServices(db, "interaction-test", "interaction-test", { forPlugin: () => ({ emit: vi.fn(), subscribe: vi.fn(), clear: vi.fn() }), } as any); try { await expect(withPluginInteractionOrigin({ companyId: f.companyId, agentId: f.sender }, () => services.authorization.updatePolicy({ companyId: f.companyId, resourceType: "issue", resourceId: f.issueId, policy: { example: "policy" } }))).rejects.toMatchObject(denied("canReceiveTaskEditsFromAgents")); expect((await db.select().from(issues).where(eq(issues.id, f.issueId)))[0].executionPolicy).toBeNull(); } finally { services.dispose(); } }); it("blocks parent influence when creating a child even if the child is self-assigned", async () => { const f = await seed(); await restrict(f.recipient, { canReceiveTaskEditsFromAgents: false }); await expect(issueService(db).create(f.companyId, { title: "Child", createdByAgentId: f.sender, assigneeAgentId: f.sender, parentId: f.issueId, status: "todo" })).rejects.toMatchObject(denied("canReceiveTaskEditsFromAgents")); expect(await db.select().from(issues).where(eq(issues.companyId, f.companyId))).toHaveLength(1); }); it("protects document writes and restores without adding revisions", async () => { const f = await seed(), svc = documentService(db); const original = await svc.upsertIssueDocument({ issueId: f.issueId, key: "plan", format: "markdown", body: "Original" }); await restrict(f.recipient, { canReceiveTaskEditsFromAgents: false }); await expect(svc.upsertIssueDocument({ issueId: f.issueId, key: "plan", format: "markdown", body: "Peer instructions", baseRevisionId: original.document.latestRevisionId, createdByAgentId: f.sender })).rejects.toMatchObject(denied("canReceiveTaskEditsFromAgents")); await expect(svc.deleteIssueDocument(f.issueId, "plan", f.sender)).rejects.toMatchObject(denied("canReceiveTaskEditsFromAgents")); expect((await svc.getIssueDocumentByKey(f.issueId, "plan"))?.body).toBe("Original"); }); it("checks mentions in documents and work products, and permits a human write", async () => { const f = await seed(), docs = documentService(db), products = workProductService(db); await restrict(f.sender, { canMentionAgents: false }); const mention = `[@Recipient](${buildAgentMentionHref(f.recipient)})`; await expect(docs.upsertIssueDocument({ issueId: f.issueId, key: "notes", format: "markdown", body: mention, createdByAgentId: f.sender })).rejects.toMatchObject(denied("canMentionAgents")); await expect(products.createForIssue(f.issueId, f.companyId, { type: "artifact", provider: "external", status: "ready", title: mention }, f.sender)) .rejects.toMatchObject(denied("canMentionAgents")); expect(await db.select().from(documents).where(eq(documents.companyId, f.companyId))).toEqual([]); expect(await db.select().from(issueWorkProducts).where(eq(issueWorkProducts.issueId, f.issueId))).toEqual([]); await docs.upsertIssueDocument({ issueId: f.issueId, key: "notes", format: "markdown", body: mention }); }); it("does not rescan an untouched historical mention when only unrelated fields change", async () => { const f = await seed(); await db.update(issues).set({ description: `[@Recipient](${buildAgentMentionHref(f.recipient)})` }).where(eq(issues.id, f.issueId)); await restrict(f.sender, { canMentionAgents: false }); await issueService(db).update(f.issueId, { priority: "high", actorAgentId: f.sender }); expect((await db.select().from(issues).where(and(eq(issues.id, f.issueId), eq(issues.companyId, f.companyId))))[0].priority).toBe("high"); }); it("checks a work product's destination task when moving it from the sender's own task", async () => { const f = await seed(), products = workProductService(db); const [own] = await db.insert(issues).values({ companyId: f.companyId, title: "Own task", assigneeAgentId: f.sender }).returning(); const product = await products.createForIssue(own.id, f.companyId, { type: "artifact", provider: "external", status: "ready", title: "Own output" }, f.sender); await restrict(f.recipient, { canReceiveTaskEditsFromAgents: false }); await expect(products.update(product!.id, { issueId: f.issueId }, f.sender)) .rejects.toMatchObject(denied("canReceiveTaskEditsFromAgents")); expect((await db.select().from(issueWorkProducts).where(eq(issueWorkProducts.id, product!.id)))[0].issueId).toBe(own.id); }); it("checks bulk import assignments before reserving issue numbers or inserting tasks", async () => { const f = await seed(); const [before] = await db.select().from(companies).where(eq(companies.id, f.companyId)); await restrict(f.recipient, { canReceiveAssignmentsFromAgents: false }); await expect(issueService(db).importIssues(f.companyId, [{ id: randomUUID(), ref: "imported", title: "Imported task", projectId: null, projectWorkspaceId: null, description: "New initial instructions", assigneeAgentId: f.recipient, status: "todo", priority: "medium", billingCode: null, assigneeAdapterOverrides: null, executionWorkspaceSettings: null, labelIds: [], monitorNotes: null, monitorScheduledBy: null, }], f.sender)).rejects.toMatchObject(denied("canReceiveAssignmentsFromAgents")); expect(await db.select().from(issues).where(eq(issues.companyId, f.companyId))).toHaveLength(1); expect((await db.select().from(companies).where(eq(companies.id, f.companyId)))[0].issueCounter).toBe(before.issueCounter); }); it("waits for company accounting before locking actors during task creation", async () => { const f = await seed(); let creation: Promise | undefined; try { await db.transaction(async importer => { await importer.select({ id: companies.id }).from(companies).where(eq(companies.id, f.companyId)).for("no key update"); let started!: (pid: number) => void; const creatorPid = new Promise(resolve => { started = resolve; }); creation = db.transaction(async creator => { const rows = await creator.execute<{ pid: number }>(sql`select pg_backend_pid() as pid`); started(rows[0].pid); return issueService(db).create(f.companyId, { title: "Concurrent creation", assigneeAgentId: f.recipient, createdByAgentId: f.sender, status: "todo" }, creator); }); const pid = await creatorPid; let waitingQuery = ""; for (let attempt = 0; attempt < 100; attempt += 1) { const rows = await db.execute<{ query: string; wait_event_type: string | null }>( sql`select query, wait_event_type from pg_stat_activity where pid = ${pid}`); if (rows[0]?.wait_event_type === "Lock") { waitingQuery = rows[0].query; break; } await new Promise(resolve => setTimeout(resolve, 10)); } expect(waitingQuery).toContain('"companies"'); await importer.execute(sql`select id from ${agents} where id in (${f.sender}, ${f.recipient}) for no key update nowait`); }); } finally { await creation; } expect(await db.select().from(issues).where(eq(issues.companyId, f.companyId))).toHaveLength(2); }); });