agent-tower 0.5.3 → 0.5.4-beta.1

package/dist/services/__tests__/team-run.service.test.js

@@ -7,12 +7,24 @@ import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vites
 const testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-tower-team-run-'));
 const dbPath = path.join(testDir, 'test.db');
 process.env.AGENT_TOWER_DATABASE_URL = `file:${dbPath}`;
-const { appendAttachmentMarkdownContextMock } = vi.hoisted(() => ({
+const { appendAttachmentMarkdownContextMock, fakeEventBus } = vi.hoisted(() => ({
     appendAttachmentMarkdownContextMock: vi.fn(),
+    fakeEventBus: {
+        emit: vi.fn(),
+        on: vi.fn(),
+        off: vi.fn(),
+    },
 }));
 vi.mock('../attachment-context.js', () => ({
     appendAttachmentMarkdownContext: appendAttachmentMarkdownContextMock,
 }));
+vi.mock('../../core/container.js', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        getEventBus: vi.fn(() => fakeEventBus),
+    };
+});
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const serverRoot = path.resolve(__dirname, '../../..');
@@ -54,7 +66,13 @@ function userMessagesPresetInput(name, aliases = [name.toLowerCase()]) {
 }
 function createGitRepoPath(label) {
     const repoPath = path.join(testDir, 'repos', `${label}-${gitRepoCounter++}`);
-    fs.mkdirSync(path.join(repoPath, '.git'), { recursive: true });
+    fs.mkdirSync(repoPath, { recursive: true });
+    execFileSync('git', ['init'], { cwd: repoPath, stdio: 'pipe' });
+    execFileSync('git', ['config', 'user.email', 'test@example.com'], { cwd: repoPath, stdio: 'pipe' });
+    execFileSync('git', ['config', 'user.name', 'Test User'], { cwd: repoPath, stdio: 'pipe' });
+    fs.writeFileSync(path.join(repoPath, 'README.md'), 'initial\n', 'utf-8');
+    execFileSync('git', ['add', 'README.md'], { cwd: repoPath, stdio: 'pipe' });
+    execFileSync('git', ['commit', '-m', 'initial commit'], { cwd: repoPath, stdio: 'pipe' });
     return repoPath;
 }
 async function createTask(title = 'Team task') {
@@ -85,6 +103,9 @@ describe('TeamRunService', () => {
         prisma = utilsModule.prisma;
     });
     beforeEach(async () => {
+        fakeEventBus.emit.mockClear();
+        fakeEventBus.on.mockClear();
+        fakeEventBus.off.mockClear();
         appendAttachmentMarkdownContextMock.mockImplementation(async (content, attachmentIds) => {
             const ids = Array.from(new Set((attachmentIds ?? []).map((id) => id.trim()).filter(Boolean)));
             if (ids.length === 0)
@@ -323,11 +344,43 @@ describe('TeamRunService', () => {
         expect(listed).toBeDefined();
         expect(listed?.content).not.toBe(fullContent);
         expect(listed?.contentPreview).toBe(listed?.content);
+        expect(listed?.contentMode).toBe('preview');
+        expect(listed?.fullContentAvailable).toBe(true);
         expect(listed?.isTruncated).toBe(true);
         expect(detail.content).toBe(fullContent);
         expect(detail.contentPreview).toBe(listed?.contentPreview);
+        expect(detail.contentMode).toBe('full');
+        expect(detail.fullContentAvailable).toBe(false);
         expect(detail.isTruncated).toBe(true);
     });
+    it('limits RoomMessage lists at the service query boundary while preserving chronological order', async () => {
+        const preset = await service.createMemberPreset(presetInput('Coder'));
+        const task = await createTask();
+        const teamRun = await service.createTeamRun(task.id, {
+            mode: 'AUTO',
+            memberPresetIds: [preset.id],
+        });
+        const first = await service.createRoomMessage(teamRun.id, { content: 'First note' });
+        const second = await service.createRoomMessage(teamRun.id, { content: 'Second note' });
+        const third = await service.createRoomMessage(teamRun.id, { content: 'Third note' });
+        await prisma.roomMessage.update({
+            where: { id: first.id },
+            data: { createdAt: new Date('2026-01-01T00:00:00.000Z') },
+        });
+        await prisma.roomMessage.update({
+            where: { id: second.id },
+            data: { createdAt: new Date('2026-01-01T00:00:01.000Z') },
+        });
+        await prisma.roomMessage.update({
+            where: { id: third.id },
+            data: { createdAt: new Date('2026-01-01T00:00:02.000Z') },
+        });
+        const messages = await service.listRoomMessages(teamRun.id, { limit: 2 });
+        expect(messages.map((message) => message.id)).toEqual([second.id, third.id]);
+        expect(messages.map((message) => message.content)).toEqual(['Second note', 'Third note']);
+        expect(messages.map((message) => message.contentMode)).toEqual(['full', 'full']);
+        expect(messages.find((message) => message.id === first.id)).toBeUndefined();
+    });
     it('creates WorkRequests for USER_MESSAGES members when a user message has no mentions', async () => {
         const leaderPreset = await service.createMemberPreset(userMessagesPresetInput('Leader'));
         const coderPreset = await service.createMemberPreset(presetInput('Coder'));
@@ -390,8 +443,12 @@ describe('TeamRunService', () => {
         const listed = await service.listRoomMessages(teamRun.id);
         const detail = await service.getRoomMessage(teamRun.id, teamRun.messages[0].id);
         expect(listed[0]?.isTruncated).toBe(true);
+        expect(listed[0]?.contentMode).toBe('preview');
+        expect(listed[0]?.fullContentAvailable).toBe(true);
         expect(listed[0]?.content).not.toContain('line '.repeat(100));
         expect(detail.content).toBe(storedMessage.content);
+        expect(detail.contentMode).toBe('full');
+        expect(detail.fullContentAvailable).toBe(false);
         expect(detail.content).toContain('line '.repeat(100));
     });
     it('parses initial TeamRun mentions from the full task body and stores the full description', async () => {
@@ -487,6 +544,266 @@ describe('TeamRunService', () => {
             status: 'PENDING_APPROVAL',
         });
     });
+    it('persists target commit metadata from RoomMessage mentions', async () => {
+        const reviewerPreset = await service.createMemberPreset(presetInput('Reviewer'));
+        const task = await createTask();
+        const teamRun = await service.createTeamRun(task.id, {
+            mode: 'CONFIRM',
+            memberPresetIds: [reviewerPreset.id],
+        });
+        const member = teamRun.members?.[0];
+        expect(member).toBeDefined();
+        const sourceWorkspace = await prisma.workspace.create({
+            data: {
+                taskId: task.id,
+                parentWorkspaceId: null,
+                ownerMemberId: null,
+                branchName: 'source-branch',
+                worktreePath: path.join(testDir, 'source-workspace'),
+                status: 'ACTIVE',
+            },
+        });
+        const message = await service.createRoomMessage(teamRun.id, {
+            content: 'Please review this commit',
+            mentions: [{
+                    memberId: member.id,
+                    target: {
+                        kind: 'WORKSPACE_COMMIT',
+                        purpose: 'REVIEW',
+                        sourceWorkspaceId: sourceWorkspace.id,
+                        headSha: 'a'.repeat(40),
+                        branchName: sourceWorkspace.branchName,
+                        planItemId: 'plan-1',
+                    },
+                }],
+        });
+        const requests = await service.listWorkRequests(teamRun.id);
+        expect(message.mentions[0]?.target).toMatchObject({
+            kind: 'WORKSPACE_COMMIT',
+            purpose: 'REVIEW',
+            sourceWorkspaceId: sourceWorkspace.id,
+            headSha: 'a'.repeat(40),
+        });
+        expect(requests).toHaveLength(1);
+        expect(requests[0]).toMatchObject({
+            targetKind: 'WORKSPACE_COMMIT',
+            targetPurpose: 'REVIEW',
+            targetSourceWorkspaceId: sourceWorkspace.id,
+            targetSourceMemberId: null,
+            targetHeadSha: 'a'.repeat(40),
+            targetBranchName: sourceWorkspace.branchName,
+            targetPlanItemId: 'plan-1',
+        });
+    });
+    it('rejects target commit metadata for source workspaces outside the TeamRun', async () => {
+        const reviewerPreset = await service.createMemberPreset(presetInput('Reviewer'));
+        const task = await createTask();
+        const otherTask = await createTask('Other task');
+        const teamRun = await service.createTeamRun(task.id, {
+            mode: 'AUTO',
+            memberPresetIds: [reviewerPreset.id],
+        });
+        const member = teamRun.members?.[0];
+        expect(member).toBeDefined();
+        const otherWorkspace = await prisma.workspace.create({
+            data: {
+                taskId: otherTask.id,
+                branchName: 'other-source',
+                worktreePath: path.join(testDir, 'other-source'),
+                status: 'ACTIVE',
+            },
+        });
+        await expect(service.createRoomMessage(teamRun.id, {
+            content: 'Please review this commit',
+            mentions: [{
+                    memberId: member.id,
+                    target: {
+                        kind: 'WORKSPACE_COMMIT',
+                        purpose: 'REVIEW',
+                        sourceWorkspaceId: otherWorkspace.id,
+                        headSha: 'b'.repeat(40),
+                        branchName: otherWorkspace.branchName,
+                    },
+                }],
+        })).rejects.toMatchObject({
+            code: 'VALIDATION_ERROR',
+            statusCode: 400,
+        });
+        await expect(prisma.workRequest.count({ where: { teamRunId: teamRun.id } })).resolves.toBe(0);
+    });
+    it('immediately completes a waiting invocation when its agent posts a RoomMessage and starts queued work', async () => {
+        const preset = await service.createMemberPreset({
+            ...presetInput('Coder'),
+            workspacePolicy: 'shared',
+        });
+        const task = await createTask();
+        const workspace = await prisma.workspace.create({
+            data: {
+                taskId: task.id,
+                branchName: '',
+                worktreePath: '',
+                workspaceKind: 'MAIN_DIRECTORY',
+                workingDir: testDir,
+                status: 'ACTIVE',
+            },
+        });
+        const teamRun = await service.createTeamRun(task.id, {
+            mode: 'AUTO',
+            memberPresetIds: [preset.id],
+        });
+        await prisma.teamRun.update({
+            where: { id: teamRun.id },
+            data: { mainWorkspaceId: workspace.id },
+        });
+        const member = teamRun.members[0];
+        const firstRequest = await prisma.workRequest.create({
+            data: {
+                teamRunId: teamRun.id,
+                requesterType: 'user',
+                targetMemberId: member.id,
+                triggerMessageId: 'message-waiting',
+                instruction: 'Finish current work',
+                status: 'STARTED',
+            },
+        });
+        const queuedRequest = await prisma.workRequest.create({
+            data: {
+                teamRunId: teamRun.id,
+                requesterType: 'user',
+                targetMemberId: member.id,
+                triggerMessageId: 'message-queued',
+                instruction: 'Start next work',
+                status: 'QUEUED',
+            },
+        });
+        const session = await prisma.session.create({
+            data: {
+                workspaceId: workspace.id,
+                agentType: 'CODEX',
+                providerId: member.providerId,
+                prompt: 'current work',
+                status: 'COMPLETED',
+            },
+        });
+        const invocation = await prisma.agentInvocation.create({
+            data: {
+                teamRunId: teamRun.id,
+                workRequestId: firstRequest.id,
+                memberId: member.id,
+                workspaceId: workspace.id,
+                sessionId: session.id,
+                status: 'WAITING_ROOM_REPLY',
+                roomReplyReminderCount: 4,
+                nextRoomReplyReminderAt: new Date(Date.UTC(2026, 0, 1, 0, 5, 0)),
+                firstNudgeAt: new Date(Date.UTC(2026, 0, 1, 0, 0, 0)),
+            },
+        });
+        const { TeamReconcilerService } = await import('../team-reconciler.service.js');
+        const scheduler = {
+            releaseInvocationLocks: vi.fn(),
+            startNextSessions: vi.fn(async () => []),
+        };
+        service.reconciler = new TeamReconcilerService({
+            scheduler,
+            eventBus: fakeEventBus,
+            scheduleReminders: false,
+        });
+        const message = await service.createRoomMessage(teamRun.id, {
+            content: 'Result posted',
+            senderType: 'agent',
+            senderId: member.id,
+            senderInvocationId: invocation.id,
+        });
+        expect(message.senderInvocationId).toBe(invocation.id);
+        await expect(prisma.agentInvocation.findUnique({ where: { id: invocation.id } })).resolves.toMatchObject({
+            status: 'COMPLETED',
+            roomReplyReminderCount: 0,
+            nextRoomReplyReminderAt: null,
+            firstNudgeAt: null,
+        });
+        await expect(prisma.workRequest.findUnique({ where: { id: firstRequest.id } })).resolves.toMatchObject({
+            status: 'COMPLETED',
+        });
+        await expect(prisma.workRequest.findUnique({ where: { id: queuedRequest.id } })).resolves.toMatchObject({
+            status: 'QUEUED',
+        });
+        expect(scheduler.releaseInvocationLocks).toHaveBeenCalledWith(invocation.id);
+        expect(scheduler.startNextSessions).toHaveBeenCalledWith(teamRun.id);
+    });
+    it('does not complete a waiting invocation for user or system RoomMessages', async () => {
+        const preset = await service.createMemberPreset(presetInput('Coder'));
+        const task = await createTask();
+        const workspace = await prisma.workspace.create({
+            data: {
+                taskId: task.id,
+                branchName: 'team-shared',
+                worktreePath: testDir,
+                status: 'ACTIVE',
+            },
+        });
+        const teamRun = await service.createTeamRun(task.id, {
+            mode: 'AUTO',
+            memberPresetIds: [preset.id],
+        });
+        const member = teamRun.members[0];
+        const request = await prisma.workRequest.create({
+            data: {
+                teamRunId: teamRun.id,
+                requesterType: 'user',
+                targetMemberId: member.id,
+                triggerMessageId: 'message-waiting-user',
+                instruction: 'Finish current work',
+                status: 'STARTED',
+            },
+        });
+        const session = await prisma.session.create({
+            data: {
+                workspaceId: workspace.id,
+                agentType: 'CODEX',
+                providerId: member.providerId,
+                prompt: 'current work',
+                status: 'COMPLETED',
+            },
+        });
+        const invocation = await prisma.agentInvocation.create({
+            data: {
+                teamRunId: teamRun.id,
+                workRequestId: request.id,
+                memberId: member.id,
+                workspaceId: workspace.id,
+                sessionId: session.id,
+                status: 'WAITING_ROOM_REPLY',
+                roomReplyReminderCount: 4,
+                nextRoomReplyReminderAt: new Date(Date.UTC(2026, 0, 1, 0, 5, 0)),
+            },
+        });
+        const userMessage = await service.createRoomMessage(teamRun.id, {
+            content: 'Host note',
+            senderType: 'user',
+            senderInvocationId: invocation.id,
+        });
+        const systemMessage = await service.createRoomMessage(teamRun.id, {
+            content: 'System note',
+            senderType: 'system',
+            senderInvocationId: invocation.id,
+        });
+        expect(userMessage.senderInvocationId).toBeNull();
+        expect(systemMessage.senderInvocationId).toBeNull();
+        await expect(prisma.roomMessage.findMany({
+            where: { id: { in: [userMessage.id, systemMessage.id] } },
+            orderBy: { createdAt: 'asc' },
+        })).resolves.toEqual([
+            expect.objectContaining({ senderType: 'user', senderInvocationId: null }),
+            expect.objectContaining({ senderType: 'system', senderInvocationId: null }),
+        ]);
+        await expect(prisma.agentInvocation.findUnique({ where: { id: invocation.id } })).resolves.toMatchObject({
+            status: 'WAITING_ROOM_REPLY',
+            roomReplyReminderCount: 4,
+        });
+        await expect(prisma.workRequest.findUnique({ where: { id: request.id } })).resolves.toMatchObject({
+            status: 'STARTED',
+        });
+    });
     it('creates private RoomMessages with participants and WorkRequests for recipients', async () => {
         const senderPreset = await service.createMemberPreset(presetInput('Sender'));
         const recipientPreset = await service.createMemberPreset(presetInput('Recipient'));
@@ -536,6 +853,55 @@ describe('TeamRunService', () => {
         await expect(service.listRoomMessages(teamRun.id, { viewerMemberId: recipient.id })).resolves.toEqual(expect.arrayContaining([expect.objectContaining({ id: message.id })]));
         await expect(service.listRoomMessages(teamRun.id, { viewerMemberId: observer.id })).resolves.toEqual([]);
     });
+    it('persists target commit metadata from private RoomMessages', async () => {
+        const senderPreset = await service.createMemberPreset(presetInput('Sender'));
+        const recipientPreset = await service.createMemberPreset(presetInput('Recipient'));
+        const task = await createTask();
+        const teamRun = await service.createTeamRun(task.id, {
+            mode: 'AUTO',
+            memberPresetIds: [senderPreset.id, recipientPreset.id],
+        });
+        const sender = teamRun.members?.find((member) => member.name === 'Sender');
+        const recipient = teamRun.members?.find((member) => member.name === 'Recipient');
+        expect(sender).toBeDefined();
+        expect(recipient).toBeDefined();
+        const sourceWorkspace = await prisma.workspace.create({
+            data: {
+                taskId: task.id,
+                parentWorkspaceId: null,
+                ownerMemberId: sender.id,
+                branchName: 'private-source',
+                worktreePath: path.join(testDir, 'private-source-workspace'),
+                status: 'ACTIVE',
+            },
+        });
+        await service.createPrivateRoomMessage(teamRun.id, {
+            content: 'Private targeted test',
+            recipientMemberIds: [recipient.id],
+            target: {
+                kind: 'WORKSPACE_COMMIT',
+                purpose: 'TEST',
+                sourceWorkspaceId: sourceWorkspace.id,
+                headSha: 'c'.repeat(40),
+                branchName: sourceWorkspace.branchName,
+                planItemId: 'private-plan',
+            },
+            senderType: 'agent',
+            senderId: sender.id,
+        });
+        const requests = await service.listWorkRequests(teamRun.id);
+        expect(requests).toHaveLength(1);
+        expect(requests[0]).toMatchObject({
+            targetMemberId: recipient.id,
+            targetKind: 'WORKSPACE_COMMIT',
+            targetPurpose: 'TEST',
+            targetSourceWorkspaceId: sourceWorkspace.id,
+            targetSourceMemberId: sender.id,
+            targetHeadSha: 'c'.repeat(40),
+            targetBranchName: sourceWorkspace.branchName,
+            targetPlanItemId: 'private-plan',
+        });
+    });
     it('records user private message senderId as a sender participant when provided', async () => {
         const senderPreset = await service.createMemberPreset(presetInput('HostSender'));
         const recipientPreset = await service.createMemberPreset(presetInput('Recipient'));