agent-tower 0.7.4-beta.2 → 0.7.5-beta.5

package/dist/services/__tests__/session-manager.lifecycle.test.js

@@ -1209,6 +1209,70 @@ describe('SessionManager session status vs real process state', () => {
         })).toBe(0);
         await manager.destroyAll();
     });
+    it.each([
+        ['start', 'entry'], ['startFollowUp', 'entry'],
+        ['start', 'backend'], ['startFollowUp', 'backend'],
+    ])('resolves a Claude MCP %s failure with missing %s and permits cleanup and retry', async (method, missing) => {
+        const { ClaudeCodeExecutor } = await import('../../executors/claude-code.executor.js');
+        // Exercise the real configuration builder and CLI Driver; only substitute
+        // the PTY transport after configuration succeeds.
+        class TestClaudeExecutor extends ClaudeCodeExecutor {
+            async spawnWithStdin() { return spawnMock(); }
+        }
+        const executor = new TestClaudeExecutor({ executionPermission: 'FULL_ACCESS' });
+        const provider = {
+            id: 'claude-mcp-recovery', name: 'Claude MCP recovery', agentType: AgentType.CLAUDE_CODE,
+            runtimeType: RuntimeType.CLI, executionPermission: 'FULL_ACCESS',
+            config: {}, env: {}, isDefault: false,
+        };
+        getProviderByIdMock.mockReturnValue(provider);
+        getExecutorByProviderMock.mockReturnValue(executor);
+        const { workspace, session } = await createSessionFixture({ providerId: provider.id, agentType: AgentType.CLAUDE_CODE });
+        const resumeSource = await prisma.session.create({ data: {
+                workspaceId: workspace.id, agentType: AgentType.CLAUDE_CODE, prompt: 'previous turn',
+                status: SessionStatus.COMPLETED, externalSessionId: 'previous-claude-session',
+            } });
+        const entry = path.join(serverRoot, 'src', 'mcp', 'index.ts');
+        const manager = new SessionManager(new EventBus());
+        const pty = new ControlledPty();
+        spawnMock.mockReset();
+        spawnMock.mockResolvedValueOnce(spawnResultFor(pty));
+        vi.stubEnv('AGENT_TOWER_DESKTOP_RUNTIME_MODE', undefined);
+        vi.stubEnv('AGENT_TOWER_MCP_ENTRY', missing === 'entry' ? path.join(testDir, 'missing-mcp.js') : entry);
+        vi.stubEnv('AGENT_TOWER_URL', missing === 'backend' ? undefined : 'http://127.0.0.1:12580');
+        vi.stubEnv('AGENT_TOWER_PORT', undefined);
+        try {
+            const starting = method === 'start' ? manager.start(session.id) : manager.startFollowUp(session.id, resumeSource.id);
+            await expect(starting).rejects.toThrow(missing === 'entry'
+                ? 'Agent Tower MCP entry not found'
+                : 'AGENT_TOWER_URL or AGENT_TOWER_PORT is required');
+            expect(spawnMock).not.toHaveBeenCalled();
+            expect(await prisma.executionProcess.count({ where: { sessionId: session.id } })).toBe(0);
+            await expect(prisma.session.findUniqueOrThrow({ where: { id: session.id } })).resolves.toMatchObject({
+                status: SessionStatus.CANCELLED, runtimeLaunchState: 'SAFE_PRE_CHILD_FAILURE',
+                runtimeLaunchClaimCount: 1, runtimeLaunchResolvedCount: 1, runtimeLaunchProcessCount: 0,
+            });
+            expect(await manager.isRuntimeCleanupConfirmed(session.id)).toBe(true);
+            await expect(manager.stop(session.id)).resolves.toMatchObject({ id: session.id });
+            vi.stubEnv('AGENT_TOWER_MCP_ENTRY', entry);
+            vi.stubEnv('AGENT_TOWER_URL', 'http://127.0.0.1:12580');
+            await expect(manager.sendMessage(session.id, 'retry after correcting MCP configuration')).resolves.toMatchObject({ id: session.id });
+            expect(spawnMock).toHaveBeenCalledOnce();
+            await expect(prisma.session.findUniqueOrThrow({ where: { id: session.id } })).resolves.toMatchObject({
+                status: SessionStatus.RUNNING, runtimeLaunchState: 'PROCESS_RECORDED',
+                runtimeLaunchClaimCount: 2, runtimeLaunchResolvedCount: 2, runtimeLaunchProcessCount: 1,
+            });
+            await manager.stop(session.id);
+            expect(pty.killed).toBe(true);
+            expect(await manager.isRuntimeCleanupConfirmed(session.id)).toBe(true);
+            expect(await prisma.executionProcess.findMany({ where: { sessionId: session.id } }))
+                .toMatchObject([{ launchClaimNumber: 2, cleanupState: 'CONFIRMED' }]);
+        }
+        finally {
+            vi.unstubAllEnvs();
+            await manager.destroyAll();
+        }
+    });
     it.each(['start', 'startFollowUp'])('revokes a public %s before runtime admission when stop wins during preparation', async (method) => {
         const { workspace, session } = await createSessionFixture();
         const resumeSource = await prisma.session.create({
@@ -1358,6 +1422,8 @@ describe('SessionManager session status vs real process state', () => {
             expect(checkpoint).toHaveBeenCalledWith(session.id);
             feed({ type: 'stream_event', event: { type: 'content_block_start', index: 2, content_block: { type: 'text', text: 'B after tool' } } });
             feed({ type: 'result', subtype: 'success', num_turns: 1 });
+            // A Claude run ends when its process exits, not at the result.
+            pty.emitExit(0);
             await completed;
             const row = await prisma.session.findUniqueOrThrow({ where: { id: session.id } });
             expect(JSON.parse(row.logSnapshot).entries.at(-1)).toMatchObject({ content: 'B after tool', metadata: { textBlock: { state: 'SEALED', sealedReason: 'TURN_END' } } });
@@ -1499,6 +1565,78 @@ describe('SessionManager session status vs real process state', () => {
         expect(snapshot.entries.map((entry) => entry.content))
             .toContain('fast logical completion');
     });
+    it('keeps a Claude Code session running after its result while background work is pending and completes on exit', async () => {
+        const { session } = await createSessionFixture({ agentType: AgentType.CLAUDE_CODE });
+        const pty = new ControlledPty();
+        spawnMock.mockResolvedValueOnce(spawnResultFor(pty));
+        const eventBus = new EventBus();
+        const manager = new SessionManager(eventBus);
+        const completed = waitForEvent(eventBus, 'session:completed');
+        const states = [];
+        eventBus.on('session:runtime_state_changed', ({ state }) => states.push(state));
+        try {
+            await manager.start(session.id);
+            const line = (message) => pty.emitData(JSON.stringify(message) + '\n');
+            line({ type: 'system', subtype: 'init', session_id: 'claude-native' });
+            line({ type: 'assistant', message: { id: 'm1', role: 'assistant', content: [{ type: 'text', text: 'WAITING for the router' }] } });
+            line({ type: 'system', subtype: 'background_tasks_changed', tasks: [{ task_id: 'bg-1', task_type: 'local_bash', description: 'router watch' }] });
+            line({ type: 'result', subtype: 'success', result: 'WAITING for the router', num_turns: 1, result_index: 0, uuid: 'r0', origin: null });
+            await vi.waitFor(() => {
+                expect(states.some((state) => state.backgroundTasks?.some((task) => task.taskId === 'bg-1'))).toBe(true);
+            }, { timeout: 2000 });
+            await new Promise((resolve) => setTimeout(resolve, 300));
+            expect(manager.hasActiveTurn(session.id)).toBe(true);
+            expect(pty.killed).toBe(false);
+            expect((await prisma.session.findUnique({ where: { id: session.id } }))?.status).toBe(SessionStatus.RUNNING);
+            line({ type: 'system', subtype: 'task_notification', task_id: 'bg-1', status: 'completed', summary: 'Background command "router watch" completed (exit code 0)' });
+            line({ type: 'system', subtype: 'background_tasks_changed', tasks: [] });
+            line({ type: 'system', subtype: 'init', session_id: 'claude-native' });
+            line({ type: 'assistant', message: { id: 'm2', role: 'assistant', content: [{ type: 'text', text: 'FINISHED routing' }] } });
+            line({ type: 'result', subtype: 'success', result: 'FINISHED routing', num_turns: 1, result_index: 1, uuid: 'r1', origin: { kind: 'task-notification' } });
+            pty.emitExit(0);
+            const payload = await completed;
+            expect(payload.status).toBe(SessionStatus.COMPLETED);
+            await vi.waitFor(() => expect(manager.hasActiveTurn(session.id)).toBe(false), { timeout: 2000 });
+            const persisted = await prisma.session.findUnique({ where: { id: session.id } });
+            expect(persisted?.status).toBe(SessionStatus.COMPLETED);
+            const contents = JSON.parse(persisted?.logSnapshot ?? '{}').entries.map((entry) => entry.content);
+            expect(contents).toContain('FINISHED routing');
+            expect(contents).toContain('Background command "router watch" completed (exit code 0)');
+        }
+        finally {
+            await manager.destroyAll();
+        }
+    });
+    it('stops a waiting Claude Code run when a follow-up arrives and tags wake-up messages as system events', async () => {
+        const { session } = await createSessionFixture({ agentType: AgentType.CLAUDE_CODE });
+        const first = new ControlledPty();
+        const second = new ControlledPty();
+        second.pid = 4343;
+        spawnMock.mockResolvedValueOnce(spawnResultFor(first)).mockResolvedValueOnce(spawnResultFor(second));
+        const eventBus = new EventBus();
+        const manager = new SessionManager(eventBus);
+        try {
+            await manager.start(session.id);
+            const line = (pty, message) => pty.emitData(JSON.stringify(message) + '\n');
+            line(first, { type: 'system', subtype: 'background_tasks_changed', tasks: [{ task_id: 'bg-1', description: 'watch' }] });
+            line(first, { type: 'result', subtype: 'success', result: 'WAITING', num_turns: 1, result_index: 0, uuid: 'r0', origin: null });
+            await new Promise((resolve) => setTimeout(resolve, 200));
+            expect(first.killed).toBe(false);
+            await manager.sendMessage(session.id, 'wake-up text', undefined, undefined, { origin: 'SYSTEM_EVENT' });
+            expect(first.killed).toBe(true);
+            const completed = waitForEvent(eventBus, 'session:completed');
+            line(second, { type: 'result', subtype: 'success', result: 'done', result_index: 0, uuid: 'r0', origin: null });
+            second.emitExit(0);
+            await completed;
+            const persisted = await prisma.session.findUnique({ where: { id: session.id } });
+            const entries = JSON.parse(persisted?.logSnapshot ?? '{}').entries;
+            const wakeup = entries.find((entry) => entry.content === 'wake-up text');
+            expect(wakeup).toMatchObject({ entryType: 'user_message', metadata: { origin: 'SYSTEM_EVENT' } });
+        }
+        finally {
+            await manager.destroyAll();
+        }
+    });
     it('waits for the completed generation auto-commit before starting an immediate follow-up', async () => {
         const { session } = await createSessionFixture();
         const firstPty = new ControlledPty();
@@ -1722,7 +1860,7 @@ describe('SessionManager session status vs real process state', () => {
         expect(spawnMock).toHaveBeenCalledTimes(2);
         await manager.destroyAll();
     });
-    it.each(['success', 'error_during_execution'])('persists Claude final %s and automatically reclaims the CLI process', async (subtype) => {
+    it.each(['success', 'error_during_execution'])('persists Claude final %s and reclaims a CLI process that lingers after its result', async (subtype) => {
         const { task, session } = await createSessionFixture({ agentType: AgentType.CLAUDE_CODE });
         const pty = new ControlledPty();
         spawnMock.mockResolvedValueOnce(spawnResultFor(pty));
@@ -1730,6 +1868,9 @@ describe('SessionManager session status vs real process state', () => {
         const manager = new SessionManager(eventBus);
         const completed = waitForEvent(eventBus, 'session:completed');
         const expectedStatus = subtype === 'success' ? SessionStatus.COMPLETED : SessionStatus.FAILED;
+        // The process reports no background work and never exits: Tower treats it as hung after the idle grace.
+        const previousGrace = process.env.AGENT_TOWER_CLAUDE_IDLE_EXIT_GRACE_MS;
+        process.env.AGENT_TOWER_CLAUDE_IDLE_EXIT_GRACE_MS = '200';
         try {
             await manager.start(session.id);
             pty.emitData(JSON.stringify({
@@ -1765,8 +1906,13 @@ describe('SessionManager session status vs real process state', () => {
                 }));
                 expect((await prisma.task.findUniqueOrThrow({ where: { id: task.id } })).status).not.toBe('IN_REVIEW');
             }
+            expect(snapshot.entries).toContainEqual(expect.objectContaining({ entryType: 'warning_message' }));
         }
         finally {
+            if (previousGrace === undefined)
+                delete process.env.AGENT_TOWER_CLAUDE_IDLE_EXIT_GRACE_MS;
+            else
+                process.env.AGENT_TOWER_CLAUDE_IDLE_EXIT_GRACE_MS = previousGrace;
             await manager.destroyAll();
         }
     });