| |
| import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest"; |
| import { createDeferredCore } from "../../../shared/deferred.js"; |
| import { |
| expectRealExitWinsOverSigkillFallback, |
| expectWaitStaysPendingUntilSigkillFallback, |
| mockLinuxOomWrapperShell, |
| } from "./test-support.js"; |
|
|
| const { spawnMock, ptyKillMock, signalProcessTreeMock, signalPtySessionTreeMock } = vi.hoisted( |
| () => ({ |
| spawnMock: vi.fn(), |
| ptyKillMock: vi.fn(), |
| signalProcessTreeMock: vi.fn(), |
| signalPtySessionTreeMock: vi.fn(), |
| }), |
| ); |
|
|
| vi.mock("../../terminal-pty.js", () => ({ |
| spawnTerminalPty: (...args: unknown[]) => spawnMock(...args), |
| })); |
|
|
| vi.mock("../../kill-tree.js", () => ({ |
| signalProcessTree: (...args: unknown[]) => signalProcessTreeMock(...args), |
| signalPtySessionTree: (...args: unknown[]) => signalPtySessionTreeMock(...args), |
| })); |
|
|
| function createStubPty(pid = 1234) { |
| let exitListener: ((event: { exitCode: number; signal?: number }) => void) | null = null; |
| const disposeData = vi.fn(); |
| const disposeExit = vi.fn(); |
| return { |
| pid, |
| write: vi.fn(), |
| onData: vi.fn(() => ({ dispose: disposeData })), |
| onExit: vi.fn((listener: (event: { exitCode: number; signal?: number }) => void) => { |
| exitListener = listener; |
| return { dispose: disposeExit }; |
| }), |
| kill: (signal?: string) => ptyKillMock(signal), |
| emitExit: (event: { exitCode: number; signal?: number }) => { |
| exitListener?.(event); |
| }, |
| disposeData, |
| disposeExit, |
| }; |
| } |
|
|
| function expectSpawnOptions() { |
| const options = firstSpawnCall()[0]; |
| if (typeof options !== "object" || options === null || Array.isArray(options)) { |
| throw new Error("expected spawn options to be an object"); |
| } |
| return options as { |
| file: string; |
| args: string[]; |
| env?: Record<string, string>; |
| name?: string; |
| }; |
| } |
|
|
| function expectSpawnEnv() { |
| return expectSpawnOptions().env; |
| } |
|
|
| function expectSpawnCommand() { |
| return expectSpawnOptions().file; |
| } |
|
|
| function expectSpawnArgs() { |
| return expectSpawnOptions().args; |
| } |
|
|
| function firstSpawnCall(): unknown[] { |
| const [call] = spawnMock.mock.calls; |
| if (!call) { |
| throw new Error("expected spawn call"); |
| } |
| return call; |
| } |
|
|
| describe("createPtyAdapter", () => { |
| let createPtyAdapter: typeof import("./pty.js").createPtyAdapter; |
|
|
| beforeAll(async () => { |
| ({ createPtyAdapter } = await import("./pty.js")); |
| }); |
|
|
| beforeEach(() => { |
| spawnMock.mockClear(); |
| ptyKillMock.mockClear(); |
| signalProcessTreeMock.mockClear(); |
| signalPtySessionTreeMock.mockClear(); |
| vi.useRealTimers(); |
| }); |
|
|
| afterEach(() => { |
| vi.useRealTimers(); |
| vi.unstubAllEnvs(); |
| vi.clearAllMocks(); |
| }); |
|
|
| it("does not spawn when construction aborts during the module import", async () => { |
| const abort = new AbortController(); |
| spawnMock.mockReturnValue(createStubPty()); |
|
|
| const starting = createPtyAdapter({ |
| shell: "bash", |
| args: ["-lc", "echo started"], |
| abortSignal: abort.signal, |
| }); |
| abort.abort(); |
|
|
| await expect(starting).rejects.toThrow("PTY construction aborted"); |
| expect(spawnMock).not.toHaveBeenCalled(); |
| }); |
|
|
| it("kills a PTY created after construction is aborted", async () => { |
| const abort = new AbortController(); |
| const spawned = createDeferredCore<ReturnType<typeof createStubPty>>(); |
| const stub = createStubPty(); |
| spawnMock.mockReturnValue(spawned.promise); |
|
|
| const starting = createPtyAdapter({ |
| shell: "bash", |
| args: ["-lc", "echo started"], |
| abortSignal: abort.signal, |
| }); |
| await vi.waitFor(() => expect(spawnMock).toHaveBeenCalledOnce()); |
| abort.abort(); |
| spawned.resolve(stub); |
|
|
| await expect(starting).rejects.toThrow("PTY construction aborted"); |
| expect(ptyKillMock).toHaveBeenCalledOnce(); |
| }); |
|
|
| it("uses the default terminal name and child env when Windows TERM is blank", async () => { |
| const originalPlatform = Object.getOwnPropertyDescriptor(process, "platform"); |
| Object.defineProperty(process, "platform", { value: "win32", configurable: true }); |
| try { |
| vi.stubEnv("TERM", " "); |
| vi.stubEnv("OPENCLAW_PTY_TEST_SENTINEL", "ambient"); |
| spawnMock.mockReturnValue(createStubPty()); |
|
|
| await createPtyAdapter({ shell: "powershell.exe", args: ["-NoLogo"] }); |
|
|
| expect(expectSpawnOptions()).toMatchObject({ |
| name: "xterm-256color", |
| env: { OPENCLAW_PTY_TEST_SENTINEL: "ambient", TERM: "xterm-256color" }, |
| }); |
| } finally { |
| if (originalPlatform) { |
| Object.defineProperty(process, "platform", originalPlatform); |
| } |
| } |
| }); |
|
|
| it("prefers the explicit child TERM without merging the Windows ambient env", async () => { |
| const originalPlatform = Object.getOwnPropertyDescriptor(process, "platform"); |
| Object.defineProperty(process, "platform", { value: "win32", configurable: true }); |
| try { |
| vi.stubEnv("TERM", "ambient-term"); |
| vi.stubEnv("OPENCLAW_PTY_TEST_SENTINEL", "ambient"); |
| spawnMock.mockReturnValue(createStubPty()); |
|
|
| await createPtyAdapter({ |
| shell: "powershell.exe", |
| args: ["-NoLogo"], |
| env: { Term: "screen-256color", ONLY_CHILD: "yes" }, |
| }); |
|
|
| expect(expectSpawnOptions()).toMatchObject({ |
| name: "screen-256color", |
| env: { TERM: "screen-256color", ONLY_CHILD: "yes" }, |
| }); |
| expect(expectSpawnEnv()).not.toHaveProperty("Term"); |
| expect(expectSpawnEnv()).not.toHaveProperty("OPENCLAW_PTY_TEST_SENTINEL"); |
| } finally { |
| if (originalPlatform) { |
| Object.defineProperty(process, "platform", originalPlatform); |
| } |
| } |
| }); |
|
|
| it.each([ |
| { name: "vt100", expected: "vt100" }, |
| { name: " ", expected: "xterm-256color" }, |
| ])("uses explicit terminal name '$name' over the child env", async ({ name, expected }) => { |
| spawnMock.mockReturnValue(createStubPty()); |
|
|
| await createPtyAdapter({ |
| shell: "bash", |
| args: ["-lc", "env"], |
| name, |
| env: { TERM: "screen-256color" }, |
| }); |
|
|
| expect(expectSpawnOptions()).toMatchObject({ |
| name: expected, |
| env: { TERM: expected }, |
| }); |
| }); |
|
|
| it("forwards non-SIGTERM explicit signals to node-pty kill on non-Windows", async () => { |
| const originalPlatform = Object.getOwnPropertyDescriptor(process, "platform"); |
| Object.defineProperty(process, "platform", { value: "darwin", configurable: true }); |
| try { |
| spawnMock.mockReturnValue(createStubPty()); |
|
|
| const adapter = await createPtyAdapter({ |
| shell: "bash", |
| args: ["-lc", "sleep 10"], |
| }); |
|
|
| adapter.kill("SIGINT"); |
| expect(ptyKillMock).toHaveBeenCalledWith("SIGINT"); |
| expect(signalProcessTreeMock).not.toHaveBeenCalled(); |
| } finally { |
| if (originalPlatform) { |
| Object.defineProperty(process, "platform", originalPlatform); |
| } |
| } |
| }); |
|
|
| it("uses process-tree kill for graceful SIGTERM cancellation", async () => { |
| spawnMock.mockReturnValue(createStubPty(1234)); |
|
|
| const adapter = await createPtyAdapter({ |
| shell: "bash", |
| args: ["-lc", "sleep 10"], |
| }); |
|
|
| adapter.kill("SIGTERM"); |
| expect(signalPtySessionTreeMock).toHaveBeenCalledWith(1234, "SIGTERM"); |
| expect(signalProcessTreeMock).not.toHaveBeenCalled(); |
| expect(ptyKillMock).not.toHaveBeenCalled(); |
| }); |
|
|
| it("uses process-tree kill for SIGKILL by default", async () => { |
| spawnMock.mockReturnValue(createStubPty()); |
|
|
| const adapter = await createPtyAdapter({ |
| shell: "bash", |
| args: ["-lc", "sleep 10"], |
| }); |
|
|
| adapter.kill(); |
| expect(signalPtySessionTreeMock).toHaveBeenCalledWith(1234, "SIGKILL"); |
| expect(signalProcessTreeMock).not.toHaveBeenCalled(); |
| expect(ptyKillMock).not.toHaveBeenCalled(); |
| }); |
|
|
| it("keeps terminal fallback distinct from unconfirmed PTY cleanup", async () => { |
| vi.useFakeTimers(); |
| spawnMock.mockReturnValue(createStubPty()); |
| const onSpawnCleanup = vi.fn<(cleanup: Promise<void>) => void>(); |
| const adapter = await createPtyAdapter({ |
| shell: "bash", |
| args: ["-lc", "sleep 10"], |
| onSpawnCleanup, |
| }); |
|
|
| await expectWaitStaysPendingUntilSigkillFallback(adapter.wait(), () => { |
| adapter.kill(); |
| }); |
| expect(onSpawnCleanup).toHaveBeenCalledOnce(); |
| await expect(onSpawnCleanup.mock.calls[0]![0]).rejects.toThrow( |
| "cleanup could not be confirmed", |
| ); |
| }); |
|
|
| it("prefers real PTY exit over SIGKILL fallback settle", async () => { |
| vi.useFakeTimers(); |
| const stub = createStubPty(); |
| spawnMock.mockReturnValue(stub); |
|
|
| const adapter = await createPtyAdapter({ |
| shell: "bash", |
| args: ["-lc", "sleep 10"], |
| }); |
|
|
| await expectRealExitWinsOverSigkillFallback({ |
| waitPromise: adapter.wait(), |
| triggerKill: () => { |
| adapter.kill(); |
| }, |
| emitExit: () => { |
| stub.emitExit({ exitCode: 0, signal: 9 }); |
| }, |
| expected: { code: 0, signal: 9 }, |
| }); |
| }); |
|
|
| it.each([true, false])( |
| "preserves the first PTY exit across waits (waitBefore=%s)", |
| async (waitBefore) => { |
| const stub = createStubPty(); |
| spawnMock.mockReturnValue(stub); |
|
|
| const adapter = await createPtyAdapter({ |
| shell: "bash", |
| args: ["-lc", "exit 3"], |
| }); |
|
|
| expect(stub.onExit).toHaveBeenCalledTimes(1); |
| const pending = waitBefore ? [adapter.wait(), adapter.wait()] : []; |
| stub.emitExit({ exitCode: 3, signal: 0 }); |
| const result = await adapter.wait(); |
| expect(result).toStrictEqual({ code: 3, signal: null }); |
| expect(adapter.stdin?.destroyed).toBe(true); |
| expect(adapter.stdin?.writable).toBe(false); |
| stub.emitExit({ exitCode: 9, signal: 15 }); |
| adapter.dispose(); |
| for (const wait of [...pending, adapter.wait()]) { |
| await expect(wait).resolves.toBe(result); |
| } |
| }, |
| ); |
|
|
| it("reports stdin as non-writable after EOF or dispose", async () => { |
| const stub = createStubPty(); |
| spawnMock.mockReturnValue(stub); |
|
|
| const adapter = await createPtyAdapter({ |
| shell: "bash", |
| args: ["-lc", "cat"], |
| }); |
|
|
| expect(adapter.stdin?.writable).toBe(true); |
| expect(adapter.stdin?.writableEnded).toBe(false); |
|
|
| adapter.stdin?.end(); |
| expect(stub.write).toHaveBeenCalledWith(process.platform === "win32" ? "\x1a" : "\x04"); |
| expect(adapter.stdin?.writable).toBe(false); |
| expect(adapter.stdin?.writableEnded).toBe(true); |
|
|
| adapter.dispose(); |
| expect(adapter.stdin?.destroyed).toBe(true); |
| }); |
|
|
| it("disposes PTY listeners", async () => { |
| const stub = createStubPty(); |
| spawnMock.mockReturnValue(stub); |
|
|
| const adapter = await createPtyAdapter({ |
| shell: "bash", |
| args: ["-lc", "echo ok"], |
| }); |
| adapter.onStdout(() => undefined); |
| const pending = adapter.wait(); |
|
|
| adapter.dispose(); |
|
|
| const result = await pending; |
| expect(result).toStrictEqual({ code: null, signal: null }); |
| await expect(adapter.wait()).resolves.toBe(result); |
| expect(stub.disposeData).toHaveBeenCalledTimes(1); |
| expect(stub.disposeExit).toHaveBeenCalledTimes(1); |
| }); |
|
|
| it("keeps inherited env when no override env is provided on non-Linux", async () => { |
| const originalPlatform = Object.getOwnPropertyDescriptor(process, "platform"); |
| Object.defineProperty(process, "platform", { value: "darwin", configurable: true }); |
| try { |
| const stub = createStubPty(); |
| spawnMock.mockReturnValue(stub); |
|
|
| await createPtyAdapter({ |
| shell: "bash", |
| args: ["-lc", "env"], |
| }); |
|
|
| expect(expectSpawnCommand()).toBe("bash"); |
| expect(expectSpawnArgs()).toEqual(["-lc", "env"]); |
| expect(expectSpawnEnv()).toBeUndefined(); |
| } finally { |
| if (originalPlatform) { |
| Object.defineProperty(process, "platform", originalPlatform); |
| } |
| } |
| }); |
|
|
| it("wraps Linux PTY spawns so shell children inherit higher OOM score", async () => { |
| const originalPlatform = Object.getOwnPropertyDescriptor(process, "platform"); |
| Object.defineProperty(process, "platform", { value: "linux", configurable: true }); |
| const restoreLinuxShell = mockLinuxOomWrapperShell(); |
| vi.resetModules(); |
| try { |
| const { createPtyAdapter: createLinuxPtyAdapter } = await import("./pty.js"); |
| const stub = createStubPty(); |
| spawnMock.mockReturnValue(stub); |
|
|
| const adapter = await createLinuxPtyAdapter({ |
| shell: "bash", |
| args: ["-lc", "env"], |
| env: { PATH: "/usr/bin", BASH_ENV: "/tmp/bashenv", TERM: "dumb" }, |
| }); |
| expect(adapter.oomScoreWrapperSelected).toBe(true); |
| } finally { |
| restoreLinuxShell(); |
| if (originalPlatform) { |
| Object.defineProperty(process, "platform", originalPlatform); |
| } |
| } |
|
|
| expect(expectSpawnCommand()).toBe("/bin/sh"); |
| expect(expectSpawnArgs()).toEqual([ |
| "-c", |
| 'echo 1000 > /proc/self/oom_score_adj 2>/dev/null; exec "$0" "$@"', |
| "bash", |
| "-lc", |
| "env", |
| ]); |
| expect(expectSpawnEnv()).toEqual({ PATH: "/usr/bin", TERM: "xterm-256color" }); |
| }); |
|
|
| it("passes explicit env overrides as strings", async () => { |
| const stub = createStubPty(); |
| spawnMock.mockReturnValue(stub); |
|
|
| await createPtyAdapter({ |
| shell: "bash", |
| args: ["-lc", "env"], |
| name: "xterm-256color", |
| env: { FOO: "bar", COUNT: "12", DROP_ME: undefined }, |
| }); |
|
|
| expect(expectSpawnEnv()).toEqual({ FOO: "bar", COUNT: "12", TERM: "xterm-256color" }); |
| }); |
|
|
| it("delegates non-SIGTERM explicit signals to the terminal owner on Windows", async () => { |
| const originalPlatform = Object.getOwnPropertyDescriptor(process, "platform"); |
| Object.defineProperty(process, "platform", { value: "win32", configurable: true }); |
| try { |
| spawnMock.mockReturnValue(createStubPty()); |
|
|
| const adapter = await createPtyAdapter({ |
| shell: "powershell.exe", |
| args: ["-NoLogo"], |
| }); |
|
|
| adapter.kill("SIGINT"); |
| expect(ptyKillMock).toHaveBeenCalledWith("SIGINT"); |
| expect(signalProcessTreeMock).not.toHaveBeenCalled(); |
| } finally { |
| if (originalPlatform) { |
| Object.defineProperty(process, "platform", originalPlatform); |
| } |
| } |
| }); |
|
|
| it("uses process-tree kill for SIGKILL on Windows", async () => { |
| const originalPlatform = Object.getOwnPropertyDescriptor(process, "platform"); |
| Object.defineProperty(process, "platform", { value: "win32", configurable: true }); |
| try { |
| spawnMock.mockReturnValue(createStubPty(4567)); |
|
|
| const adapter = await createPtyAdapter({ |
| shell: "powershell.exe", |
| args: ["-NoLogo"], |
| }); |
|
|
| adapter.kill("SIGKILL"); |
| expect(signalPtySessionTreeMock).toHaveBeenCalledWith(4567, "SIGKILL"); |
| expect(signalProcessTreeMock).not.toHaveBeenCalled(); |
| expect(ptyKillMock).not.toHaveBeenCalled(); |
| } finally { |
| if (originalPlatform) { |
| Object.defineProperty(process, "platform", originalPlatform); |
| } |
| } |
| }); |
| }); |
|
|
