683 lines
19 KiB
TypeScript
683 lines
19 KiB
TypeScript
import { describe, it, expect, afterEach } from "vitest";
|
|
import {
|
|
createTerminal,
|
|
ensureNodePtySpawnHelperExecutableForCurrentPlatform,
|
|
type TerminalSession,
|
|
} from "./terminal.js";
|
|
import { chmodSync, mkdtempSync, mkdirSync, rmSync, statSync, writeFileSync } from "node:fs";
|
|
import { join } from "node:path";
|
|
import { tmpdir } from "node:os";
|
|
|
|
// Extract text from a single row
|
|
function getRowText(state: ReturnType<TerminalSession["getState"]>, rowIndex: number): string {
|
|
return state.grid[rowIndex].map((cell) => cell.char).join("").trimEnd();
|
|
}
|
|
|
|
// Extract all visible lines as array (trimmed, empty lines included)
|
|
function getLines(state: ReturnType<TerminalSession["getState"]>): string[] {
|
|
return state.grid.map((row) => row.map((cell) => cell.char).join("").trimEnd());
|
|
}
|
|
|
|
// Wait for terminal state to match expected lines
|
|
async function waitForLines(
|
|
session: TerminalSession,
|
|
expectedLines: string[],
|
|
timeoutMs = 5000
|
|
): Promise<void> {
|
|
const start = Date.now();
|
|
while (Date.now() - start < timeoutMs) {
|
|
const lines = getLines(session.getState());
|
|
let matches = true;
|
|
for (let i = 0; i < expectedLines.length; i++) {
|
|
if (lines[i] !== expectedLines[i]) {
|
|
matches = false;
|
|
break;
|
|
}
|
|
}
|
|
if (matches) {
|
|
return;
|
|
}
|
|
await new Promise((resolve) => setTimeout(resolve, 50));
|
|
}
|
|
const actual = getLines(session.getState()).slice(0, expectedLines.length);
|
|
throw new Error(
|
|
`Timeout waiting for expected lines.\nExpected:\n${JSON.stringify(expectedLines, null, 2)}\nActual:\n${JSON.stringify(actual, null, 2)}`
|
|
);
|
|
}
|
|
|
|
describe("Terminal", () => {
|
|
const sessions: TerminalSession[] = [];
|
|
const temporaryDirs: string[] = [];
|
|
|
|
afterEach(async () => {
|
|
for (const session of sessions) {
|
|
session.kill();
|
|
}
|
|
sessions.length = 0;
|
|
while (temporaryDirs.length > 0) {
|
|
const dir = temporaryDirs.pop();
|
|
if (dir) {
|
|
rmSync(dir, { recursive: true, force: true });
|
|
}
|
|
}
|
|
});
|
|
|
|
function trackSession(session: TerminalSession): TerminalSession {
|
|
sessions.push(session);
|
|
return session;
|
|
}
|
|
|
|
describe("createTerminal", () => {
|
|
it("ensures darwin prebuild spawn-helper is executable", () => {
|
|
const packageRoot = mkdtempSync(join(tmpdir(), "terminal-node-pty-helper-"));
|
|
temporaryDirs.push(packageRoot);
|
|
const prebuildDir = join(packageRoot, "prebuilds", `darwin-${process.arch}`);
|
|
mkdirSync(prebuildDir, { recursive: true });
|
|
const helperPath = join(prebuildDir, "spawn-helper");
|
|
writeFileSync(helperPath, "#!/bin/sh\necho helper\n");
|
|
chmodSync(helperPath, 0o644);
|
|
|
|
ensureNodePtySpawnHelperExecutableForCurrentPlatform({
|
|
packageRoot,
|
|
platform: "darwin",
|
|
force: true,
|
|
});
|
|
|
|
expect(statSync(helperPath).mode & 0o111).toBe(0o111);
|
|
});
|
|
|
|
it("creates a terminal session with an id, name, and cwd", async () => {
|
|
const session = trackSession(
|
|
await createTerminal({
|
|
cwd: "/tmp",
|
|
shell: "/bin/sh",
|
|
env: { PS1: "$ " },
|
|
})
|
|
);
|
|
|
|
expect(session.id).toBeDefined();
|
|
expect(typeof session.id).toBe("string");
|
|
expect(session.id.length).toBeGreaterThan(0);
|
|
expect(session.name).toBe("Terminal");
|
|
expect(session.cwd).toBe("/tmp");
|
|
});
|
|
|
|
it("uses custom name when provided", async () => {
|
|
const session = trackSession(
|
|
await createTerminal({
|
|
cwd: "/tmp",
|
|
shell: "/bin/sh",
|
|
env: { PS1: "$ " },
|
|
name: "Dev Server",
|
|
})
|
|
);
|
|
|
|
expect(session.name).toBe("Dev Server");
|
|
});
|
|
|
|
it("uses default shell if not specified", async () => {
|
|
const session = trackSession(
|
|
await createTerminal({
|
|
cwd: "/tmp",
|
|
})
|
|
);
|
|
|
|
expect(session.id).toBeDefined();
|
|
});
|
|
|
|
it("uses default rows and cols", async () => {
|
|
const session = trackSession(
|
|
await createTerminal({
|
|
cwd: "/tmp",
|
|
shell: "/bin/sh",
|
|
env: { PS1: "$ " },
|
|
})
|
|
);
|
|
|
|
const state = session.getState();
|
|
expect(state.rows).toBe(24);
|
|
expect(state.cols).toBe(80);
|
|
});
|
|
|
|
it("respects custom rows and cols", async () => {
|
|
const session = trackSession(
|
|
await createTerminal({
|
|
cwd: "/tmp",
|
|
shell: "/bin/sh",
|
|
env: { PS1: "$ " },
|
|
rows: 40,
|
|
cols: 120,
|
|
})
|
|
);
|
|
|
|
const state = session.getState();
|
|
expect(state.rows).toBe(40);
|
|
expect(state.cols).toBe(120);
|
|
});
|
|
});
|
|
|
|
describe("send input", () => {
|
|
it("executes a simple echo command", async () => {
|
|
const session = trackSession(
|
|
await createTerminal({
|
|
cwd: "/tmp",
|
|
shell: "/bin/sh",
|
|
env: { PS1: "$ " },
|
|
})
|
|
);
|
|
|
|
// Wait for initial prompt, then send command
|
|
await waitForLines(session, ["$"]);
|
|
|
|
session.send({ type: "input", data: "echo hello\r" });
|
|
|
|
// After running "echo hello", terminal should show:
|
|
// Line 0: "$ echo hello"
|
|
// Line 1: "hello"
|
|
// Line 2: "$"
|
|
await waitForLines(session, ["$ echo hello", "hello", "$"]);
|
|
|
|
const state = session.getState();
|
|
expect(getRowText(state, 0)).toBe("$ echo hello");
|
|
expect(getRowText(state, 1)).toBe("hello");
|
|
expect(getRowText(state, 2)).toBe("$");
|
|
});
|
|
|
|
it("executes multiple commands sequentially", async () => {
|
|
const session = trackSession(
|
|
await createTerminal({
|
|
cwd: "/tmp",
|
|
shell: "/bin/sh",
|
|
env: { PS1: "$ " },
|
|
})
|
|
);
|
|
|
|
await waitForLines(session, ["$"]);
|
|
|
|
session.send({ type: "input", data: "echo first\r" });
|
|
await waitForLines(session, ["$ echo first", "first", "$"]);
|
|
|
|
session.send({ type: "input", data: "echo second\r" });
|
|
await waitForLines(session, [
|
|
"$ echo first",
|
|
"first",
|
|
"$ echo second",
|
|
"second",
|
|
"$",
|
|
]);
|
|
|
|
const state = session.getState();
|
|
expect(getRowText(state, 0)).toBe("$ echo first");
|
|
expect(getRowText(state, 1)).toBe("first");
|
|
expect(getRowText(state, 2)).toBe("$ echo second");
|
|
expect(getRowText(state, 3)).toBe("second");
|
|
expect(getRowText(state, 4)).toBe("$");
|
|
});
|
|
|
|
it("captures output from pwd in specified cwd", async () => {
|
|
const session = trackSession(
|
|
await createTerminal({
|
|
cwd: "/tmp",
|
|
shell: "/bin/sh",
|
|
env: { PS1: "$ " },
|
|
})
|
|
);
|
|
|
|
await waitForLines(session, ["$"]);
|
|
|
|
session.send({ type: "input", data: "pwd\r" });
|
|
|
|
await waitForLines(session, ["$ pwd", "/tmp", "$"]);
|
|
|
|
const state = session.getState();
|
|
expect(getRowText(state, 0)).toBe("$ pwd");
|
|
expect(getRowText(state, 1)).toBe("/tmp");
|
|
expect(getRowText(state, 2)).toBe("$");
|
|
});
|
|
});
|
|
|
|
describe("colors", () => {
|
|
it("captures ANSI 16 color codes (mode 1)", async () => {
|
|
const session = trackSession(
|
|
await createTerminal({
|
|
cwd: "/tmp",
|
|
shell: "/bin/sh",
|
|
env: { PS1: "$ ", TERM: "xterm-256color" },
|
|
})
|
|
);
|
|
|
|
await waitForLines(session, ["$"]);
|
|
|
|
// \033[31m = ANSI red (color 1)
|
|
session.send({ type: "input", data: "printf '\\033[31mRED\\033[0m'\r" });
|
|
|
|
await waitForLines(session, ["$ printf '\\033[31mRED\\033[0m'", "RED$"]);
|
|
|
|
const state = session.getState();
|
|
const outputRow = state.grid[1];
|
|
|
|
expect(outputRow[0].char).toBe("R");
|
|
expect(outputRow[0].fg).toBe(1); // ANSI red = 1
|
|
expect(outputRow[0].fgMode).toBe(1); // Mode 1 = 16 ANSI colors
|
|
|
|
// The "$" after RED should have default color
|
|
expect(outputRow[3].char).toBe("$");
|
|
expect(outputRow[3].fg).toBe(undefined);
|
|
expect(outputRow[3].fgMode).toBe(undefined);
|
|
});
|
|
|
|
it("captures 256 color codes (mode 2)", async () => {
|
|
const session = trackSession(
|
|
await createTerminal({
|
|
cwd: "/tmp",
|
|
shell: "/bin/sh",
|
|
env: { PS1: "$ ", TERM: "xterm-256color" },
|
|
})
|
|
);
|
|
|
|
await waitForLines(session, ["$"]);
|
|
|
|
// \033[38;5;208m = 256-color orange (color 208)
|
|
session.send({ type: "input", data: "printf '\\033[38;5;208mORG\\033[0m'\r" });
|
|
|
|
await waitForLines(session, ["$ printf '\\033[38;5;208mORG\\033[0m'", "ORG$"]);
|
|
|
|
const state = session.getState();
|
|
const outputRow = state.grid[1];
|
|
|
|
// Check O cell
|
|
expect(outputRow[0].char).toBe("O");
|
|
expect(outputRow[0].fg).toBe(208); // 256-color index
|
|
expect(outputRow[0].fgMode).toBe(2); // Mode 2 = 256 colors
|
|
});
|
|
|
|
it("captures true color RGB (mode 3)", async () => {
|
|
const session = trackSession(
|
|
await createTerminal({
|
|
cwd: "/tmp",
|
|
shell: "/bin/sh",
|
|
env: { PS1: "$ ", TERM: "xterm-256color" },
|
|
})
|
|
);
|
|
|
|
await waitForLines(session, ["$"]);
|
|
|
|
// \033[38;2;255;128;64m = true color RGB(255, 128, 64)
|
|
session.send({ type: "input", data: "printf '\\033[38;2;255;128;64mRGB\\033[0m'\r" });
|
|
|
|
await waitForLines(session, ["$ printf '\\033[38;2;255;128;64mRGB\\033[0m'", "RGB$"]);
|
|
|
|
const state = session.getState();
|
|
const outputRow = state.grid[1];
|
|
|
|
// Check R cell
|
|
expect(outputRow[0].char).toBe("R");
|
|
expect(outputRow[0].fgMode).toBe(3); // Mode 3 = true color
|
|
|
|
// The color value should be packed RGB: (255 << 16) | (128 << 8) | 64
|
|
const expectedPacked = (255 << 16) | (128 << 8) | 64;
|
|
expect(outputRow[0].fg).toBe(expectedPacked);
|
|
});
|
|
|
|
it("captures background colors", async () => {
|
|
const session = trackSession(
|
|
await createTerminal({
|
|
cwd: "/tmp",
|
|
shell: "/bin/sh",
|
|
env: { PS1: "$ ", TERM: "xterm-256color" },
|
|
})
|
|
);
|
|
|
|
await waitForLines(session, ["$"]);
|
|
|
|
// \033[41m = ANSI red background
|
|
session.send({ type: "input", data: "printf '\\033[41mBG\\033[0m'\r" });
|
|
|
|
await waitForLines(session, ["$ printf '\\033[41mBG\\033[0m'", "BG$"]);
|
|
|
|
const state = session.getState();
|
|
const outputRow = state.grid[1];
|
|
|
|
expect(outputRow[0].char).toBe("B");
|
|
expect(outputRow[0].bg).toBe(1); // ANSI red = 1
|
|
expect(outputRow[0].bgMode).toBe(1); // Mode 1 = 16 ANSI colors
|
|
});
|
|
});
|
|
|
|
describe("resize", () => {
|
|
it("updates terminal dimensions on resize", async () => {
|
|
const session = trackSession(
|
|
await createTerminal({
|
|
cwd: "/tmp",
|
|
shell: "/bin/sh",
|
|
env: { PS1: "$ " },
|
|
rows: 24,
|
|
cols: 80,
|
|
})
|
|
);
|
|
|
|
session.send({ type: "resize", rows: 40, cols: 120 });
|
|
|
|
await new Promise((resolve) => setTimeout(resolve, 100));
|
|
|
|
const state = session.getState();
|
|
expect(state.rows).toBe(40);
|
|
expect(state.cols).toBe(120);
|
|
});
|
|
|
|
it("grid reflects new dimensions after resize", async () => {
|
|
const session = trackSession(
|
|
await createTerminal({
|
|
cwd: "/tmp",
|
|
shell: "/bin/sh",
|
|
env: { PS1: "$ " },
|
|
rows: 24,
|
|
cols: 80,
|
|
})
|
|
);
|
|
|
|
session.send({ type: "resize", rows: 10, cols: 40 });
|
|
await new Promise((resolve) => setTimeout(resolve, 100));
|
|
|
|
const state = session.getState();
|
|
expect(state.grid.length).toBe(10);
|
|
expect(state.grid[0].length).toBe(40);
|
|
});
|
|
});
|
|
|
|
describe("subscribe", () => {
|
|
it("receives full state on initial subscription", async () => {
|
|
const session = trackSession(
|
|
await createTerminal({
|
|
cwd: "/tmp",
|
|
shell: "/bin/sh",
|
|
env: { PS1: "$ " },
|
|
})
|
|
);
|
|
|
|
const messages: Array<{ type: string }> = [];
|
|
const unsubscribe = session.subscribe((msg) => {
|
|
messages.push(msg);
|
|
});
|
|
|
|
await new Promise((resolve) => setTimeout(resolve, 100));
|
|
|
|
expect(messages.length).toBeGreaterThan(0);
|
|
expect(messages[0].type).toBe("full");
|
|
|
|
unsubscribe();
|
|
});
|
|
|
|
it("receives messages on updates", async () => {
|
|
const session = trackSession(
|
|
await createTerminal({
|
|
cwd: "/tmp",
|
|
shell: "/bin/sh",
|
|
env: { PS1: "$ " },
|
|
})
|
|
);
|
|
|
|
await waitForLines(session, ["$"]);
|
|
|
|
const messages: Array<{ type: string }> = [];
|
|
const unsubscribe = session.subscribe((msg) => {
|
|
messages.push(msg);
|
|
});
|
|
|
|
messages.length = 0;
|
|
|
|
session.send({ type: "input", data: "echo test\r" });
|
|
|
|
await waitForLines(session, ["$ echo test", "test", "$"]);
|
|
|
|
expect(messages.length).toBeGreaterThan(0);
|
|
|
|
unsubscribe();
|
|
});
|
|
|
|
it("unsubscribe stops receiving messages", async () => {
|
|
const session = trackSession(
|
|
await createTerminal({
|
|
cwd: "/tmp",
|
|
shell: "/bin/sh",
|
|
env: { PS1: "$ " },
|
|
})
|
|
);
|
|
|
|
await waitForLines(session, ["$"]);
|
|
|
|
const messages: Array<{ type: string }> = [];
|
|
const unsubscribe = session.subscribe((msg) => {
|
|
messages.push(msg);
|
|
});
|
|
|
|
unsubscribe();
|
|
messages.length = 0;
|
|
|
|
session.send({ type: "input", data: "echo after\r" });
|
|
await new Promise((resolve) => setTimeout(resolve, 200));
|
|
|
|
expect(messages.length).toBe(0);
|
|
});
|
|
});
|
|
|
|
describe("raw output stream", () => {
|
|
it("streams raw output chunks with byte offsets", async () => {
|
|
const session = trackSession(
|
|
await createTerminal({
|
|
cwd: "/tmp",
|
|
shell: "/bin/sh",
|
|
env: { PS1: "$ " },
|
|
})
|
|
);
|
|
|
|
await waitForLines(session, ["$"]);
|
|
|
|
const chunks: Array<{ data: string; startOffset: number; endOffset: number }> = [];
|
|
const sub = session.subscribeRaw((chunk) => {
|
|
chunks.push({
|
|
data: chunk.data,
|
|
startOffset: chunk.startOffset,
|
|
endOffset: chunk.endOffset,
|
|
});
|
|
});
|
|
|
|
session.send({ type: "input", data: "echo raw-stream\r" });
|
|
await waitForLines(session, ["$ echo raw-stream", "raw-stream", "$"]);
|
|
|
|
expect(chunks.length).toBeGreaterThan(0);
|
|
expect(chunks[chunks.length - 1].endOffset).toBe(session.getOutputOffset());
|
|
for (let i = 1; i < chunks.length; i++) {
|
|
expect(chunks[i].startOffset).toBe(chunks[i - 1].endOffset);
|
|
}
|
|
|
|
sub.unsubscribe();
|
|
});
|
|
|
|
it("replays buffered output from offset", async () => {
|
|
const session = trackSession(
|
|
await createTerminal({
|
|
cwd: "/tmp",
|
|
shell: "/bin/sh",
|
|
env: { PS1: "$ " },
|
|
})
|
|
);
|
|
|
|
await waitForLines(session, ["$"]);
|
|
|
|
const seen: Array<{ data: string; endOffset: number; replay: boolean }> = [];
|
|
const firstSub = session.subscribeRaw((chunk) => {
|
|
seen.push({
|
|
data: chunk.data,
|
|
endOffset: chunk.endOffset,
|
|
replay: chunk.replay,
|
|
});
|
|
});
|
|
|
|
session.send({ type: "input", data: "echo before-detach\r" });
|
|
await waitForLines(session, ["$ echo before-detach", "before-detach", "$"]);
|
|
|
|
const resumeOffset = seen[seen.length - 1]?.endOffset ?? 0;
|
|
firstSub.unsubscribe();
|
|
|
|
session.send({ type: "input", data: "echo after-detach\r" });
|
|
await waitForLines(session, [
|
|
"$ echo before-detach",
|
|
"before-detach",
|
|
"$ echo after-detach",
|
|
"after-detach",
|
|
"$",
|
|
]);
|
|
|
|
const replayed: string[] = [];
|
|
const secondSub = session.subscribeRaw(
|
|
(chunk) => {
|
|
if (chunk.replay) {
|
|
replayed.push(chunk.data);
|
|
}
|
|
},
|
|
{ fromOffset: resumeOffset }
|
|
);
|
|
|
|
const replayText = replayed.join("");
|
|
expect(replayText).toContain("after-detach");
|
|
expect(secondSub.replayedFrom).toBeGreaterThanOrEqual(resumeOffset);
|
|
secondSub.unsubscribe();
|
|
});
|
|
});
|
|
|
|
describe("getState", () => {
|
|
it("returns current terminal state with grid", async () => {
|
|
const session = trackSession(
|
|
await createTerminal({
|
|
cwd: "/tmp",
|
|
shell: "/bin/sh",
|
|
env: { PS1: "$ " },
|
|
rows: 24,
|
|
cols: 80,
|
|
})
|
|
);
|
|
|
|
const state = session.getState();
|
|
|
|
expect(state.rows).toBe(24);
|
|
expect(state.cols).toBe(80);
|
|
expect(state.grid).toBeDefined();
|
|
expect(state.grid.length).toBe(24);
|
|
expect(state.grid[0].length).toBe(80);
|
|
expect(state.cursor).toBeDefined();
|
|
expect(typeof state.cursor.row).toBe("number");
|
|
expect(typeof state.cursor.col).toBe("number");
|
|
});
|
|
|
|
it("grid cells have char and color attributes", async () => {
|
|
const session = trackSession(
|
|
await createTerminal({
|
|
cwd: "/tmp",
|
|
shell: "/bin/sh",
|
|
env: { PS1: "$ " },
|
|
})
|
|
);
|
|
|
|
await waitForLines(session, ["$"]);
|
|
|
|
const state = session.getState();
|
|
// First cell should be "$"
|
|
expect(state.grid[0][0].char).toBe("$");
|
|
expect(state.grid[0][0]).toHaveProperty("fg");
|
|
expect(state.grid[0][0]).toHaveProperty("bg");
|
|
});
|
|
});
|
|
|
|
describe("scrollback", () => {
|
|
it("preserves scrollback buffer", async () => {
|
|
const session = trackSession(
|
|
await createTerminal({
|
|
cwd: "/tmp",
|
|
shell: "/bin/sh",
|
|
env: { PS1: "$ " },
|
|
rows: 5,
|
|
cols: 80,
|
|
})
|
|
);
|
|
|
|
await waitForLines(session, ["$"]);
|
|
|
|
// seq 1 20 produces 20 lines of output
|
|
// With 5 rows, we expect lines to scroll into scrollback
|
|
session.send({ type: "input", data: "seq 1 20\r" });
|
|
|
|
// Wait for command to finish - final prompt appears after "20"
|
|
// In a 5-row terminal, we'll see the last lines plus prompt
|
|
// The visible area will show something like: 17, 18, 19, 20, $
|
|
await waitForLines(session, ["17", "18", "19", "20", "$"]);
|
|
|
|
const state = session.getState();
|
|
|
|
// Scrollback should contain the earlier output
|
|
expect(state.scrollback.length).toBeGreaterThan(0);
|
|
|
|
const scrollbackText = state.scrollback
|
|
.map((row) => row.map((cell) => cell.char).join("").trimEnd())
|
|
.filter((line) => line.length > 0);
|
|
|
|
// The scrollback should contain the command and early numbers
|
|
expect(scrollbackText).toContain("$ seq 1 20");
|
|
expect(scrollbackText).toContain("1");
|
|
expect(scrollbackText).toContain("2");
|
|
expect(scrollbackText).toContain("3");
|
|
});
|
|
});
|
|
|
|
describe("kill", () => {
|
|
it("terminates the shell process", async () => {
|
|
const session = trackSession(
|
|
await createTerminal({
|
|
cwd: "/tmp",
|
|
shell: "/bin/sh",
|
|
env: { PS1: "$ " },
|
|
})
|
|
);
|
|
|
|
await waitForLines(session, ["$"]);
|
|
|
|
session.kill();
|
|
|
|
// Should not throw when trying to get state after kill
|
|
const state = session.getState();
|
|
expect(state).toBeDefined();
|
|
});
|
|
|
|
it("send after kill is a no-op", async () => {
|
|
const session = trackSession(
|
|
await createTerminal({
|
|
cwd: "/tmp",
|
|
shell: "/bin/sh",
|
|
env: { PS1: "$ " },
|
|
})
|
|
);
|
|
|
|
session.kill();
|
|
|
|
// Should not throw
|
|
session.send({ type: "input", data: "echo test\r" });
|
|
});
|
|
});
|
|
|
|
describe("mouse events", () => {
|
|
it("accepts mouse events without throwing", async () => {
|
|
const session = trackSession(
|
|
await createTerminal({
|
|
cwd: "/tmp",
|
|
shell: "/bin/sh",
|
|
env: { PS1: "$ " },
|
|
})
|
|
);
|
|
|
|
// Should not throw
|
|
session.send({ type: "mouse", row: 0, col: 0, button: 0, action: "down" });
|
|
session.send({ type: "mouse", row: 0, col: 0, button: 0, action: "up" });
|
|
});
|
|
});
|
|
});
|