fix(mcp): match two-line idle prompts against live PTY CR bytes

hasExpectedPromptSuffix deleted carriage returns, so a cached
user@host prompt with the CR-to-LF blank lines never matched live
\r\r\n bytes. Compare that CR-as-LF form when the cached prompt spans
lines. Same-line redraws still match by dropping CR.

Co-authored-by: 陈大猫 <binaricat@users.noreply.github.com>

electron/bridges/ai/ptyExecHelpers.cjs

@@ -68,7 +68,8 @@ const PROMPT_SUFFIX_WINDOW_PER_PROMPT_CHAR = 8;
 
 function hasExpectedPromptSuffix(text, expectedPrompt) {
   if (!expectedPrompt) return false;
-  const normalizedPrompt = stripAnsi(String(expectedPrompt || "")).replace(/\r/g, "");
+  const ansiFreePrompt = stripAnsi(String(expectedPrompt || ""));
+  const normalizedPrompt = ansiFreePrompt.replace(/\r/g, "");
   if (!normalizedPrompt) return false;
   const fullText = String(text || "");
   const windowChars = Math.max(
@@ -76,7 +77,17 @@ function hasExpectedPromptSuffix(text, expectedPrompt) {
     String(expectedPrompt).length * PROMPT_SUFFIX_WINDOW_PER_PROMPT_CHAR,
   );
   const tail = fullText.length > windowChars ? fullText.slice(-windowChars) : fullText;
-  return stripAnsi(tail).replace(/\r/g, "").endsWith(normalizedPrompt);
+  const strippedTail = stripAnsi(tail);
+  // Drop CR so a redraw inside one line (`root@host:~\r# `) still matches
+  // the cached prompt. That collapses a two-line PS1's `\r\r\n` to a single
+  // LF, which no longer ends with the cache (`user@host: /root\n\n\n$ `).
+  if (strippedTail.replace(/\r/g, "").endsWith(normalizedPrompt)) return true;
+  // The idle-prompt cache turns those CRs into LFs and keeps the blank
+  // lines. Compare that form too, only when the cache itself spans lines,
+  // so a bare `$`/`#` is unchanged.
+  if (!ansiFreePrompt.includes("\n")) return false;
+  const crAsLfPrompt = ansiFreePrompt.replace(/\r/g, "\n");
+  return strippedTail.replace(/\r/g, "\n").endsWith(crAsLfPrompt);
 }
 
 function escapePosixSingleQuoted(text) {

electron/bridges/ai/ptyExecPromptSuffix.test.cjs

@@ -3,7 +3,7 @@
 const test = require("node:test");
 const assert = require("node:assert/strict");
 const { hasExpectedPromptSuffix } = require("./ptyExecHelpers.cjs");
-const { stripAnsi } = require("./shellUtils.cjs");
+const { extractTrailingIdlePrompt, stripAnsi } = require("./shellUtils.cjs");
 
 // The behaviour before the tail window was introduced: normalise the whole
 // text, then compare its end.
@@ -41,6 +41,38 @@ test("prompt suffix is found after a very large flood of CRLF output", () => {
   assert.equal(hasExpectedPromptSuffix(`${flood}${COLORED_PROMPT}`, "root@3160T:~# "), true);
 });
 
+test("live PTY CR bytes match a cached two-line idle prompt", () => {
+  // Bash writes the PS1 newline as CR and ONLCR adds another, so the bytes
+  // are `\r\r\n`. The idle-prompt cache keeps those as blank lines. Suffix
+  // matching has to accept that form; stripping CR down to one LF does not.
+  const live = "user@host: /workspace\r\r\n$ ";
+  const cached = extractTrailingIdlePrompt(`welcome\r\n${live}`);
+  assert.equal(cached, "user@host: /workspace\n\n\n$ ");
+  const matchLive = hasExpectedPromptSuffix(live, cached);
+  assert.equal(matchLive, true);
+  assert.equal(hasExpectedPromptSuffix(`hostname\r\nbox\r\n${live}`, cached), true);
+  assert.equal(
+    hasExpectedPromptSuffix("\x1b[?2004huser@host: /workspace\r\r\n$ ", cached),
+    true,
+  );
+
+  const rootLive = "user@host: /root\r\r\n# ";
+  const rootCached = extractTrailingIdlePrompt(rootLive);
+  assert.equal(rootCached, "user@host: /root\n\n\n# ");
+  assert.equal(hasExpectedPromptSuffix(rootLive, rootCached), true);
+
+  // Readiness for a real LF two-line prompt still matches, and a bare
+  // `$`/`#` is neither this prompt nor a POSIX prompt on its own.
+  const lfCached = extractTrailingIdlePrompt("welcome\r\nuser@host: /workspace\n$ ");
+  assert.equal(lfCached, "user@host: /workspace\n$ ");
+  assert.equal(hasExpectedPromptSuffix("user@host: /workspace\n$ ", lfCached), true);
+  assert.equal(hasExpectedPromptSuffix("output\r\n$ ", cached), false);
+  assert.equal(hasExpectedPromptSuffix("$ ", cached), false);
+  assert.equal(hasExpectedPromptSuffix("# ", rootCached), false);
+  assert.equal(extractTrailingIdlePrompt("$ "), "");
+  assert.equal(extractTrailingIdlePrompt("# "), "");
+});
+
 test("prompt suffix check does not scan the whole buffer on every call", () => {
   // 2M characters of CRLF output used to cost seconds per call because every
   // call stripped ANSI and carriage returns over the entire text.

electron/bridges/ai/shellUtils.cjs

@@ -69,6 +69,11 @@ const CMD_PROMPT_PATTERN = /^[A-Za-z]:(?:\\[^<>"|]*)?>$/;
 //     the final `]` before `$`/`#` is the delimiter.
 const POSIX_PROMPT_PATTERN = /^(?:[^\s@]+@[^\s:]+(?::[^\n\r]*)?|\[[^\s@\]]+@[^\s\]:]+(?:\s+[^\n\r]+)?\])[#$]$/;
 
+// Host line of a two-line bash PS1 (`\u@\h: \w` then a following `$` or `#`).
+// Same user@host[:path] class as POSIX_PROMPT_PATTERN's first alternative,
+// without a prompt marker on this line. A bare `$`/`#` alone is not a prompt.
+const POSIX_PROMPT_HOST_LINE_PATTERN = /^[^\s@]+@[^\s:]+(?::[^\n\r]*)?$/;
+
 // Alpine's default ash PS1 omits the username: `\h:\w\$ ` -> `localhost:~# `.
 // Require a hostname and a home/absolute path, excluding prompt delimiters
 // within the path so partially entered commands do not count as idle prompts.
@@ -102,7 +107,8 @@ function extractTrailingIdlePrompt(output) {
   const normalized = stripAnsi(output).replace(/\r/g, "\n");
   if (!normalized || normalized.endsWith("\n")) return "";
 
-  const lastLine = normalized.split("\n").pop() || "";
+  const lines = normalized.split("\n");
+  const lastLine = lines.pop() || "";
   const rightTrimmed = lastLine.replace(/\s+$/, "");
   if (!rightTrimmed) return "";
 
@@ -118,6 +124,24 @@ function extractTrailingIdlePrompt(output) {
     return lastLine;
   }
 
+  // Two-line PS1 (`export PS1="\u@\h: \w\n$ "`). Bash emits the newline as
+  // CR and the PTY's ONLCR adds another, so the bytes are `\r\r\n`. The
+  // CR-to-LF normalize above turns that into blank lines between the host
+  // line and `$`/`#`. Keep those blanks in the cache: getFreshIdlePrompt
+  // uses the same normalize, and hasExpectedPromptSuffix compares this
+  // CR-as-LF form against live PTY bytes. A lone `$` must not satisfy endsWith.
+  if (rightTrimmed === "$" || rightTrimmed === "#") {
+    let hostIndex = lines.length - 1;
+    while (hostIndex >= 0 && lines[hostIndex].replace(/\s+$/, "") === "") {
+      hostIndex -= 1;
+    }
+    const previousLine = hostIndex >= 0 ? lines[hostIndex] : "";
+    const previousRightTrimmed = previousLine.replace(/\s+$/, "");
+    if (POSIX_PROMPT_HOST_LINE_PATTERN.test(previousRightTrimmed)) {
+      return `${lines.slice(hostIndex).join("\n")}\n${lastLine}`;
+    }
+  }
+
   return "";
 }
 
@@ -178,7 +202,8 @@ function trackSessionIdlePrompt(session, chunk) {
 // Return `session.lastIdlePrompt` only if the PTY's recent rolling tail
 // still ends with it. The cached prompt is updated only when
 // extractTrailingIdlePrompt recognizes a known shape (PowerShell, cmd.exe,
-// `user@host[:path][#$]`, RHEL `[user@host path][#$]`, or Alpine `host:path[#$]`);
+// `user@host[:path][#$]`, two-line `user@host[:path]` + `$`/`#`,
+// RHEL `[user@host path][#$]`, or Alpine `host:path[#$]`);
 // a remote shell switch into another shell, an oh-my-posh / starship / custom
 // PS1, or any unrecognized prompt would
 // otherwise leave a stale value behind, which `resolveEffectiveShellKind`

electron/bridges/ai/shellUtils.test.cjs

@@ -219,6 +219,53 @@ test("extracts a trailing RHEL-family bracketed idle prompt", () => {
   assert.equal(extractTrailingIdlePrompt("welcome\r\nroot@host ~#"), "");
 });
 
+test("extractTrailingIdlePrompt recognizes a two-line user@host then bare $/# PS1", () => {
+  // export PS1="\u@\h: \w\n$ " paints the host line, then a lone "$ ".
+  // The cached prompt must keep both lines so a lone "$" cannot satisfy endsWith.
+  assert.equal(
+    extractTrailingIdlePrompt("welcome\r\nuser@host: /home/foo\n$ "),
+    "user@host: /home/foo\n$ ",
+  );
+  assert.equal(
+    extractTrailingIdlePrompt("welcome\r\nroot@host: /root\n# "),
+    "root@host: /root\n# ",
+  );
+  // Live bash PTY: prompt CR plus ONLCR is `\r\r\n`, which this normalizer
+  // stores as blank lines. The cache must keep them so endsWith still matches.
+  assert.equal(
+    extractTrailingIdlePrompt("\x1b[?2004huser@host: /home/foo\r\r\n$ "),
+    "user@host: /home/foo\n\n\n$ ",
+  );
+  assert.equal(
+    extractTrailingIdlePrompt("\x1b[?2004hroot@host: /root\r\r\n# "),
+    "root@host: /root\n\n\n# ",
+  );
+  assert.equal(extractTrailingIdlePrompt("$ "), "");
+  assert.equal(extractTrailingIdlePrompt("# "), "");
+  assert.equal(extractTrailingIdlePrompt("welcome\r\n$ "), "");
+  assert.equal(extractTrailingIdlePrompt("not a host line\n$ "), "");
+  assert.equal(extractTrailingIdlePrompt("copied output\n# "), "");
+  assert.equal(isDefaultPosixPromptLine("$"), false);
+  assert.equal(isDefaultPosixPromptLine("#"), false);
+  assert.equal(isDefaultPosixPromptLine("$ "), false);
+  assert.equal(isDefaultPosixPromptLine("# "), false);
+});
+
+test("trackSessionIdlePrompt and getFreshIdlePrompt accept a two-line user@host PS1", () => {
+  const session = {};
+  const prompt = "user@host: /home/foo\n$ ";
+  trackSessionIdlePrompt(session, `welcome\r\n${prompt}`);
+  assert.equal(getFreshIdlePrompt(session), prompt);
+
+  const ptySession = {};
+  trackSessionIdlePrompt(ptySession, "\x1b[?2004huser@host: /home/foo\r\r\n$ ");
+  assert.equal(getFreshIdlePrompt(ptySession), "user@host: /home/foo\n\n\n$ ");
+});
+
+test("extractTrailingIdlePrompt still recognizes a classic single-line POSIX prompt", () => {
+  assert.equal(extractTrailingIdlePrompt("welcome\r\nuser@host:~$ "), "user@host:~$ ");
+});
+
 test("isDefaultPosixPromptLine accepts virtualenv, conda, and BT-panel env prefixes", () => {
   // Python venv / conda / BT-panel prepend "(name) " before the real prompt.
   // Recognition strips that prefix; a missing space after ")" is already