| import { expectDefined } from "@openclaw/normalization-core"; |
| import { describe, expect, it, vi } from "vitest"; |
| import { createDeferred } from "../../../test/helpers/promise.js"; |
| import { TerminalSessionManager } from "./session-manager.js"; |
| import { |
| agentTerminalOwner, |
| baseOpenRequest, |
| makeFakePty, |
| taskAgentOwner, |
| } from "./session-manager.test-helpers.js"; |
|
|
| const TERMINAL_EVENT_EXIT = "terminal.exit"; |
|
|
| describe("TerminalSessionManager task lifecycle", () => { |
| it("aborts a matching pending task open and kills its late backend", async () => { |
| const { promise: spawn, resolve: resolveSpawn } = |
| createDeferred<ReturnType<typeof makeFakePty>>(); |
| const manager = new TerminalSessionManager({ emit: vi.fn(), spawn: () => spawn }); |
| const opening = manager.open( |
| baseOpenRequest({ |
| owner: taskAgentOwner("agent:main:cron:job-1:run:run-1", "task-1"), |
| }), |
| ); |
|
|
| expect(manager.closeTaskSessions("task-1")).toBe(0); |
| const latePty = makeFakePty(); |
| resolveSpawn(latePty); |
|
|
| await expect(opening).resolves.toEqual({ |
| ok: false, |
| code: "closed", |
| message: "terminal closed because its task ended", |
| }); |
| expect(latePty.killed).toBe(true); |
| expect(manager.size).toBe(0); |
| }); |
|
|
| it("does not authorize interactive access through a colliding task id", async () => { |
| const fake = makeFakePty(); |
| const manager = new TerminalSessionManager({ emit: vi.fn(), spawn: async () => fake }); |
| const owner = { |
| ...agentTerminalOwner("agent:ops:main", "ops-session", "ops"), |
| taskId: "agent:research:main", |
| } as const; |
| const opened = await manager.open(baseOpenRequest({ owner })); |
| if (!opened.ok) { |
| throw new Error("expected terminal session"); |
| } |
|
|
| const collidingOwner = agentTerminalOwner( |
| "agent:research:main", |
| "research-session", |
| "research", |
| ); |
| expect(manager.snapshotAgent(collidingOwner, opened.sessionId)).toBeUndefined(); |
| expect(manager.closeAgent(collidingOwner, opened.sessionId)).toEqual({ |
| ok: false, |
| code: "session_unavailable", |
| }); |
| expect(fake.killed).toBe(false); |
| }); |
|
|
| it("closes one task owner with viewer cleanup while preserving persistent owners", async () => { |
| const emit = vi.fn(); |
| const runPtys = [makeFakePty(), makeFakePty()]; |
| const persistentPty = makeFakePty(); |
| const connectionPty = makeFakePty(); |
| const ptys = [...runPtys, persistentPty, connectionPty]; |
| let spawnIndex = 0; |
| const manager = new TerminalSessionManager({ |
| emit, |
| spawn: async () => expectDefined(ptys[spawnIndex++], "terminal PTY test invariant"), |
| }); |
| const runOwner = { |
| ...agentTerminalOwner("agent:main:cron:job-1:run:run-1", "run-session"), |
| taskId: "task-1", |
| } as const; |
| const persistentOwner = agentTerminalOwner("agent:main:main", "main-session"); |
| const first = await manager.open(baseOpenRequest({ owner: runOwner })); |
| const second = await manager.open(baseOpenRequest({ owner: runOwner })); |
| const persistent = await manager.open(baseOpenRequest({ owner: persistentOwner })); |
| const connection = await manager.open( |
| baseOpenRequest({ owner: { kind: "conn", connId: "connection-owner" } }), |
| ); |
| if (!first.ok || !second.ok || !persistent.ok || !connection.ok) { |
| throw new Error("expected terminal sessions"); |
| } |
| manager.attach("viewer-1", first.sessionId); |
| manager.attach("viewer-2", second.sessionId); |
| emit.mockClear(); |
|
|
| expect(manager.closeTaskSessions(runOwner.taskId)).toBe(2); |
| expect(runPtys.every((pty) => pty.killed)).toBe(true); |
| expect(persistentPty.killed).toBe(false); |
| expect(connectionPty.killed).toBe(false); |
| expect(manager.listAgent(runOwner)).toEqual([]); |
| expect(manager.listAgent(persistentOwner)).toHaveLength(1); |
| expect(manager.write("connection-owner", connection.sessionId, "still live\n")).toBe(true); |
| expect(emit).toHaveBeenCalledWith("viewer-1", TERMINAL_EVENT_EXIT, { |
| sessionId: first.sessionId, |
| exitCode: null, |
| signal: null, |
| reason: "closed", |
| }); |
| expect(emit).toHaveBeenCalledWith("viewer-2", TERMINAL_EVENT_EXIT, { |
| sessionId: second.sessionId, |
| exitCode: null, |
| signal: null, |
| reason: "closed", |
| }); |
| manager.handleDisconnect("viewer-1"); |
| manager.handleDisconnect("viewer-2"); |
| expect(manager.size).toBe(2); |
| }); |
|
|
| it("drains one agent incarnation while admitting its same-key replacement", async () => { |
| const oldPty = makeFakePty(); |
| const pendingPty = makeFakePty(); |
| const { promise: pendingBackend, resolve: resolvePending } = |
| createDeferred<ReturnType<typeof makeFakePty>>(); |
| const replacementPtys = [makeFakePty(), makeFakePty()]; |
| let spawnIndex = 0; |
| const manager = new TerminalSessionManager({ |
| emit: vi.fn(), |
| spawn: async () => replacementPtys[spawnIndex++] ?? makeFakePty(), |
| }); |
| const oldOwner = agentTerminalOwner("agent:main:archive-target", "old-session"); |
| const replacementOwner = agentTerminalOwner("agent:main:archive-target", "replacement-session"); |
| const opened = await manager.open( |
| baseOpenRequest({ owner: oldOwner, createBackend: async () => oldPty }), |
| ); |
| if (!opened.ok) { |
| throw new Error("expected terminal session"); |
| } |
| const pending = manager.open( |
| baseOpenRequest({ owner: oldOwner, createBackend: () => pendingBackend }), |
| ); |
|
|
| const drain = manager.beginAgentSessionDrain(oldOwner); |
| expect(oldPty.killed).toBe(true); |
| expect(drain.hasWork()).toBe(true); |
| resolvePending(pendingPty); |
| await expect(pending).resolves.toMatchObject({ ok: false, code: "closed" }); |
| expect(pendingPty.killed).toBe(true); |
| expect(drain.hasWork()).toBe(true); |
| oldPty.emitExit(0); |
| expect(drain.hasWork()).toBe(true); |
| pendingPty.emitExit(0); |
| await expect(drain.drained).resolves.toBeUndefined(); |
| expect(drain.hasWork()).toBe(false); |
| await expect(manager.open(baseOpenRequest({ owner: oldOwner }))).resolves.toMatchObject({ |
| ok: false, |
| code: "closed", |
| }); |
| await expect(manager.open(baseOpenRequest({ owner: replacementOwner }))).resolves.toMatchObject( |
| { |
| ok: true, |
| }, |
| ); |
|
|
| drain.release(); |
| await expect(manager.open(baseOpenRequest({ owner: oldOwner }))).resolves.toMatchObject({ |
| ok: true, |
| }); |
| }); |
| }); |
|
|
