mirror of
https://github.com/binaricat/Netcatty.git
synced 2026-11-16 20:11:08 +00:00
* fix(terminal): batch hidden log output * fix(terminal): preserve ordered hidden output * fix(terminal): bound hidden output overhead * fix(terminal): respect custom tab stops in timestamps * fix(terminal): preserve terminal parser state * fix(terminal): preserve hidden output boundaries * fix(terminal): retain batching with prompt formatting * fix(terminal): preserve prompt boundaries through transforms * fix(terminal): handle unbatched prompt output * fix(terminal): preserve batched prompt and time boundaries * fix(terminal): retain background timestamp boundaries * fix(terminal): preserve visible timestamp boundaries * fix(terminal): separate shell output from tui frames * fix(terminal): separate output after tui exit * fix(terminal): preserve prompts across output slices * fix(terminal): flush output before context reads * fix(terminal): time-slice timestamp marker cleanup * fix(terminal): preserve prompt columns after bare LF * fix(terminal): preserve background write yielding * fix(terminal): retain yields across timestamp boundaries * perf(terminal): scan output boundaries once * fix(terminal): track prompt cursor movement * fix(terminal): resume prompt scan after resets * fix(terminal): preserve stateful prompt ordering * fix(terminal): drain close output before capture * fix(terminal): measure control-only prompt prefixes * fix(terminal): preserve prompt control boundaries * fix(terminal): preserve prompt mode toggles * fix(terminal): bound hidden batches and unfocus policy Always drain write-coalescer size caps even when scheduled frames are gated, keep unfocused-but-visible panes on throttled batching instead of per-chunk force flush, compute prompt starts on post-transform display data, and model full-width wrap so prompt-on-newline does not insert a blank line. * perf(terminal): skip off-path timestamps and share alt-screen probes When host line timestamps are disabled, write plain bytes without the segmenter/marker hot path. Reuse one alt-screen CSI probe per coalesced chunk for frame split and schedule mode, and reuse a single full-batch visual-row measure on the single-segment batched timestamp path. * fix(terminal): read line-timestamp enable from live hostRef Session data handlers close over boot-time ctx.host, so toolbar/vault toggles of showLineTimestamps were ignored. Prefer hostRef.current for the marker hot-path gate and keep hostRef synced on every Terminal render. * perf(terminal): per-second timestamp ledger while gutter is off When line timestamps are hidden, keep a lightweight one-stamp-per-second ledger without xterm markers. Opening the gutter materializes recent ledger entries into markers for paint; while visible, keep per-line markers for accuracy. * perf(terminal): separate timestamp record from gutter paint Always record a one-stamp-per-second ledger on the write path with no xterm markers. Gutter rendering maps the ledger to visible rows, so open and closed modes share the same cheap record path. * fix(terminal): fill gutter gaps with previous second stamp When painting line timestamps from the per-second ledger, blank rows between stamps inherit the preceding stamp's label so multi-line output in the same second is fully labeled. * fix(terminal): stop empty gutter paint and false scrollback rebase Only rebase ledger anchors when the buffer is actually full and baseY grows from top trim — not when baseY rises while the buffer is still growing (which deleted MOTD/login stamps on scroll). Cap gutter paint at the last content line so empty viewport rows past the cursor stay blank. * fix(terminal): soft-wrap stamp placement and sparse reflow anchors Estimate ledger lines with visual-row measurement so narrow terminals do not pin the next second on a wrap continuation. After each write, attach at most one xterm marker per stamped second so reflow and scrollback trim keep anchors honest without per-line marker storms. * fix(terminal): ignore alt-screen rows when placing timestamp anchors Stamp line estimates froze incorrectly through vim/less alt-screen output, so sparse reflow markers landed far below the restored normal buffer. Skip visual-row advancement while DEC alt-screen is active, key one-stamp-per-second from the batch arrival date, and only attach anchors still present in the ledger after capacity trim. * fix(terminal): seed stamp lines from normal buffer when already on alt When a write begins on the alternate screen, active cursor is the TUI row — freezing that through 1049 leave mis-pinned sparse anchors and dropped them past normal bufferLength. Seed and restore stamp estimates from buffer.normal, and cover multi-write already-on-alt leave+prompt. * fix(terminal): keep same-chunk pre-enter line on alt leave Leave CSI must not always re-read pre-write buffer.normal: when enter happened in the same walk, the frozen estimate already includes normal advances before the TUI. Only restore buffer.normal when the write started already on the alternate screen. * fix(terminal): pure alt stamp transitions that never rewind lines Stamp estimates stay in normal-buffer coordinates: seed once (active or buffer.normal when already on alt), freeze while alt is active, and on leave only clear altActive — never re-read the live term mid-walk. Export applyAltScreenAction with a table-driven unit test covering spurious leave, plus write-path cases for already-on-alt, same-chunk pre-enter advance, and leave-without-enter.
1235 lines
37 KiB
TypeScript
1235 lines
37 KiB
TypeScript
import test from "node:test";
|
||
import assert from "node:assert/strict";
|
||
|
||
import {
|
||
consumeOsc133CommandCompletion,
|
||
createPromptLineBreakState,
|
||
detectTerminalCommandCompletions,
|
||
findTerminalPromptSourceChunkVisibleStarts,
|
||
insertPromptLineBreakBeforePrompt,
|
||
markPromptLineBreakCommandPending,
|
||
markTerminalCommandCompletionPending,
|
||
prepareTerminalDataForPromptLineBreak,
|
||
syncPromptLineBreakState,
|
||
} from "./promptLineBreak";
|
||
|
||
test("finds prompt chunks across trailing and leading ANSI sequences", () => {
|
||
const trailingAnsiData = "file tail\x1b[0m$ ";
|
||
assert.deepEqual(
|
||
findTerminalPromptSourceChunkVisibleStarts(
|
||
trailingAnsiData,
|
||
"$ ",
|
||
["file tail\x1b[0m".length],
|
||
),
|
||
["file tail".length],
|
||
);
|
||
|
||
const leadingAnsiData = "file tail\x1b[32m$ ";
|
||
assert.deepEqual(
|
||
findTerminalPromptSourceChunkVisibleStarts(leadingAnsiData, "$ ", ["file tail".length]),
|
||
["file tail".length],
|
||
);
|
||
assert.deepEqual(findTerminalPromptSourceChunkVisibleStarts("file tail$ ", "$ ", []), []);
|
||
|
||
const clearData = "file tail\x1b[2J$ ";
|
||
const promptVisibleStarts = findTerminalPromptSourceChunkVisibleStarts(
|
||
clearData,
|
||
"$ ",
|
||
["file tail\x1b[2J".length],
|
||
);
|
||
const state = createPromptLineBreakState();
|
||
state.lastPromptText = "$ ";
|
||
state.pendingCommand = true;
|
||
assert.equal(
|
||
prepareTerminalDataForPromptLineBreak(
|
||
createFakeTerm("", 0) as never,
|
||
"file tail\x1b[2J\x1b[3J$ ",
|
||
state,
|
||
true,
|
||
promptVisibleStarts,
|
||
),
|
||
"file tail\r\n\x1b[2J\x1b[3J$ ",
|
||
);
|
||
});
|
||
|
||
test("keeps cursor movement before a prompt-side line break", () => {
|
||
const state = createPromptLineBreakState();
|
||
state.lastPromptText = "$ ";
|
||
state.pendingCommand = true;
|
||
const output = "foo\x1b[E";
|
||
const data = `${output}$ `;
|
||
const promptStarts = findTerminalPromptSourceChunkVisibleStarts(
|
||
data,
|
||
state.lastPromptText,
|
||
[output.length],
|
||
);
|
||
|
||
assert.equal(
|
||
prepareTerminalDataForPromptLineBreak(
|
||
createFakeTerm("", 0) as never,
|
||
data,
|
||
state,
|
||
true,
|
||
promptStarts,
|
||
),
|
||
data,
|
||
);
|
||
});
|
||
|
||
test("measures cursor-only prompt prefixes before deciding on a line break", () => {
|
||
const state = createPromptLineBreakState();
|
||
state.lastPromptText = "$ ";
|
||
state.pendingCommand = true;
|
||
const cursorForward = "\x1b[10C";
|
||
const data = `${cursorForward}$ `;
|
||
|
||
assert.equal(
|
||
prepareTerminalDataForPromptLineBreak(
|
||
createFakeTerm("", 0) as never,
|
||
data,
|
||
state,
|
||
true,
|
||
findTerminalPromptSourceChunkVisibleStarts(data, "$ ", [cursorForward.length]),
|
||
),
|
||
`${cursorForward}\r\n$ `,
|
||
);
|
||
});
|
||
|
||
test("does not move a clear-screen prompt away from cursor home", () => {
|
||
const state = createPromptLineBreakState();
|
||
state.lastPromptText = "$ ";
|
||
state.pendingCommand = true;
|
||
const data = "\x1b[H\x1b[2J$ ";
|
||
|
||
assert.equal(
|
||
prepareTerminalDataForPromptLineBreak(
|
||
createFakeTerm("", 5) as never,
|
||
data,
|
||
state,
|
||
true,
|
||
findTerminalPromptSourceChunkVisibleStarts(data, "$ "),
|
||
),
|
||
data,
|
||
);
|
||
});
|
||
|
||
test("does not add a second break after carriage return", () => {
|
||
const state = createPromptLineBreakState();
|
||
state.lastPromptText = "$ ";
|
||
state.pendingCommand = true;
|
||
const output = "foo\r";
|
||
const data = `${output}$ `;
|
||
|
||
assert.equal(
|
||
prepareTerminalDataForPromptLineBreak(
|
||
createFakeTerm("", 5) as never,
|
||
data,
|
||
state,
|
||
true,
|
||
findTerminalPromptSourceChunkVisibleStarts(data, "$ ", [output.length]),
|
||
),
|
||
data,
|
||
);
|
||
});
|
||
|
||
test("does not move prompts after row-positioning controls", () => {
|
||
for (const control of ["\x1b[r", "\x1b[A", "\x1b[B", "\x1b[d", "\x1b[e"]) {
|
||
const state = createPromptLineBreakState();
|
||
state.lastPromptText = "$ ";
|
||
state.pendingCommand = true;
|
||
const data = `${control}$ `;
|
||
|
||
assert.equal(
|
||
prepareTerminalDataForPromptLineBreak(
|
||
createFakeTerm("", 0) as never,
|
||
data,
|
||
state,
|
||
true,
|
||
findTerminalPromptSourceChunkVisibleStarts(data, "$ ", [control.length]),
|
||
),
|
||
data,
|
||
JSON.stringify(control),
|
||
);
|
||
}
|
||
});
|
||
|
||
test("keeps non-moving mode toggles on the prompt side of an inserted break", () => {
|
||
for (const control of ["\x1b[?2004h", "\x1b[?25h", "\x1b[?25l"]) {
|
||
const stateAtLineStart = createPromptLineBreakState();
|
||
stateAtLineStart.lastPromptText = "$ ";
|
||
stateAtLineStart.pendingCommand = true;
|
||
const data = `${control}$ `;
|
||
const promptStarts = findTerminalPromptSourceChunkVisibleStarts(
|
||
data,
|
||
stateAtLineStart.lastPromptText,
|
||
[control.length],
|
||
);
|
||
|
||
assert.equal(
|
||
prepareTerminalDataForPromptLineBreak(
|
||
createFakeTerm("", 0) as never,
|
||
data,
|
||
stateAtLineStart,
|
||
true,
|
||
promptStarts,
|
||
),
|
||
data,
|
||
JSON.stringify(control),
|
||
);
|
||
|
||
const stateMidLine = createPromptLineBreakState();
|
||
stateMidLine.lastPromptText = "$ ";
|
||
stateMidLine.pendingCommand = true;
|
||
assert.equal(
|
||
prepareTerminalDataForPromptLineBreak(
|
||
createFakeTerm("output", 6) as never,
|
||
data,
|
||
stateMidLine,
|
||
true,
|
||
promptStarts,
|
||
),
|
||
`\r\n${data}`,
|
||
JSON.stringify(control),
|
||
);
|
||
}
|
||
});
|
||
|
||
test("inserts a prompt line break after leaving the alternate screen", () => {
|
||
const state = createPromptLineBreakState();
|
||
state.lastPromptText = "$ ";
|
||
state.pendingCommand = true;
|
||
const leaveAlternateScreen = "\x1b[?1049l";
|
||
const data = `${leaveAlternateScreen}$ `;
|
||
const promptStarts = findTerminalPromptSourceChunkVisibleStarts(
|
||
data,
|
||
state.lastPromptText,
|
||
[leaveAlternateScreen.length],
|
||
);
|
||
|
||
assert.equal(
|
||
prepareTerminalDataForPromptLineBreak(
|
||
createFakeTerm("", 5) as never,
|
||
data,
|
||
state,
|
||
true,
|
||
promptStarts,
|
||
),
|
||
`${leaveAlternateScreen}\r\n$ `,
|
||
);
|
||
});
|
||
|
||
function createFakeTerm(lineText = "", cursorX = lineText.length) {
|
||
return {
|
||
buffer: {
|
||
active: {
|
||
cursorX,
|
||
cursorY: 0,
|
||
baseY: 0,
|
||
getLine(line: number) {
|
||
if (line !== 0) return undefined;
|
||
return {
|
||
isWrapped: false,
|
||
translateToString() {
|
||
return lineText;
|
||
},
|
||
};
|
||
},
|
||
},
|
||
},
|
||
};
|
||
}
|
||
|
||
test("command completion tracking prefers OSC 133 and consumes one submitted command", () => {
|
||
const state = createPromptLineBreakState();
|
||
const stateRef = { current: state };
|
||
markTerminalCommandCompletionPending(stateRef);
|
||
markTerminalCommandCompletionPending(stateRef);
|
||
|
||
assert.equal(consumeOsc133CommandCompletion("C", state), false);
|
||
assert.equal(consumeOsc133CommandCompletion("D;0", state), true);
|
||
assert.equal(state.pendingCommandCompletions, 1);
|
||
assert.equal(consumeOsc133CommandCompletion("D;1", state), true);
|
||
assert.equal(consumeOsc133CommandCompletion("D;0", state), false);
|
||
});
|
||
|
||
test("command completion prompt fallback drains bounded submitted commands only at an empty prompt", () => {
|
||
const state = createPromptLineBreakState();
|
||
const stateRef = { current: state };
|
||
markTerminalCommandCompletionPending(stateRef);
|
||
markTerminalCommandCompletionPending(stateRef);
|
||
|
||
assert.equal(
|
||
detectTerminalCommandCompletions(createFakeTerm("$ echo pending") as never, state),
|
||
0,
|
||
);
|
||
assert.equal(state.pendingCommandCompletions, 2);
|
||
assert.equal(
|
||
detectTerminalCommandCompletions(createFakeTerm("$ ") as never, state),
|
||
2,
|
||
);
|
||
assert.equal(state.pendingCommandCompletions, 0);
|
||
assert.equal(
|
||
detectTerminalCommandCompletions(createFakeTerm("$ ") as never, state),
|
||
0,
|
||
);
|
||
});
|
||
|
||
function createWrappedFakeTerm(rows: string[], cursorY: number, cursorX: number, cols: number) {
|
||
return {
|
||
cols,
|
||
buffer: {
|
||
active: {
|
||
cursorX,
|
||
cursorY,
|
||
baseY: 0,
|
||
getLine(line: number) {
|
||
const lineText = rows[line];
|
||
if (lineText === undefined) return undefined;
|
||
return {
|
||
isWrapped: line > 0,
|
||
translateToString() {
|
||
return lineText;
|
||
},
|
||
};
|
||
},
|
||
},
|
||
},
|
||
};
|
||
}
|
||
|
||
test("does not insert before prompt-like suffixes in a larger output chunk", () => {
|
||
assert.equal(
|
||
insertPromptLineBreakBeforePrompt("hello$ ", "$ ", 0),
|
||
"hello$ ",
|
||
);
|
||
});
|
||
|
||
test("inserts at the start of a prompt chunk when previous output left the cursor mid-line", () => {
|
||
assert.equal(
|
||
insertPromptLineBreakBeforePrompt("$ ", "$ ", 5),
|
||
"\r\n$ ",
|
||
);
|
||
});
|
||
|
||
test("does not insert when the output already ends with a line break", () => {
|
||
assert.equal(
|
||
insertPromptLineBreakBeforePrompt("hello\r\n$ ", "$ ", 0),
|
||
"hello\r\n$ ",
|
||
);
|
||
});
|
||
|
||
test("keeps prompt ANSI styling on the prompt side of the inserted line break", () => {
|
||
assert.equal(
|
||
insertPromptLineBreakBeforePrompt("\x1b[32m$ \x1b[0m", "$ ", 5),
|
||
"\r\n\x1b[32m$ \x1b[0m",
|
||
);
|
||
});
|
||
|
||
test("does not insert for non-prompt output", () => {
|
||
assert.equal(
|
||
insertPromptLineBreakBeforePrompt("hello> ", "$ ", 0),
|
||
"hello> ",
|
||
);
|
||
});
|
||
|
||
test("does not insert for output chunks that only end with the cached prompt text", () => {
|
||
assert.equal(
|
||
insertPromptLineBreakBeforePrompt("total $ ", "$ ", 0),
|
||
"total $ ",
|
||
);
|
||
});
|
||
|
||
test("does not insert before an ambiguous prompt suffix inside output", () => {
|
||
assert.equal(
|
||
insertPromptLineBreakBeforePrompt("world$ ", "$ ", 5),
|
||
"world$ ",
|
||
);
|
||
});
|
||
|
||
test("does not insert before prompt-like output after a line break", () => {
|
||
assert.equal(
|
||
insertPromptLineBreakBeforePrompt("\r\nhello$ ", "$ ", 0),
|
||
"\r\nhello$ ",
|
||
);
|
||
});
|
||
|
||
test("inserts before a distinct root prompt in the same output chunk", () => {
|
||
const prompt = "[root@iZwz9ftrhzy4b3hduolf6yZ ~]# ";
|
||
|
||
assert.equal(
|
||
insertPromptLineBreakBeforePrompt(`file tail${prompt}`, prompt, 0),
|
||
`file tail\r\n${prompt}`,
|
||
);
|
||
});
|
||
|
||
test("inserts before a distinct conda prompt in the same output chunk", () => {
|
||
const prompt = "(base) rynn@aiserver:~$ ";
|
||
|
||
assert.equal(
|
||
insertPromptLineBreakBeforePrompt(`file tail${prompt}`, prompt, 0),
|
||
`file tail\r\n${prompt}`,
|
||
);
|
||
});
|
||
|
||
test("inserts before a distinct no-space root prompt in the same output chunk", () => {
|
||
const prompt = " root@stwo:~#";
|
||
|
||
assert.equal(
|
||
insertPromptLineBreakBeforePrompt(`file tail${prompt}`, prompt, 0),
|
||
`file tail\r\n${prompt}`,
|
||
);
|
||
});
|
||
|
||
test("does not insert before an already separated distinct prompt", () => {
|
||
const prompt = "(base) rynn@aiserver:~$ ";
|
||
|
||
assert.equal(
|
||
insertPromptLineBreakBeforePrompt(`file tail\r\n${prompt}`, prompt, 0),
|
||
`file tail\r\n${prompt}`,
|
||
);
|
||
});
|
||
|
||
test("does not refresh cached prompt from output that only ends with the prompt text", () => {
|
||
const state = createPromptLineBreakState();
|
||
state.lastPromptText = "$ ";
|
||
state.pendingCommand = true;
|
||
|
||
assert.equal(
|
||
prepareTerminalDataForPromptLineBreak(
|
||
createFakeTerm("", 0) as never,
|
||
"total $ ",
|
||
state,
|
||
true,
|
||
),
|
||
"total $ ",
|
||
);
|
||
assert.equal(state.suppressNextPromptCache, true);
|
||
|
||
syncPromptLineBreakState(createFakeTerm("total $ ") as never, state);
|
||
|
||
assert.equal(state.lastPromptText, "$ ");
|
||
assert.equal(state.pendingCommand, true);
|
||
assert.equal(state.suppressNextPromptCache, false);
|
||
});
|
||
|
||
test("uses a preserved PTY chunk boundary to separate a short prompt", () => {
|
||
const state = createPromptLineBreakState();
|
||
state.lastPromptText = "$ ";
|
||
state.pendingCommand = true;
|
||
|
||
assert.equal(
|
||
prepareTerminalDataForPromptLineBreak(
|
||
createFakeTerm("", 0) as never,
|
||
"file tail$ ",
|
||
state,
|
||
true,
|
||
["file tail".length],
|
||
),
|
||
"file tail\r\n$ ",
|
||
);
|
||
assert.equal(state.suppressNextPromptCache, false);
|
||
});
|
||
|
||
test("keeps waiting for the real prompt after an output suffix matches the prompt text", () => {
|
||
const state = createPromptLineBreakState();
|
||
state.lastPromptText = "$ ";
|
||
state.pendingCommand = true;
|
||
|
||
assert.equal(
|
||
prepareTerminalDataForPromptLineBreak(
|
||
createFakeTerm("", 0) as never,
|
||
"total $ ",
|
||
state,
|
||
true,
|
||
),
|
||
"total $ ",
|
||
);
|
||
|
||
syncPromptLineBreakState(createFakeTerm("total $ ") as never, state);
|
||
|
||
assert.equal(
|
||
prepareTerminalDataForPromptLineBreak(
|
||
createFakeTerm("total $ ", 8) as never,
|
||
"$ ",
|
||
state,
|
||
true,
|
||
),
|
||
"\r\n$ ",
|
||
);
|
||
});
|
||
|
||
test("keeps waiting after prompt-like output on a fresh line", () => {
|
||
const state = createPromptLineBreakState();
|
||
state.lastPromptText = "$ ";
|
||
state.pendingCommand = true;
|
||
|
||
assert.equal(
|
||
prepareTerminalDataForPromptLineBreak(
|
||
createFakeTerm("", 0) as never,
|
||
"\r\nhello$ ",
|
||
state,
|
||
true,
|
||
),
|
||
"\r\nhello$ ",
|
||
);
|
||
|
||
syncPromptLineBreakState(createFakeTerm("hello$ ") as never, state);
|
||
|
||
assert.equal(state.lastPromptText, "$ ");
|
||
assert.equal(state.pendingCommand, true);
|
||
|
||
assert.equal(
|
||
prepareTerminalDataForPromptLineBreak(
|
||
createFakeTerm("hello$ ", 7) as never,
|
||
"$ ",
|
||
state,
|
||
true,
|
||
),
|
||
"\r\n$ ",
|
||
);
|
||
});
|
||
|
||
test("prepares a same-chunk cat output break for a distinct prompt", () => {
|
||
const state = createPromptLineBreakState();
|
||
state.lastPromptText = "(base) rynn@aiserver:~$ ";
|
||
state.pendingCommand = true;
|
||
|
||
assert.equal(
|
||
prepareTerminalDataForPromptLineBreak(
|
||
createFakeTerm("", 0) as never,
|
||
"without trailing newline(base) rynn@aiserver:~$ ",
|
||
state,
|
||
true,
|
||
),
|
||
"without trailing newline\r\n(base) rynn@aiserver:~$ ",
|
||
);
|
||
assert.equal(state.suppressNextPromptCache, false);
|
||
});
|
||
|
||
test("caches a no-space root prompt from typed command alignment", () => {
|
||
const prompt = " root@stwo:~#";
|
||
const command = "printf ok";
|
||
const state = createPromptLineBreakState();
|
||
|
||
markPromptLineBreakCommandPending(
|
||
{ current: state },
|
||
createFakeTerm(`${prompt}${command}`) as never,
|
||
command,
|
||
);
|
||
|
||
assert.equal(state.lastPromptText, prompt);
|
||
assert.equal(state.pendingCommand, true);
|
||
});
|
||
|
||
test("caches a no-space root prompt when command echo lags", () => {
|
||
const prompt = " root@stwo:~#";
|
||
const command = "printf ok";
|
||
const state = createPromptLineBreakState();
|
||
|
||
markPromptLineBreakCommandPending(
|
||
{ current: state },
|
||
createFakeTerm(`${prompt}${command.slice(0, -1)}`) as never,
|
||
command,
|
||
);
|
||
|
||
assert.equal(state.lastPromptText, prompt);
|
||
assert.equal(state.pendingCommand, true);
|
||
});
|
||
|
||
test("caches a no-space root prompt when command echo lags by a word", () => {
|
||
const prompt = " root@stwo:~#";
|
||
const command = "printf ok";
|
||
const state = createPromptLineBreakState();
|
||
|
||
markPromptLineBreakCommandPending(
|
||
{ current: state },
|
||
createFakeTerm(`${prompt}printf `) as never,
|
||
command,
|
||
);
|
||
|
||
assert.equal(state.lastPromptText, prompt);
|
||
assert.equal(state.pendingCommand, true);
|
||
});
|
||
|
||
test("caches a no-space root prompt when a longer command echo lags by a word", () => {
|
||
const prompt = "root@host:~#";
|
||
const command = "git status";
|
||
const state = createPromptLineBreakState();
|
||
|
||
markPromptLineBreakCommandPending(
|
||
{ current: state },
|
||
createFakeTerm(`${prompt}git `) as never,
|
||
command,
|
||
);
|
||
|
||
assert.equal(state.lastPromptText, prompt);
|
||
assert.equal(state.pendingCommand, true);
|
||
});
|
||
|
||
test("caches a no-space root prompt when command echo lags mid-word", () => {
|
||
const prompt = "root@host:~#";
|
||
const command = "git status";
|
||
const state = createPromptLineBreakState();
|
||
|
||
markPromptLineBreakCommandPending(
|
||
{ current: state },
|
||
createFakeTerm(`${prompt}git st`) as never,
|
||
command,
|
||
);
|
||
|
||
assert.equal(state.lastPromptText, prompt);
|
||
assert.equal(state.pendingCommand, true);
|
||
});
|
||
|
||
test("caches a standard prompt when command echo lags near completion", () => {
|
||
const state = createPromptLineBreakState();
|
||
|
||
markPromptLineBreakCommandPending(
|
||
{ current: state },
|
||
createFakeTerm("$ git statu") as never,
|
||
"git status",
|
||
);
|
||
|
||
assert.equal(state.lastPromptText, "$ ");
|
||
assert.equal(state.pendingCommand, true);
|
||
});
|
||
|
||
test("caches a standard prompt when command echo lags after a word boundary", () => {
|
||
const cases = ["$ git ", "$ git st"];
|
||
|
||
for (const lineText of cases) {
|
||
const state = createPromptLineBreakState();
|
||
|
||
markPromptLineBreakCommandPending(
|
||
{ current: state },
|
||
createFakeTerm(lineText) as never,
|
||
"git status",
|
||
);
|
||
|
||
assert.equal(state.lastPromptText, "$ ", lineText);
|
||
assert.equal(state.pendingCommand, true, lineText);
|
||
}
|
||
});
|
||
|
||
test("caches a standard prompt when short command echo lags by one character", () => {
|
||
const cases = [
|
||
{ lineText: "$ l", command: "ls" },
|
||
{ lineText: "$ c", command: "cd" },
|
||
{ lineText: "prod-web> l", command: "ls", promptText: "prod-web> " },
|
||
{ lineText: "prod> l", command: "ls", promptText: "prod> " },
|
||
{ lineText: "prod.web> l", command: "ls", promptText: "prod.web> " },
|
||
{ lineText: "user@host:~$ l", command: "ls", promptText: "user@host:~$ " },
|
||
{ lineText: "[user@host ~]$ l", command: "ls", promptText: "[user@host ~]$ " },
|
||
{ lineText: "➜ netcatty $ l", command: "ls", promptText: "➜ netcatty $ " },
|
||
{ lineText: "➜ git l", command: "ls", promptText: "➜ git " },
|
||
{ lineText: "➜ git np", command: "npm", promptText: "➜ git " },
|
||
];
|
||
|
||
for (const { lineText, command, promptText = "$ " } of cases) {
|
||
const state = createPromptLineBreakState();
|
||
|
||
markPromptLineBreakCommandPending(
|
||
{ current: state },
|
||
createFakeTerm(lineText) as never,
|
||
command,
|
||
);
|
||
|
||
assert.equal(state.lastPromptText, promptText, lineText);
|
||
assert.equal(state.pendingCommand, true, lineText);
|
||
}
|
||
});
|
||
|
||
test("caches a no-space root prompt when a short command echo lags by a word", () => {
|
||
const prompt = "root@host:~#";
|
||
const cases = [
|
||
{ echoedInput: "ls ", command: "ls -la" },
|
||
{ echoedInput: "cd ", command: "cd /tmp" },
|
||
];
|
||
|
||
for (const { echoedInput, command } of cases) {
|
||
const state = createPromptLineBreakState();
|
||
|
||
markPromptLineBreakCommandPending(
|
||
{ current: state },
|
||
createFakeTerm(`${prompt}${echoedInput}`) as never,
|
||
command,
|
||
);
|
||
|
||
assert.equal(state.lastPromptText, prompt, command);
|
||
assert.equal(state.pendingCommand, true, command);
|
||
}
|
||
});
|
||
|
||
test("caches a no-space root prompt when a short command echo lags by one character", () => {
|
||
const prompt = " root@stwo:~#";
|
||
const cases = [
|
||
{ echoedInput: "l", command: "ls" },
|
||
{ echoedInput: "c", command: "cd" },
|
||
];
|
||
|
||
for (const { echoedInput, command } of cases) {
|
||
const state = createPromptLineBreakState();
|
||
|
||
markPromptLineBreakCommandPending(
|
||
{ current: state },
|
||
createFakeTerm(`${prompt}${echoedInput}`) as never,
|
||
command,
|
||
);
|
||
|
||
assert.equal(state.lastPromptText, prompt, command);
|
||
assert.equal(state.pendingCommand, true, command);
|
||
}
|
||
});
|
||
|
||
test("does not cache a stale command as prompt text", () => {
|
||
const state = createPromptLineBreakState();
|
||
|
||
markPromptLineBreakCommandPending(
|
||
{ current: state },
|
||
createFakeTerm("$ ls") as never,
|
||
"sudo",
|
||
);
|
||
|
||
assert.equal(state.lastPromptText, "");
|
||
assert.equal(state.pendingCommand, true);
|
||
});
|
||
|
||
test("does not cache common interactive program prompts", () => {
|
||
const cases = [
|
||
{ lineText: "sftp> get file", command: "get file" },
|
||
{ lineText: "ftp> ls", command: "ls" },
|
||
{ lineText: "ghci> :t map", command: ":t map" },
|
||
{ lineText: "node> .help", command: ".help" },
|
||
{ lineText: "mongo> db.stats()", command: "db.stats()" },
|
||
{ lineText: "rs0:PRIMARY> db.stats()", command: "db.stats()" },
|
||
{ lineText: "test> const x = 1", command: "const x = 1" },
|
||
{ lineText: "test> await db.users.findOne()", command: "await db.users.findOne()" },
|
||
{ lineText: "rs0 [direct: primary] test> db.stats()", command: "db.stats()" },
|
||
{ lineText: "rs0 [direct: primary] reporting> db.stats()", command: "db.stats()" },
|
||
{ lineText: "rs0 primary reporting> exit", command: "exit" },
|
||
{ lineText: "irb(main):001> puts 1", command: "puts 1" },
|
||
{ lineText: "pry(main)> whereami", command: "whereami" },
|
||
{ lineText: "[1] pry(main)> whereami", command: "whereami" },
|
||
{ lineText: "SQL> select 1", command: "select 1" },
|
||
{ lineText: "cqlsh> select * from users", command: "select * from users" },
|
||
{ lineText: "hive> select 1", command: "select 1" },
|
||
{ lineText: "spark-sql> select 1", command: "select 1" },
|
||
{ lineText: "jshell> /help", command: "/help" },
|
||
{ lineText: " ...> System.out.println(1)", command: "System.out.println(1)" },
|
||
{ lineText: "ksql> select 1", command: "select 1" },
|
||
{ lineText: "trino> select 1", command: "select 1" },
|
||
{ lineText: "trino:tpch> select 1", command: "select 1" },
|
||
{ lineText: "presto> show catalogs", command: "show catalogs" },
|
||
{ lineText: "presto:default> show tables", command: "show tables" },
|
||
{ lineText: "duckdb> select 1", command: "select 1" },
|
||
{ lineText: "lftp user@example.com:~> ls", command: "ls" },
|
||
{ lineText: "cqlsh:cycling> select * from cyclist", command: "select * from cyclist" },
|
||
{ lineText: "hive (default)> select 1", command: "select 1" },
|
||
{ lineText: "0: jdbc:hive2://localhost:10000/default> select 1", command: "select 1" },
|
||
{ lineText: "spark-sql (default)> select 1", command: "select 1" },
|
||
{ lineText: "test> db.stats()", command: "db.stats()" },
|
||
{ lineText: "test> db", command: "db" },
|
||
{ lineText: "test> const x = 1", command: "const x = 1" },
|
||
{ lineText: "test> await db.users.findOne()", command: "await db.users.findOne()" },
|
||
{ lineText: "rs0 [direct: primary] reporting> const x = 1", command: "const x = 1" },
|
||
{ lineText: "rs0 [direct: primary] reporting> await db.users.findOne()", command: "await db.users.findOne()" },
|
||
{ lineText: "Atlas a [primary] reporting> db.stats()", command: "db.stats()" },
|
||
{ lineText: "Atlas a [primary] reporting> await db.users.findOne()", command: "await db.users.findOne()" },
|
||
{ lineText: "rs0 primary test> db.stats()", command: "db.stats()" },
|
||
{ lineText: "test> rs.status()", command: "rs.status()" },
|
||
{ lineText: "test> print(1)", command: "print(1)" },
|
||
{ lineText: "test> 1 + 1", command: "1 + 1" },
|
||
{ lineText: "admin@localhost:27017> db.stats()", command: "db.stats()" },
|
||
];
|
||
|
||
for (const { lineText, command } of cases) {
|
||
const state = createPromptLineBreakState();
|
||
|
||
markPromptLineBreakCommandPending(
|
||
{ current: state },
|
||
createFakeTerm(lineText) as never,
|
||
command,
|
||
);
|
||
|
||
assert.equal(state.lastPromptText, "", lineText);
|
||
assert.equal(state.pendingCommand, true, lineText);
|
||
}
|
||
});
|
||
|
||
test("does not cache wrapped common interactive program prompts", () => {
|
||
const cases = [
|
||
{ rows: ["sftp> get very-long-", "remote-file"], command: "get very-long-remote-file" },
|
||
{ rows: ["node> console.", "log('ok')"], command: "console.log('ok')" },
|
||
{ rows: ["mongo> db.", "stats()"], command: "db.stats()" },
|
||
{ rows: ["cqlsh> select *", " from users"], command: "select * from users" },
|
||
{ rows: ["jshell> System.out.", "println(1)"], command: "System.out.println(1)" },
|
||
{ rows: [" ...> System.out.", "println(1)"], command: "System.out.println(1)" },
|
||
{ rows: ["trino> select", " 1"], command: "select 1" },
|
||
{ rows: ["trino:tpch> select", " 1"], command: "select 1" },
|
||
{ rows: ["duckdb> select", " 1"], command: "select 1" },
|
||
{ rows: ["cqlsh:cycling> select *", " from cyclist"], command: "select * from cyclist" },
|
||
{ rows: ["hive (default)> select", " 1"], command: "select 1" },
|
||
{ rows: ["0: jdbc:hive2://localhost:10000/default> select", " 1"], command: "select 1" },
|
||
{ rows: ["test> db.", "stats()"], command: "db.stats()" },
|
||
{ rows: ["test> d", "b"], command: "db" },
|
||
{ rows: ["rs0:PRIMARY> db.", "stats()"], command: "db.stats()" },
|
||
{ rows: ["rs0 [direct: primary] test> db.", "stats()"], command: "db.stats()" },
|
||
{ rows: ["rs0 [direct: primary]", " test> db.stats()"], command: "db.stats()" },
|
||
{ rows: ["rs0 [direct: primary]", " reporting> db.stats()"], command: "db.stats()" },
|
||
{ rows: ["rs0 [direct: primary]", " reporting> const x = 1"], command: "const x = 1" },
|
||
{ rows: ["Atlas a [primary]", " reporting> db.stats()"], command: "db.stats()" },
|
||
{ rows: ["rs0 primary test> db.", "stats()"], command: "db.stats()" },
|
||
{ rows: ["test> print", "(1)"], command: "print(1)" },
|
||
{ rows: ["test> 1 ", "+ 1"], command: "1 + 1" },
|
||
{ rows: ["admin@localhost:27017> db.", "stats()"], command: "db.stats()" },
|
||
];
|
||
|
||
for (const { rows, command } of cases) {
|
||
const state = createPromptLineBreakState();
|
||
|
||
markPromptLineBreakCommandPending(
|
||
{ current: state },
|
||
createWrappedFakeTerm(rows, 1, rows[1].length, 20) as never,
|
||
command,
|
||
);
|
||
|
||
assert.equal(state.lastPromptText, "", rows[0]);
|
||
assert.equal(state.pendingCommand, true, rows[0]);
|
||
}
|
||
});
|
||
|
||
test("caches wrapped non-Mongo-looking default-name greater-than prompts", () => {
|
||
const cases = [
|
||
{ rows: ["test> hel", "p"], command: "help", promptText: "test> " },
|
||
{ rows: ["test> show ", "dbs"], command: "show dbs", promptText: "test> " },
|
||
{ rows: ["admin> ex", "it"], command: "exit", promptText: "admin> " },
|
||
{ rows: ["local> dep", "loy"], command: "deploy", promptText: "local> " },
|
||
];
|
||
|
||
for (const { rows, command, promptText } of cases) {
|
||
const state = createPromptLineBreakState();
|
||
|
||
markPromptLineBreakCommandPending(
|
||
{ current: state },
|
||
createWrappedFakeTerm(rows, 1, rows[1].length, 20) as never,
|
||
command,
|
||
);
|
||
|
||
assert.equal(state.lastPromptText, promptText, rows[0]);
|
||
assert.equal(state.pendingCommand, true, rows[0]);
|
||
}
|
||
});
|
||
|
||
test("does not cache a live command suffix as prompt text", () => {
|
||
const state = createPromptLineBreakState();
|
||
|
||
markPromptLineBreakCommandPending(
|
||
{ current: state },
|
||
createFakeTerm("$ echo sudo") as never,
|
||
"sudo",
|
||
);
|
||
|
||
assert.equal(state.lastPromptText, "");
|
||
assert.equal(state.pendingCommand, true);
|
||
});
|
||
|
||
test("does not cache host prompt command symbols as prompt text", () => {
|
||
const prompt = "user@host:~$ ";
|
||
const cases = [
|
||
`${prompt}echo # sudo`,
|
||
`${prompt}printf % sudo`,
|
||
`${prompt}echo $ sudo`,
|
||
];
|
||
|
||
for (const lineText of cases) {
|
||
const state = createPromptLineBreakState();
|
||
|
||
markPromptLineBreakCommandPending(
|
||
{ current: state },
|
||
createFakeTerm(lineText) as never,
|
||
"sudo",
|
||
);
|
||
|
||
assert.equal(state.lastPromptText, "", lineText);
|
||
assert.equal(state.pendingCommand, true, lineText);
|
||
}
|
||
});
|
||
|
||
test("does not cache a themed prompt live command suffix as prompt text", () => {
|
||
for (const lineText of [
|
||
"➜ ~ echo sudo",
|
||
"➜ echo sudo",
|
||
"➜ make sudo",
|
||
"➜ docker sudo",
|
||
"➜ ./script sudo",
|
||
"➜ ./script sudo",
|
||
"➜ ~ echo # sudo",
|
||
]) {
|
||
const state = createPromptLineBreakState();
|
||
|
||
markPromptLineBreakCommandPending(
|
||
{ current: state },
|
||
createFakeTerm(lineText) as never,
|
||
"sudo",
|
||
);
|
||
|
||
assert.equal(state.lastPromptText, "", lineText);
|
||
assert.equal(state.pendingCommand, true, lineText);
|
||
}
|
||
});
|
||
|
||
test("caches themed prompt decorations from typed command alignment", () => {
|
||
const cases = [
|
||
{ lineText: "➜ ~/repo do", command: "do", promptText: "➜ ~/repo " },
|
||
{
|
||
lineText: "➜ netcatty git:(main) ✗ ls",
|
||
command: "ls",
|
||
promptText: "➜ netcatty git:(main) ✗ ",
|
||
},
|
||
{
|
||
lineText: "➜ netcatty git:(main) ✗ + ls",
|
||
command: "ls",
|
||
promptText: "➜ netcatty git:(main) ✗ + ",
|
||
},
|
||
{ lineText: "➜ netcatty ✗ $ ls", command: "ls", promptText: "➜ netcatty ✗ $ " },
|
||
{ lineText: "➜ netcatty $ ls", command: "ls", promptText: "➜ netcatty $ " },
|
||
];
|
||
|
||
for (const { lineText, command, promptText } of cases) {
|
||
const state = createPromptLineBreakState();
|
||
|
||
markPromptLineBreakCommandPending(
|
||
{ current: state },
|
||
createFakeTerm(lineText) as never,
|
||
command,
|
||
);
|
||
|
||
assert.equal(state.lastPromptText, promptText, lineText);
|
||
assert.equal(state.pendingCommand, true, lineText);
|
||
}
|
||
});
|
||
|
||
test("caches themed prompt decorations when command echo lags", () => {
|
||
const cases = [
|
||
{ lineText: "➜ ~ git ", command: "git status", promptText: "➜ ~ " },
|
||
{ lineText: "➜ ~ git st", command: "git status", promptText: "➜ ~ " },
|
||
{
|
||
lineText: "➜ netcatty git:(main) ✗ git ",
|
||
command: "git status",
|
||
promptText: "➜ netcatty git:(main) ✗ ",
|
||
},
|
||
{
|
||
lineText: "➜ netcatty git:(main) ✗ git st",
|
||
command: "git status",
|
||
promptText: "➜ netcatty git:(main) ✗ ",
|
||
},
|
||
];
|
||
|
||
for (const { lineText, command, promptText } of cases) {
|
||
const state = createPromptLineBreakState();
|
||
|
||
markPromptLineBreakCommandPending(
|
||
{ current: state },
|
||
createFakeTerm(lineText) as never,
|
||
command,
|
||
);
|
||
|
||
assert.equal(state.lastPromptText, promptText, lineText);
|
||
assert.equal(state.pendingCommand, true, lineText);
|
||
}
|
||
});
|
||
|
||
test("caches themed bare directory prompts for direct sends before command echo", () => {
|
||
const cases = [
|
||
{ lineText: "➜ netcatty ", command: "ls", promptText: "➜ netcatty " },
|
||
{ lineText: "➜ git ", command: "npm", promptText: "➜ git " },
|
||
{ lineText: "➜ git ", command: "git status", promptText: "➜ git " },
|
||
{ lineText: "➜ make ", command: "sudo", promptText: "➜ make " },
|
||
{ lineText: "➜ make ", command: "make build", promptText: "➜ make " },
|
||
{ lineText: "➜ node ", command: "yarn", promptText: "➜ node " },
|
||
];
|
||
|
||
for (const { lineText, command, promptText } of cases) {
|
||
const state = createPromptLineBreakState();
|
||
|
||
markPromptLineBreakCommandPending(
|
||
{ current: state },
|
||
createFakeTerm(lineText) as never,
|
||
command,
|
||
);
|
||
|
||
assert.equal(state.lastPromptText, promptText, lineText);
|
||
assert.equal(state.pendingCommand, true, lineText);
|
||
}
|
||
});
|
||
|
||
test("does not cache interactive prompts for direct sends before command echo", () => {
|
||
const cases = [
|
||
{ lineText: "test> ", command: "const x = 1" },
|
||
{ lineText: "test> ", command: "await db.users.findOne()" },
|
||
{ lineText: "test> ", command: "db" },
|
||
{ lineText: "rs0 [direct: primary] reporting> ", command: "const x = 1" },
|
||
{ lineText: "rs0 [direct: primary] reporting> ", command: "await db.users.findOne()" },
|
||
{ lineText: "rs0 [direct: primary] reporting> ", command: "db.stats()" },
|
||
{ lineText: "Atlas a [primary] reporting> ", command: "db.stats()" },
|
||
];
|
||
|
||
for (const { lineText, command } of cases) {
|
||
const state = createPromptLineBreakState();
|
||
|
||
markPromptLineBreakCommandPending(
|
||
{ current: state },
|
||
createFakeTerm(lineText) as never,
|
||
command,
|
||
);
|
||
|
||
assert.equal(state.lastPromptText, "", lineText);
|
||
assert.equal(state.pendingCommand, true, lineText);
|
||
}
|
||
});
|
||
|
||
test("clears an old cached prompt when a direct send is interactive", () => {
|
||
const state = createPromptLineBreakState();
|
||
state.lastPromptText = "rs0 [direct: primary] reporting> ";
|
||
|
||
markPromptLineBreakCommandPending(
|
||
{ current: state },
|
||
createFakeTerm("rs0 [direct: primary] reporting> ") as never,
|
||
"db.stats()",
|
||
);
|
||
|
||
assert.equal(state.lastPromptText, "");
|
||
assert.equal(state.pendingCommand, true);
|
||
});
|
||
|
||
test("caches host-style greater-than prompts for direct sends before command echo", () => {
|
||
const cases = [
|
||
{ lineText: "server> ", command: "exit" },
|
||
{ lineText: "staging> ", command: "show dbs" },
|
||
{ lineText: "server> ", command: "db.stats()" },
|
||
{ lineText: "webdb> ", command: "deploy" },
|
||
{ lineText: "prod.db> ", command: "deploy" },
|
||
{ lineText: "test> ", command: "deploy" },
|
||
{ lineText: "test> ", command: "exit" },
|
||
{ lineText: "test> ", command: "help" },
|
||
{ lineText: "test> ", command: "show dbs" },
|
||
{ lineText: "admin> ", command: "deploy" },
|
||
];
|
||
|
||
for (const { lineText, command } of cases) {
|
||
const state = createPromptLineBreakState();
|
||
|
||
markPromptLineBreakCommandPending(
|
||
{ current: state },
|
||
createFakeTerm(lineText) as never,
|
||
command,
|
||
);
|
||
|
||
assert.equal(state.lastPromptText, lineText, lineText);
|
||
assert.equal(state.pendingCommand, true, lineText);
|
||
}
|
||
});
|
||
|
||
test("does not cache a live path suffix as prompt text", () => {
|
||
for (const lineText of ["$ cd ~/sudo", "$ cat > sudo", "$ echo path#sudo"]) {
|
||
const state = createPromptLineBreakState();
|
||
|
||
markPromptLineBreakCommandPending(
|
||
{ current: state },
|
||
createFakeTerm(lineText) as never,
|
||
"sudo",
|
||
);
|
||
|
||
assert.equal(state.lastPromptText, "", lineText);
|
||
assert.equal(state.pendingCommand, true, lineText);
|
||
}
|
||
});
|
||
|
||
test("does not cache a stale command from a standard prompt echo prefix", () => {
|
||
for (const lineText of ["$ s", "$ su", "$ sud"]) {
|
||
const state = createPromptLineBreakState();
|
||
|
||
markPromptLineBreakCommandPending(
|
||
{ current: state },
|
||
createFakeTerm(lineText) as never,
|
||
"sudo",
|
||
);
|
||
|
||
assert.equal(state.lastPromptText, "", lineText);
|
||
assert.equal(state.pendingCommand, true, lineText);
|
||
}
|
||
});
|
||
|
||
test("does not cache partial stale commands after a no-space prompt", () => {
|
||
const prompt = " root@stwo:~#";
|
||
for (const lineText of [`${prompt}s`, `${prompt}sud`]) {
|
||
const state = createPromptLineBreakState();
|
||
|
||
markPromptLineBreakCommandPending(
|
||
{ current: state },
|
||
createFakeTerm(lineText) as never,
|
||
"sudo",
|
||
);
|
||
|
||
assert.equal(state.lastPromptText, "", lineText);
|
||
assert.equal(state.pendingCommand, true, lineText);
|
||
}
|
||
});
|
||
|
||
test("does not cache stale command suffixes after a no-space prompt", () => {
|
||
const prompt = " root@stwo:~#";
|
||
const cases = [
|
||
`${prompt}cat > sudo`,
|
||
`${prompt}echo # sudo`,
|
||
`${prompt}echo $ sudo`,
|
||
`${prompt}printf % sudo`,
|
||
`${prompt}echo path#sudo`,
|
||
`${prompt}> sudo`,
|
||
`${prompt}# sudo`,
|
||
`${prompt}% sudo`,
|
||
`${prompt}$ sudo`,
|
||
];
|
||
cases.push("root#echo $ sudo", "root@host:~#make $ sudo");
|
||
|
||
for (const lineText of cases) {
|
||
const state = createPromptLineBreakState();
|
||
|
||
markPromptLineBreakCommandPending(
|
||
{ current: state },
|
||
createFakeTerm(lineText) as never,
|
||
"sudo",
|
||
);
|
||
|
||
assert.equal(state.lastPromptText, "", lineText);
|
||
assert.equal(state.pendingCommand, true, lineText);
|
||
}
|
||
});
|
||
|
||
test("syncs prompts that contain prompt-like symbols", () => {
|
||
const prompts = [
|
||
"user@host ~/foo# bar $ ",
|
||
"user@host ~/foo# git $ ",
|
||
"user@host ~/foo#git $ ",
|
||
"root@host ~/foo# bar # ",
|
||
"root@host ~/foo#bar # ",
|
||
"fish@host ~/foo# bar % ",
|
||
"fish@host ~/foo%bar % ",
|
||
"user@host:~/foo# bar $ ",
|
||
"user@host ~/repo # $ ",
|
||
"➜ ~ $ ",
|
||
"user@host ~/foo% bar $ ",
|
||
"user@host ~/foo> bar $ ",
|
||
"user@host ~/foo# bar> ",
|
||
"user@host ~/foo# bar› ",
|
||
"user@host ~/foo#bar> ",
|
||
];
|
||
|
||
for (const prompt of prompts) {
|
||
const state = createPromptLineBreakState();
|
||
|
||
syncPromptLineBreakState(createFakeTerm(prompt) as never, state);
|
||
|
||
assert.equal(state.lastPromptText, prompt, prompt);
|
||
assert.equal(state.pendingCommand, false, prompt);
|
||
}
|
||
});
|
||
|
||
test("syncs a no-space root prompt without xterm row padding", () => {
|
||
const prompt = " root@stwo:~#";
|
||
const state = createPromptLineBreakState();
|
||
|
||
syncPromptLineBreakState(createFakeTerm(`${prompt} `, prompt.length) as never, state);
|
||
|
||
assert.equal(state.lastPromptText, prompt);
|
||
assert.equal(state.pendingCommand, false);
|
||
});
|
||
|
||
test("refreshes cached prompt when a changed prompt arrives after a line break in the same chunk", () => {
|
||
const state = createPromptLineBreakState();
|
||
state.lastPromptText = "old$ ";
|
||
state.pendingCommand = true;
|
||
const termBeforeWrite = createFakeTerm("old$ cd /tmp", 12);
|
||
|
||
assert.equal(
|
||
prepareTerminalDataForPromptLineBreak(
|
||
termBeforeWrite as never,
|
||
"\r\nnew$ ",
|
||
state,
|
||
true,
|
||
),
|
||
"\r\nnew$ ",
|
||
);
|
||
assert.equal(state.suppressNextPromptCache, false);
|
||
|
||
syncPromptLineBreakState(createFakeTerm("new$ ") as never, state);
|
||
|
||
assert.equal(state.lastPromptText, "new$ ");
|
||
assert.equal(state.pendingCommand, false);
|
||
});
|
||
|
||
test("caches the first valid prompt even when a command is already pending", () => {
|
||
const state = createPromptLineBreakState();
|
||
state.pendingCommand = true;
|
||
|
||
syncPromptLineBreakState(createFakeTerm("$ ") as never, state);
|
||
|
||
assert.equal(state.lastPromptText, "$ ");
|
||
assert.equal(state.pendingCommand, false);
|
||
assert.equal(state.suppressNextPromptCache, false);
|
||
});
|
||
|
||
test("does not refresh cached prompt from an unchanged mid-line write without a line reset", () => {
|
||
const state = createPromptLineBreakState();
|
||
state.lastPromptText = "old$ ";
|
||
state.pendingCommand = true;
|
||
const termBeforeWrite = createFakeTerm("old$ run", 8);
|
||
|
||
assert.equal(
|
||
prepareTerminalDataForPromptLineBreak(
|
||
termBeforeWrite as never,
|
||
"outputnew$ ",
|
||
state,
|
||
true,
|
||
),
|
||
"outputnew$ ",
|
||
);
|
||
assert.equal(state.suppressNextPromptCache, true);
|
||
|
||
syncPromptLineBreakState(createFakeTerm("outputnew$ ") as never, state);
|
||
|
||
assert.equal(state.lastPromptText, "old$ ");
|
||
assert.equal(state.pendingCommand, true);
|
||
assert.equal(state.suppressNextPromptCache, false);
|
||
});
|
||
|
||
test("does not insert a blank line after a full-width prefix that already wrapped", () => {
|
||
const state = createPromptLineBreakState();
|
||
state.lastPromptText = "$ ";
|
||
state.pendingCommand = true;
|
||
const cols = 10;
|
||
const fullWidth = "x".repeat(cols);
|
||
const term = createWrappedFakeTerm([fullWidth], 0, 0, cols);
|
||
|
||
assert.equal(
|
||
prepareTerminalDataForPromptLineBreak(
|
||
term as never,
|
||
`${fullWidth}$ `,
|
||
state,
|
||
true,
|
||
[fullWidth.length],
|
||
),
|
||
`${fullWidth}$ `,
|
||
);
|
||
});
|
||
|
||
test("finds prompt starts on the display string after identity transforms", () => {
|
||
const prompt = "$ ";
|
||
const data = `file tail${prompt}`;
|
||
const starts = findTerminalPromptSourceChunkVisibleStarts(
|
||
data,
|
||
prompt,
|
||
["file tail".length],
|
||
);
|
||
assert.deepEqual(starts, ["file tail".length]);
|
||
});
|