agent-tower 0.7.4-beta.0 → 0.7.4-beta.2

package/dist/services/__tests__/workspace.service.test.js

@@ -381,6 +381,37 @@ describe('WorkspaceService TeamRun workspace lifecycle', () => {
         await expect(service.merge(workspace.id)).rejects.toMatchObject({ code: 'PARENT_WORKSPACE_HAS_ACTIVE_SESSION' });
         expect(mergeWorktreeMock).not.toHaveBeenCalled();
     });
+    it.each([undefined, true])('keeps target background services running when merging with stopActiveServices=%s', async (stopActiveServices) => {
+        const { project, task: parent } = await createTask('Parent with background services');
+        const parentWorkspace = await prisma.workspace.create({ data: {
+                taskId: parent.id, branchName: 'at/parent', baseBranch: 'main', worktreePath: '/parent',
+            } });
+        const child = await prisma.task.create({ data: {
+                projectId: project.id, title: 'Child', parentTaskId: parent.id, status: 'IN_REVIEW',
+            } });
+        const childWorkspace = await prisma.workspace.create({ data: {
+                taskId: child.id, branchName: 'at/child', baseBranch: 'at/parent', worktreePath: '/child',
+            } });
+        const background = await prisma.workspaceBackgroundService.create({ data: {
+                workspaceId: parentWorkspace.id,
+                name: 'web',
+                command: 'node',
+                desiredState: 'RUNNING',
+                runtimeState: 'RUNNING',
+                runtimeInstanceId: 'runtime-parent-web',
+                pid: 4321,
+            } });
+        const stopAllForWorkspace = vi.fn().mockRejectedValue(new Error('target service must not be stopped'));
+        const lifecycleService = new WorkspaceService(new TeamLockService(), { stopAllForWorkspace });
+        await expect(lifecycleService.merge(childWorkspace.id, { stopActiveServices }))
+            .resolves.toBe('root-merge-sha');
+        expect(mergeWorktreeMock).toHaveBeenCalledWith('/child', 'at/parent', expect.objectContaining({ targetWorktreePath: '/parent' }));
+        expect(stopAllForWorkspace).not.toHaveBeenCalled();
+        await expect(prisma.workspaceBackgroundService.findUnique({ where: { id: background.id } }))
+            .resolves.toEqual(background);
+        await expect(prisma.workspace.findUnique({ where: { id: parentWorkspace.id } }))
+            .resolves.toMatchObject({ status: 'ACTIVE' });
+    });
     it('retains a merged parent branch and its ownership until its subtasks no longer depend on it', async () => {
         const { project, task: parent } = await createTask('Retain parent branch');
         await prisma.task.update({ where: { id: parent.id }, data: { status: 'DONE' } });
@@ -393,6 +424,31 @@ describe('WorkspaceService TeamRun workspace lifecycle', () => {
         await service.cleanup();
         expect(deleteBranchIfSafeMock).toHaveBeenCalledWith('at/parent', expect.anything());
     });
+    it('retains an ancestor branch referenced only by a grandchild', async () => {
+        const { project, task: parent } = await createTask('Grandchild branch dependency');
+        await prisma.task.update({ where: { id: parent.id }, data: { status: 'DONE' } });
+        const workspace = await prisma.workspace.create({ data: { taskId: parent.id, branchName: 'at/root', baseBranch: 'main', worktreePath: '/root', status: 'MERGED' } });
+        const child = await prisma.task.create({ data: { projectId: project.id, title: 'Child', parentTaskId: parent.id, baseBranch: 'main' } });
+        const grandchild = await prisma.task.create({ data: { projectId: project.id, title: 'Grandchild', parentTaskId: child.id, baseBranch: 'at/root' } });
+        await service.cleanup();
+        expect(deleteBranchIfSafeMock).not.toHaveBeenCalled();
+        expect(await prisma.workspace.findUnique({ where: { id: workspace.id } })).not.toBeNull();
+        await prisma.task.update({ where: { id: grandchild.id }, data: { deletedAt: new Date() } });
+        await service.cleanup();
+        expect(deleteBranchIfSafeMock).toHaveBeenCalledWith('at/root', expect.anything());
+    });
+    it('merges a grandchild into its immediate parent without completing either ancestor', async () => {
+        const { project, task: parent } = await createTask('Grandchild merge');
+        const child = await prisma.task.create({ data: { projectId: project.id, title: 'Child', parentTaskId: parent.id } });
+        await prisma.workspace.create({ data: { taskId: child.id, branchName: 'at/child', baseBranch: 'main', worktreePath: '/child' } });
+        const grandchild = await prisma.task.create({ data: { projectId: project.id, title: 'Grandchild', parentTaskId: child.id, status: 'IN_REVIEW' } });
+        const workspace = await prisma.workspace.create({ data: { taskId: grandchild.id, branchName: 'at/grandchild', baseBranch: 'at/child', worktreePath: '/grandchild' } });
+        await service.merge(workspace.id);
+        expect(mergeWorktreeMock).toHaveBeenCalledWith('/grandchild', 'at/child', expect.objectContaining({ targetWorktreePath: '/child' }));
+        expect((await prisma.task.findUniqueOrThrow({ where: { id: grandchild.id } })).status).toBe('DONE');
+        expect((await prisma.task.findUniqueOrThrow({ where: { id: child.id } })).status).toBe('TODO');
+        expect((await prisma.task.findUniqueOrThrow({ where: { id: parent.id } })).status).toBe('TODO');
+    });
     it('creates a main-directory workspace without creating a git worktree', async () => {
         const { project, task } = await createTask('main directory workspace task');
         const workspace = await service.create(task.id, {
@@ -2281,7 +2337,7 @@ describe('WorkspaceService TeamRun workspace lifecycle', () => {
         await expect(lockedService.merge(workspace.id)).rejects.toThrow('git merge failed');
         expect(lockService.listLocks()).toEqual([]);
     });
-    it('cleans up stale managed worktree records and deletes their branches', async () => {
+    it('reclaims stale managed worktrees and branches while retaining history records', async () => {
         const { project, task } = await createTask('cleanup stale workspace task');
         await prisma.task.update({
             where: { id: task.id },
@@ -2306,7 +2362,11 @@ describe('WorkspaceService TeamRun workspace lifecycle', () => {
         expect(deleteBranchIfSafeMock).toHaveBeenCalledWith(workspace.branchName, {
             protectedBranches: [project.mainBranch, workspace.baseBranch],
         });
-        await expect(prisma.workspace.findUnique({ where: { id: workspace.id } })).resolves.toBeNull();
+        await expect(prisma.workspace.findUnique({ where: { id: workspace.id } })).resolves.toMatchObject({
+            status: 'MERGED', worktreePath: '', workingDir: '', cleanedAt: expect.any(Date),
+        });
+        await expect(service.cleanup()).resolves.toBe(0);
+        expect(removeWorktreeMock).toHaveBeenCalledTimes(1);
     });
     it('retries periodic cleanup only after completed session trees are confirmed stopped', async () => {
         const { task } = await createTask('periodic idle ACP cleanup');
@@ -2329,7 +2389,10 @@ describe('WorkspaceService TeamRun workspace lifecycle', () => {
         isRuntimeCleanupConfirmed.mockResolvedValue(true);
         await expect(service.cleanup()).resolves.toBe(1);
         expect(removeWorktreeMock).toHaveBeenCalledWith(workspace.worktreePath);
-        expect(await prisma.workspace.findUnique({ where: { id: workspace.id } })).toBeNull();
+        expect(await prisma.workspace.findUnique({ where: { id: workspace.id } })).toMatchObject({
+            cleanedAt: expect.any(Date), worktreePath: '',
+        });
+        expect(await prisma.session.count({ where: { workspaceId: workspace.id } })).toBe(1);
     });
     it('stops background services before cleanup removes a workspace directory', async () => {
         const { project, task } = await createTask('cleanup background service task');
@@ -2356,7 +2419,7 @@ describe('WorkspaceService TeamRun workspace lifecycle', () => {
         expect(backgroundService.releaseLogsForWorkspace).toHaveBeenCalledWith(workspace.id);
         expect(removeWorktreeMock).toHaveBeenCalledWith(workspace.worktreePath);
     });
-    it('cleans up stale managed TeamRun nested worktree records', async () => {
+    it('reclaims stale managed TeamRun worktrees while retaining workspace identity', async () => {
         const { project, task, teamRun } = await createTeamRunWithMember();
         await prisma.task.update({
             where: { id: task.id },
@@ -2381,7 +2444,9 @@ describe('WorkspaceService TeamRun workspace lifecycle', () => {
         expect(deleteBranchIfSafeMock).toHaveBeenCalledWith(workspace.branchName, {
             protectedBranches: [project.mainBranch, workspace.baseBranch],
         });
-        await expect(prisma.workspace.findUnique({ where: { id: workspace.id } })).resolves.toBeNull();
+        await expect(prisma.workspace.findUnique({ where: { id: workspace.id } })).resolves.toMatchObject({
+            status: 'MERGED', worktreePath: '', workingDir: '', cleanedAt: expect.any(Date),
+        });
     });
     it('keeps non-managed unregistered worktree records for retry', async () => {
         const { task } = await createTask('cleanup unmanaged workspace task');
@@ -2453,5 +2518,30 @@ describe('WorkspaceService TeamRun workspace lifecycle', () => {
         expect(cleaned).toBe(0);
         expect(removeWorktreeMock).not.toHaveBeenCalled();
     });
+    it.each(['failed', 'checked_out'])('retries %s branch cleanup without removing history or the directory twice', async (status) => {
+        const { task } = await createTask('pending branch cleanup');
+        await prisma.task.update({ where: { id: task.id }, data: { status: 'DONE' } });
+        const workspace = await prisma.workspace.create({ data: {
+                taskId: task.id, branchName: 'at/pending-branch', worktreePath: '/pending-branch', status: 'MERGED',
+                sessions: { create: { agentType: 'CODEX', prompt: 'history', status: 'COMPLETED', logSnapshot: '{"entries":[]}' } },
+            }, include: { sessions: true } });
+        Object.assign(service, { sessionService: { stop: vi.fn(async () => workspace.sessions[0]), isRuntimeCleanupConfirmed: vi.fn(async () => true) } });
+        deleteBranchIfSafeMock.mockResolvedValueOnce({ status, branchName: workspace.branchName });
+        await service.cleanup();
+        expect(await prisma.workspace.findUnique({ where: { id: workspace.id } })).toMatchObject({ worktreePath: '', cleanedAt: null });
+        await service.cleanup();
+        expect(await prisma.workspace.findUnique({ where: { id: workspace.id } })).toMatchObject({ cleanedAt: expect.any(Date) });
+        expect((await prisma.session.findUniqueOrThrow({ where: { id: workspace.sessions[0].id } })).logSnapshot).toBe('{"entries":[]}');
+        expect(removeWorktreeMock).toHaveBeenCalledTimes(1);
+        expect(deleteBranchIfSafeMock).toHaveBeenCalledTimes(2);
+    });
+    it('serializes concurrent cleanups before releasing the same workspace resources', async () => {
+        const { task } = await createTask('concurrent cleanup');
+        await prisma.task.update({ where: { id: task.id }, data: { status: 'DONE' } });
+        await prisma.workspace.create({ data: { taskId: task.id, branchName: 'at/concurrent', worktreePath: '/concurrent', status: 'MERGED' } });
+        const results = await Promise.all([service.cleanup(), service.cleanup()]);
+        expect(results.reduce((sum, count) => sum + count, 0)).toBe(1);
+        expect(removeWorktreeMock).toHaveBeenCalledTimes(1);
+    });
 });
 //# sourceMappingURL=workspace.service.test.js.map