nntrivi2001
a0cd808456
A terminal mounted on a hidden tab sits in a 0x0 box; its first fit shrank xterm to 12x6 and the attach carried that size to tmux, so every background pane was squeezed (Claude's TUI redrawn at 12 columns). It now neither fits nor reports a size until shown, attaches with no size, and the server spawns such an attach at the window's own size (tmux.windowSize). A shown tab reports its size even when the fit did not change xterm's. Settings > Agents shows the host's login profiles to staff only: a developer got two 403s from reads that were never theirs.
381 lines
14 KiB
JavaScript
381 lines
14 KiB
JavaScript
/**
|
||
* @file pty-attach.test.js
|
||
* @description Unit tests for the PTY-attach helper's runId validation and
|
||
* data/control framing, using a fake node-pty implementation (no real tmux
|
||
* or PTY spawned).
|
||
* @author Nguyễn Ngọc Trí Vĩ <vinnt@smartgift.vn>
|
||
*/
|
||
const { describe, it, beforeEach, afterEach } = require("node:test");
|
||
const assert = require("node:assert/strict");
|
||
const { EventEmitter } = require("node:events");
|
||
const ptyAttach = require("../lib/pty-attach");
|
||
const tmux = require("../lib/tmux");
|
||
|
||
function makeFakePty() {
|
||
const emitter = new EventEmitter();
|
||
const writes = [];
|
||
const pty = {
|
||
onData: (fn) => emitter.on("data", fn),
|
||
onExit: (fn) => emitter.on("exit", fn),
|
||
write: (d) => writes.push(d),
|
||
resize: (cols, rows) => writes.push({ resize: [cols, rows] }),
|
||
kill: () => emitter.emit("exit", { exitCode: 0 }),
|
||
__emitter: emitter,
|
||
__writes: writes,
|
||
};
|
||
return pty;
|
||
}
|
||
|
||
function makeFakeWs() {
|
||
const emitter = new EventEmitter();
|
||
const sent = [];
|
||
return {
|
||
on: (evt, fn) => emitter.on(evt, fn),
|
||
send: (data, opts) => sent.push({ data, binary: !!(opts && opts.binary) }),
|
||
__emitter: emitter,
|
||
__sent: sent,
|
||
};
|
||
}
|
||
|
||
describe("pty-attach", () => {
|
||
let fakePty;
|
||
beforeEach(() => {
|
||
fakePty = makeFakePty();
|
||
ptyAttach.__setSpawnImpl(() => fakePty);
|
||
ptyAttach.__resetGroups();
|
||
tmux.__setExecImpl(() => "");
|
||
});
|
||
afterEach(() => {
|
||
tmux.__reset();
|
||
});
|
||
|
||
it("rejects a runId that doesn't match agenthub-lane-<digits>", () => {
|
||
assert.throws(() => ptyAttach.validateRunId("../../etc/passwd"), /EBADRUNID/);
|
||
assert.throws(() => ptyAttach.validateRunId("some-other-session"), /EBADRUNID/);
|
||
});
|
||
|
||
it("accepts a well-formed runId", () => {
|
||
assert.doesNotThrow(() => ptyAttach.validateRunId("agenthub-lane-42"));
|
||
assert.doesNotThrow(() => ptyAttach.validateRunId("agenthub-lane-42-3"));
|
||
assert.doesNotThrow(() => ptyAttach.validateRunId("agenthub-lane-42-9"));
|
||
assert.throws(() => ptyAttach.validateRunId("agenthub-lane-42-10"), /EBADRUNID/);
|
||
assert.throws(() => ptyAttach.validateRunId("agenthub-lane-42-0"), /EBADRUNID/);
|
||
});
|
||
|
||
it("leaves copy-mode before the first keystroke after a wheel, and only then", () => {
|
||
const calls = [];
|
||
tmux.__setExecImpl((args) => {
|
||
calls.push(args);
|
||
return "";
|
||
});
|
||
const ws = makeFakeWs();
|
||
ptyAttach.attach(ws, "agenthub-lane-1", { cols: 80, rows: 24 });
|
||
const leaves = () => calls.filter((c) => c[0] === "copy-mode").length;
|
||
const send = (t) => ws.__emitter.emit("message", Buffer.from(t), false);
|
||
|
||
send("a");
|
||
assert.equal(leaves(), 0, "no scroll yet: typing spawns no tmux");
|
||
send("\x1b[<64;10;5M\x1b[<64;10;5M");
|
||
send("\x1b[I");
|
||
assert.equal(leaves(), 0, "a wheel or a focus report is not typing");
|
||
send("b");
|
||
assert.deepEqual(calls.filter((c) => c[0] === "copy-mode")[0], [
|
||
"copy-mode",
|
||
"-q",
|
||
"-t",
|
||
"=agenthub-lane-1:",
|
||
]);
|
||
send("c");
|
||
assert.equal(leaves(), 1, "once per scroll");
|
||
assert.deepEqual(
|
||
fakePty.__writes.filter((w) => typeof w === "string"),
|
||
["a", "\x1b[<64;10;5M\x1b[<64;10;5M", "\x1b[I", "b", "c"]
|
||
);
|
||
});
|
||
|
||
it("turns tmux mouse mode on for the session it attaches to", () => {
|
||
const calls = [];
|
||
tmux.__setExecImpl((args) => {
|
||
calls.push(args);
|
||
return "";
|
||
});
|
||
ptyAttach.attach(makeFakeWs(), "agenthub-lane-1", { cols: 80, rows: 24 });
|
||
assert.deepEqual(calls[0].slice(0, 5), [
|
||
"set-option",
|
||
"-t",
|
||
"=agenthub-lane-1:",
|
||
"mouse",
|
||
"on",
|
||
]);
|
||
});
|
||
|
||
it("attaches with the RUNNING tmux server's own binary, not the one on PATH", () => {
|
||
// A tmux upgraded while its server runs leaves a newer client on PATH that
|
||
// the old server answers with "open terminal failed: not a terminal".
|
||
tmux.__setExecImpl((args) => (args[0] === "display-message" ? `${process.pid}\n` : ""));
|
||
let file;
|
||
ptyAttach.__setSpawnImpl((f) => {
|
||
file = f;
|
||
return fakePty;
|
||
});
|
||
ptyAttach.attach(makeFakeWs(), "agenthub-lane-1", { cols: 80, rows: 24 });
|
||
assert.equal(file, process.platform === "linux" ? `/proc/${process.pid}/exe` : "tmux");
|
||
});
|
||
|
||
it("falls back to tmux on PATH when the server's pid cannot be read", () => {
|
||
tmux.__setExecImpl((args) => {
|
||
if (args[0] === "display-message") throw new Error("no server running");
|
||
return "";
|
||
});
|
||
let file;
|
||
ptyAttach.__setSpawnImpl((f) => {
|
||
file = f;
|
||
return fakePty;
|
||
});
|
||
ptyAttach.attach(makeFakeWs(), "agenthub-lane-1", { cols: 80, rows: 24 });
|
||
assert.equal(file, "tmux");
|
||
});
|
||
|
||
it("still attaches even if the mouse-mode set-option call fails", () => {
|
||
tmux.__setExecImpl(() => {
|
||
throw new Error("no such session: agenthub-lane-1");
|
||
});
|
||
assert.doesNotThrow(() =>
|
||
ptyAttach.attach(makeFakeWs(), "agenthub-lane-1", { cols: 80, rows: 24 })
|
||
);
|
||
});
|
||
|
||
it("wires PTY data to binary WS frames and WS binary frames to PTY writes", () => {
|
||
const ws = makeFakeWs();
|
||
// Linux: a Windows attach also says `wheel` first (its own test below).
|
||
ptyAttach.attach(ws, "agenthub-lane-1", { cols: 80, rows: 24, platform: "linux" });
|
||
|
||
fakePty.__emitter.emit("data", "hello from claude");
|
||
assert.equal(ws.__sent.length, 1);
|
||
assert.equal(ws.__sent[0].data, "hello from claude");
|
||
assert.equal(ws.__sent[0].binary, true);
|
||
|
||
ws.__emitter.emit("message", Buffer.from("typed text"), { binary: true });
|
||
assert.deepEqual(fakePty.__writes[0], "typed text");
|
||
});
|
||
|
||
it("routes a JSON text frame with type resize to pty.resize", () => {
|
||
const ws = makeFakeWs();
|
||
ptyAttach.attach(ws, "agenthub-lane-1", { cols: 80, rows: 24 });
|
||
ws.__emitter.emit(
|
||
"message",
|
||
Buffer.from(JSON.stringify({ type: "resize", cols: 100, rows: 40 })),
|
||
{
|
||
binary: false,
|
||
}
|
||
);
|
||
assert.deepEqual(fakePty.__writes[0], { resize: [100, 40] });
|
||
});
|
||
|
||
it("forwards a plain text WS frame (keystrokes) to pty.write", () => {
|
||
// xterm.js's onData hands the browser a plain string, and
|
||
// WebSocket.send(string) always emits a TEXT frame — so every keystroke
|
||
// arrives here as non-binary. This must reach the pty, not be dropped as
|
||
// an unparseable control message.
|
||
const ws = makeFakeWs();
|
||
ptyAttach.attach(ws, "agenthub-lane-1", { cols: 80, rows: 24 });
|
||
ws.__emitter.emit("message", Buffer.from("ls -la\r"), { binary: false });
|
||
assert.deepEqual(fakePty.__writes[0], "ls -la\r");
|
||
});
|
||
|
||
it("sends an exit control message and closes on PTY exit", () => {
|
||
const ws = makeFakeWs();
|
||
let closed = false;
|
||
ws.close = () => {
|
||
closed = true;
|
||
};
|
||
ptyAttach.attach(ws, "agenthub-lane-1", { cols: 80, rows: 24 });
|
||
fakePty.__emitter.emit("exit", { exitCode: 0 });
|
||
const last = ws.__sent[ws.__sent.length - 1];
|
||
assert.equal(last.binary, false);
|
||
assert.deepEqual(JSON.parse(last.data), { type: "exit", code: 0 });
|
||
assert.equal(closed, true);
|
||
});
|
||
|
||
it("holds a second viewer at the first one's size until it takes the lead", () => {
|
||
// Two browsers of different sizes on one pane: tmux's `window-size latest`
|
||
// resized the window under whichever was not typing. One drives; the other
|
||
// renders the driver's grid.
|
||
const ptys = [];
|
||
ptyAttach.__setSpawnImpl((_f, _a, opts) => {
|
||
const p = makeFakePty();
|
||
p.opts = opts;
|
||
ptys.push(p);
|
||
return p;
|
||
});
|
||
const resize = (ws, cols, rows, drive) =>
|
||
ws.__emitter.emit(
|
||
"message",
|
||
Buffer.from(JSON.stringify({ type: "resize", cols, rows, drive })),
|
||
{
|
||
binary: false,
|
||
}
|
||
);
|
||
const a = makeFakeWs();
|
||
const b = makeFakeWs();
|
||
ptyAttach.attach(a, "agenthub-lane-1", { cols: 200, rows: 50 });
|
||
ptyAttach.attach(b, "agenthub-lane-1", { cols: 100, rows: 30 });
|
||
assert.deepEqual([ptys[1].opts.cols, ptys[1].opts.rows], [200, 50]);
|
||
assert.deepEqual(JSON.parse(b.__sent[0].data), { type: "size", cols: 200, rows: 50 });
|
||
|
||
resize(b, 100, 30); // its own fit, not a takeover: nothing moves
|
||
assert.equal(ptys[1].__writes.length, 0);
|
||
|
||
resize(b, 100, 30, true); // a keystroke in b
|
||
assert.deepEqual(ptys[1].__writes.at(-1), { resize: [100, 30] });
|
||
assert.deepEqual(ptys[0].__writes.at(-1), { resize: [100, 30] });
|
||
assert.deepEqual(JSON.parse(a.__sent.at(-1).data), { type: "size", cols: 100, rows: 30 });
|
||
|
||
b.__emitter.emit("close"); // the driver leaves: the rest size themselves
|
||
assert.deepEqual(JSON.parse(a.__sent.at(-1).data), { type: "lead" });
|
||
});
|
||
|
||
it("attaches a terminal that names no size at the window's own size", () => {
|
||
// A terminal on a hidden tab is 0×0 and sends no size; spawning its attach
|
||
// at a default resized the pane under every other client.
|
||
const opts = [];
|
||
ptyAttach.__setSpawnImpl((_f, _a, o) => {
|
||
opts.push(o);
|
||
return makeFakePty();
|
||
});
|
||
tmux.__setExecImpl((args) => (args.includes("#{window_width} #{window_height}") ? "141 48\n" : ""));
|
||
ptyAttach.attach(makeFakeWs(), "agenthub-lane-1", { cols: undefined, rows: undefined });
|
||
assert.deepEqual([opts[0].cols, opts[0].rows], [141, 48]);
|
||
// tmux cannot answer: the old default, never a crash.
|
||
ptyAttach.__resetGroups();
|
||
tmux.__setExecImpl(() => {
|
||
throw new Error("no server");
|
||
});
|
||
ptyAttach.attach(makeFakeWs(), "agenthub-lane-2", { cols: undefined, rows: undefined });
|
||
assert.deepEqual([opts[1].cols, opts[1].rows], [80, 24]);
|
||
});
|
||
|
||
it("survives a stopped pane: pipe errors, typing and resizes after the attach exited", () => {
|
||
// Windows node-pty re-throws a read-pipe error nobody listens for, and its
|
||
// write pipe has no listener at all: Stop (kill-session) ended the attach
|
||
// with EPIPE and the uncaught error killed the whole dashboard.
|
||
const ptys = [];
|
||
ptyAttach.__setSpawnImpl(() => {
|
||
const p = makeFakePty();
|
||
p.on = (evt, fn) => p.__emitter.on(evt, fn);
|
||
p._agent = { inSocket: new EventEmitter() };
|
||
p.resize = () => {
|
||
if (p.__gone) throw new Error("Cannot resize a pty that has already exited");
|
||
};
|
||
p.write = () => {
|
||
if (p.__gone) throw new Error("write EPIPE");
|
||
};
|
||
ptys.push(p);
|
||
return p;
|
||
});
|
||
const a = makeFakeWs();
|
||
const b = makeFakeWs();
|
||
a.close = b.close = () => {};
|
||
ptyAttach.attach(a, "agenthub-lane-1", { cols: 80, rows: 24 });
|
||
ptyAttach.attach(b, "agenthub-lane-1", { cols: 80, rows: 24 });
|
||
|
||
const epipe = Object.assign(new Error("read EPIPE"), { code: "EPIPE" });
|
||
assert.doesNotThrow(() => ptys[0].__emitter.emit("error", epipe));
|
||
assert.doesNotThrow(() => ptys[0]._agent.inSocket.emit("error", epipe));
|
||
|
||
ptys[0].__gone = true;
|
||
ptys[0].__emitter.emit("exit", { exitCode: 1 }); // a's close event not yet in
|
||
const msg = (ws, data, binary) => ws.__emitter.emit("message", Buffer.from(data), { binary });
|
||
assert.doesNotThrow(() =>
|
||
msg(b, JSON.stringify({ type: "resize", cols: 90, rows: 30, drive: true }), false)
|
||
);
|
||
assert.doesNotThrow(() => msg(a, "x", true));
|
||
ptys[1].__gone = true; // exited, onExit still queued
|
||
assert.doesNotThrow(() => msg(b, "y", true));
|
||
});
|
||
|
||
it("kills the PTY attach process when the WS connection closes", () => {
|
||
const ws = makeFakeWs();
|
||
ptyAttach.attach(ws, "agenthub-lane-1", { cols: 80, rows: 24 });
|
||
let killed = false;
|
||
fakePty.kill = () => {
|
||
killed = true;
|
||
};
|
||
ws.__emitter.emit("close");
|
||
assert.equal(killed, true);
|
||
});
|
||
});
|
||
|
||
describe("attachBinary on Windows", () => {
|
||
it("names tmux with its extension — node-pty there never adds `.exe`", () => {
|
||
// A bare `tmux` made node-pty answer "File not found" on every attach, so
|
||
// the browser's terminal opened, closed and reconnected every 1.5 s.
|
||
const saved = process.env.PATH;
|
||
process.env.PATH = "";
|
||
try {
|
||
assert.equal(ptyAttach.attachBinary("win32"), "tmux.exe");
|
||
} finally {
|
||
process.env.PATH = saved;
|
||
}
|
||
});
|
||
|
||
it("attaches through node-pty's bundled conpty.dll on Windows only", () => {
|
||
// The inbox ConPTY re-renders psmux's output and leaves stray cells
|
||
// (torn left edge, bars mid-screen) wherever its glyph widths disagree
|
||
// with xterm.js's.
|
||
for (const [platform, dll] of [
|
||
["win32", true],
|
||
["linux", undefined],
|
||
]) {
|
||
let opts;
|
||
ptyAttach.__setSpawnImpl((_f, _a, o) => {
|
||
opts = o;
|
||
return makeFakePty();
|
||
});
|
||
ptyAttach.attach(makeFakeWs(), "agenthub-lane-1", { cols: 80, rows: 24, platform });
|
||
assert.equal(opts.useConptyDll, dll);
|
||
ptyAttach.__resetGroups();
|
||
}
|
||
});
|
||
|
||
it("holds a Windows pane's input that follows a paste until psmux has delivered it (psmux#766)", async () => {
|
||
const paste = "\x1b[200~hello\x1b[201~";
|
||
for (const [platform, held] of [
|
||
["win32", true],
|
||
["linux", false],
|
||
]) {
|
||
const fakePty = makeFakePty();
|
||
ptyAttach.__setSpawnImpl(() => fakePty);
|
||
tmux.__setExecImpl(() => "");
|
||
const ws = makeFakeWs();
|
||
ptyAttach.attach(ws, "agenthub-lane-1", { cols: 80, rows: 24, platform });
|
||
ws.__emitter.emit("message", Buffer.from(paste), false);
|
||
ws.__emitter.emit("message", Buffer.from("\r"), false);
|
||
assert.deepEqual(fakePty.__writes, held ? [paste] : [paste, "\r"], platform);
|
||
if (held) {
|
||
await new Promise((r) => setTimeout(r, 800));
|
||
assert.deepEqual(fakePty.__writes, [paste, "\r"]);
|
||
}
|
||
ptyAttach.__resetGroups();
|
||
}
|
||
tmux.__reset();
|
||
});
|
||
|
||
it("tells a Windows attach to send the wheel itself (psmux never tracks the mouse)", () => {
|
||
for (const [platform, told] of [
|
||
["win32", true],
|
||
["linux", false],
|
||
]) {
|
||
const ws = makeFakeWs();
|
||
ptyAttach.attach(ws, "agenthub-lane-1", { cols: 80, rows: 24, platform });
|
||
const said = ws.__sent.filter((m) => !m.binary).map((m) => JSON.parse(m.data));
|
||
assert.equal(
|
||
said.some((m) => m.type === "wheel"),
|
||
told,
|
||
platform
|
||
);
|
||
ptyAttach.__resetGroups();
|
||
}
|
||
});
|
||
});
|