@hyzyn/dsh-tty 0.32.0 → 0.32.2

package/README.en.md

@@ -129,7 +129,9 @@ Both were reproduced on **Windows 11 ARM (24H2) + Node 22 ARM64**. The fix:
   banner) but deliberately **not `-NoProfile`** — the user’s profile is where aliases and functions come from.
   TERM / COLORTERM are meaningless for ConPTY and are no longer injected;
 - **“Run one command” tabs** (docker exec, command tabs opened by the agent) use `cmd /c` or
-  `PowerShell -Command`;
+  `PowerShell -Command`; **PowerShell’s `-Command` collapses a non-zero last command into process exit code
+  1** (`cmd /c exit 5` → 1, both versions), so to get a concrete code let the command `exit 5` itself (POSIX
+  `sh -c` does not behave this way);
 - **Input line-ending normalisation (D74, reported on real hardware 2026-09-27)**: conhost treats Enter as
   **CR**, so a bare LF only moves the cursor down and **does not submit the command line** — `tty_send`
   writing `echo X\n` as the tool description says leaves the command sitting on the input line (no output,
@@ -140,11 +142,16 @@ Both were reproduced on **Windows 11 ARM (24H2) + Node 22 ARM64**. The fix:
   (`powershell.exe` / `pwsh.exe`) through a stable `-File` stub that hooks `prompt` and
   `PSConsoleHostReadLine` — this yields cwd tracking (`tty_list.cwd` following `cd`), exit codes, the
   `running` state and command-granular `tty_expect`. **cmd is not** (it has no command-boundary hooks), so
-  the settings card greys the switch out and points at “switch the shell path to PowerShell”. **Known
-  limit**: on PowerShell 7 the command output reaches ConPTY *after* the D marker (pane redraws are
-  asynchronous and batched — the same root cause as in the tmux case), so `tty_capture{last}` may come back
-  empty; use `tty_capture` to read the tail there. Windows PowerShell 5.1 is unaffected (both were measured
-  on a real machine). The stub only loads through `-ExecutionPolicy Bypass` (process-scoped); two boundaries
+  the settings card greys the switch out and points at “switch the shell path to PowerShell”. **The two
+  versions differ, and the syntax hint is branched by version**: `&&` / `||` are **PowerShell 7** only —
+  on 5.1 `&&` is a parse error and not a single command runs. **Known limit (not reproduced)**: it was
+  recorded that on PowerShell 7 the command output reaches ConPTY *after* the D marker, so
+  `tty_capture{last}` may come back empty; on 2026-10-13 this was re-measured on pwsh **7.6.6** (Win11
+  ARM64) across three output shapes (20 small outputs / a 2000-line burst / 20 writes over 2s) with
+  **0/20 empty windows** — not reproduced. If you do hit one, read the tail with `tty_capture` and report
+  the pwsh version. One more **exit-code rule**: in the PowerShell family a **parse error** (`&&` on 5.1,
+  `echo (1` on both) runs nothing at all yet the D marker reports **0** — never judge success by the exit
+  code alone; the error text is in the output. The stub only loads through `-ExecutionPolicy Bypass` (process-scoped); two boundaries
   are recorded as they are: when **Group Policy** locks the execution policy to Restricted / AllSigned that
   parameter does **not** override GPO, so the stub fails to load and the tab opens with integration silently
   absent (the same degradation as “the user turned PSReadLine off”); the parameter also writes the value into
@@ -1220,8 +1227,8 @@ verify things like “is there still a white panel after switching light/dark th
   (last 256KB) cannot be recovered.
 - **Shell integration covers zsh / bash on POSIX and the PowerShell family on Windows**: other shells
   (Windows cmd) are skipped automatically (`tty_capture{last}` reports a clear error rather than a wrong
-  one); on PowerShell 7 the command output can land after the D marker, so `tty_capture{last}` may be empty
-  there (read the tail with `tty_capture` instead). bash < 4.4 uses the DEBUG trap fallback: internal commands
+  one); a PowerShell 7 `tty_capture{last}` empty window was recorded but **not reproduced on pwsh 7.6.6**
+  on 2026-10-13 (0/20 across three output shapes) — if you see one, read the tail with `tty_capture`. bash < 4.4 uses the DEBUG trap fallback: internal commands
   of compound commands such as loops emit extra B markers, and `tty_capture{last}` captures only the output
   after the last internal command for those commands (exit codes and `tty_expect` are unaffected). If the
   user’s rc overrides `PROMPT_COMMAND`/the hook array, the integration may stop working — turn off

package/README.md

@@ -119,7 +119,8 @@ dsh plugin --profile web add link:$(pwd)/packages/tty   # 仓库开发调试
   **不补 `-NoProfile`** —— 用户的 profile 正是别名与函数的来源。TERM / COLORTERM 对 ConPTY
   没有意义，也不再注入；
 - **「跑一条命令」的标签**（docker exec、agent 起的命令标签）走 `cmd /c` 或
-  `PowerShell -Command`；
+  `PowerShell -Command`；**PowerShell 的 `-Command` 会把「末条命令非零」塌成进程退出码 1**
+  （`cmd /c exit 5` → 1，两版一致），要拿到具体码值就让命令自己 `exit 5`（POSIX 侧 `sh -c` 不会这样）；
 - **输入行尾归一化（D74，2026-09-27 真机报告）**：conhost 的 Enter 是 **CR**，裸 LF 只把光标
   下移一格、**不提交命令行**——`tty_send` 按工具描述发 `echo X\n` 时命令停在输入行上（没有输出、
   没有新提示符，看起来像「发出去了但没执行」）。**win32 的本地会话**上插件现在把裸 LF 补成 CRLF
@@ -127,9 +128,14 @@ dsh plugin --profile web add link:$(pwd)/packages/tty   # 仓库开发调试
 - **shell 集成（OSC 133/7）按家族分**：**PowerShell 家族支持**（`powershell.exe` / `pwsh.exe`）——
   注入走 `-File` 稳定桩（挂 `prompt` + `PSConsoleHostReadLine` 钩子），拿到 `tty_list.cwd` 跟随
   `cd`、退出码、`running` 三态与命令粒度的 `tty_expect`；**cmd 不支持**（没有命令开始/结束钩子），
-  设置卡片把开关置灰并指向「把 Shell 路径换成 PowerShell」。**已知限制**：PowerShell 7 上命令输出
-  在 ConPTY 里晚于 D 标记抵达（渲染重画是异步批量的，与 tmux 场景同根因），`tty_capture{last}`
-  可能取到空 —— 那里用 `tty_capture` 读尾部；Windows PowerShell 5.1 不受影响（两版都真机实测过）。
+  设置卡片把开关置灰并指向「把 Shell 路径换成 PowerShell」。**两版语法不同，提示文案按版本分支给**：
+  `&&` / `||` 只有 **PowerShell 7** 认，5.1 上写 `&&` 是解析错误（一条命令都不会跑）。
+  **已知限制（未复现）**：曾有记录说 PowerShell 7 上命令输出在 ConPTY 里晚于 D 标记抵达、
+  `tty_capture{last}` 可能取到空；2026-10-13 在 pwsh **7.6.6**（Win11 ARM64）上按三档输出量复测
+  （20 次小输出 / 2000 行大输出 / 2s 内分 20 次的慢输出）**0/20 空窗**，未复现 —— 真遇到就用
+  `tty_capture` 读尾部，并把当时的 pwsh 版本报回来。另有一条**退出码口径**：PowerShell 家族里
+  **解析错误**（5.1 上的 `&&`、两版上的 `echo (1`）命令一条都没跑，而 D 标记报 **0** —— 不能只看
+  退出码判成功，报错文本在输出里。
   桩靠 `-ExecutionPolicy Bypass`（进程级）才载得进来，两条边界如实记着：**组策略**把执行策略锁成
   Restricted / AllSigned 时该参数压不过 GPO，桩载不进去、标签照开而集成静默失效（与「用户关了
   PSReadLine」同一种降级）；这个参数还会把值写进 `$Env:PSExecutionPolicyPreference`，从该会话里

package/lib/index.d.ts

@@ -540,6 +540,14 @@ interface ShellIntegrationState {
     sawMark: boolean;
     /** B..D 之间：命令输出捕获中。 */
     inCommand: boolean;
+    /**
+     * 当前这条命令**开始的时刻**（见到那个 `B` 的 Date.now()；0 = 还没见过 B）。
+     *
+     * 用途只有一个（D101）：区分「命令行回显」与「往在跑的程序里敲的字」。命令行的回显是**在 B
+     * 之前**提交的那次 `tty_send`（`session.lastInputAt < commandStartedAt`），而 TUI 里的按键
+     * 一定晚于 B —— 后者在屏上出现是真实输出，不许当回显剔掉（D75 的边界）。
+     */
+    commandStartedAt: number;
     cmdBuffer: string;
     /** T 标记带来的 pane 快照（tmux 持久标签；D 时优先于 cmdBuffer）。 */
     pendingT: string | null;

package/lib/index.js

@@ -768,7 +768,7 @@ const FLUSH_INTERVAL_MS = 12;
 /** 待发输出超过该字符数时跳过窗口立即冲刷（防超长输出无限延迟）。 */
 const FLUSH_SIZE_CHARS = 64 * 1024;
 function createShellState() {
-    return { carry: '', sawMark: false, inCommand: false, cmdBuffer: '', pendingT: null, lastCommand: null, cmdSeq: 0 };
+    return { carry: '', sawMark: false, inCommand: false, commandStartedAt: 0, cmdBuffer: '', pendingT: null, lastCommand: null, cmdSeq: 0 };
 }
 /** OSC 133;T 的 base64 payload → utf8 文本（无效输入返回 null）。 */
 function decodeBase64Utf8(payload) {
@@ -842,6 +842,7 @@ export function feedShellIntegration(session, text) {
         const kind = match[1];
         if (kind === 'B') {
             state.inCommand = true;
+            state.commandStartedAt = Date.now();
             state.cmdBuffer = '';
             state.pendingT = null;
         }
@@ -1174,6 +1175,66 @@ function lastCommandStart(text) {
     OSC133_RE.lastIndex = 0; // 归位：这个正则是共用的（feedShellIntegration 也用它）
     return end;
 }
+/**
+ * 从原始流里取出**命令输出**的部分（D101）：丢掉每个 `A`（prompt 开始）到其后第一个 `B`
+ * （命令开始）之间的文本，以及末尾那段还没等到 `B` 的 `A` 段。
+ *
+ * 为什么需要它：`A..B` 之间只有提示符与**命令行回显**——真实输出一定在 `B` 之后。这是
+ * shell 集成的硬边界（不是文本启发式）。回溯路径一直在用它（`lastCommandStart` 从最后一个
+ * `B` 起切），而 live 路径此前拿**整段原始流**去匹配，于是「字面出现在命令行里」的 pattern
+ * 会命中自己的回显、秒回 matched —— 命令其实还在跑（D75 的文本剔除在窗口里出现过任意 `B`
+ * 标记时也不启用，见 `echoStrippable`）。
+ *
+ * 真机实测（2026-10-13，Windows 11 ARM64 + pwsh 7.6.6 / Win PowerShell 5.1.26100）：命令
+ * `Start-Sleep -Seconds 2; echo PROBE_ECHO_QQQ` + 等 `PROBE_ECHO_QQQ`，两版分别在 **432ms /
+ * 446ms** 就返回 matched；macOS/zsh 上同类用例 **1ms**。修法即本函数：命中前先按边界裁掉
+ * 提示符/回显段。
+ *
+ * 没有标记的会话（cmd、集成被关、TUI 全屏重画）原样返回——降级语义不变。
+ *
+ * 用在两处：`unreadRegion`（回溯窗口，从最后一个 `B` 起切之后再做一次）与
+ * `liveOutputRegion` 的「窗口里没有 `B`」那一支。
+ */
+function commandOutputRegion(text) {
+    let result = '';
+    let cursor = 0;
+    let inPrompt = false;
+    OSC133_RE.lastIndex = 0;
+    for (const match of text.matchAll(OSC133_RE)) {
+        const index = match.index ?? 0;
+        if (!inPrompt)
+            result += text.slice(cursor, index);
+        if (match[1] === 'A')
+            inPrompt = true;
+        else if (match[1] === 'B')
+            inPrompt = false;
+        cursor = index + match[0].length;
+    }
+    if (!inPrompt)
+        result += text.slice(cursor);
+    OSC133_RE.lastIndex = 0; // 归位：这个正则是共用的（feedShellIntegration 也用它）
+    return result;
+}
+/**
+ * `tty_expect` 的 live 窗口：从「本次等待期间到达的原始流」里取出**命令输出**（D101）。
+ *
+ * 三种现场分别处理，判据都是 shell 集成的边界，不做文本启发式：
+ *   1. 窗口里有 `B`（命令在本次等待期间开始了）→ 只取最后一个 `B` 之后。**命令行回显在 `B` 之前**
+ *      （真机上回显与 `B` 常在同一 chunk 里、回显在前），所以这一步就把回显丢掉了；
+ *   2. 窗口里没有 `B` 但 `inCommand`（`B` 早于注册）→ 整段都是那个命令的输出（TUI 全屏重画、
+ *      长任务刷屏），原样返回；
+ *   3. 都没有 → 没有集成（cmd / 集成被关）或正停在提示符上：此时可能只有提示符与回显，也可能
+ *      是没人发命令时自己冒出来的后台输出 —— 只能交给 `commandOutputRegion` 裁掉「未闭合的
+ *      `A` 段」（提示符 + 正在回显的命令行），其余照旧返回（后台输出不能被误杀）。
+ */
+function liveOutputRegion(text, state) {
+    const fromB = lastCommandStart(text);
+    if (fromB !== -1)
+        return text.slice(fromB);
+    if (state.inCommand)
+        return text;
+    return commandOutputRegion(text);
+}
 /** 首次被 agent 工具触达时把水位线落在当下——否则第一次回扫会把用户此前的历史输出当成「还没读过」。 */
 function ensureReadMark(session) {
     if (session.readSeq >= 0)
@@ -1200,7 +1261,9 @@ function unreadRegion(session) {
     const bufferStart = session.outputSeq - session.buffer.length;
     const text = session.buffer.slice(Math.max(0, session.readSeq - bufferStart));
     const start = lastCommandStart(text);
-    return start === -1 ? text : text.slice(start);
+    // D101：从最后一个 B 起切只解决了「回显在 B 之前」那一半；这段里还可能有一段**还没等到 B**
+    // 的 A 段（提示符 + 正在回显的命令行），同样要在匹配前裁掉。
+    return commandOutputRegion(start === -1 ? text : text.slice(start));
 }
 /**
  * pattern 匹配的统一入口（D72）：先对含 ANSI 的原始流试（live 路径原语义），
@@ -1227,6 +1290,13 @@ function testPattern(re, text) {
  *   - 真实输出里也出现的标记照旧命中（不误杀）；
  *   - 只在回显行**末尾**匹配才削（cmd 的回显与提示符同行，所以按行尾切）；
  *   - 有 B 标记 / 命令正在跑（TUI 全屏重画里出现输入文本是正常输出）时不启用。
+ *
+ * **D101 补**：上面第三条让这条剔除在真实会话里几乎从不启用——窗口里出现**前一条命令**的
+ * `B` 标记就是常态，「命令正在跑」更是常态。真机实测（2026-10-13）：`Start-Sleep -Seconds 2;
+ * echo MARK` + 等 `MARK`，Windows PowerShell 5.1 / 7 分别 446ms / 432ms 就 matched，macOS/zsh
+ * 上 1ms。所以回显的**主防线**改成零启发式的 `commandOutputRegion`（按 `A..B` 边界裁，
+ * `tty_expect` 的 live 路径与 `unreadRegion` 都走它）；本函数退成没有标记那种壳（cmd /
+ * 集成被关——那里没有边界可用，只能按提交过的输入做文本剔除）的兜底。
  * ------------------------------------------------------------------ */
 /** 回显候选的行数上限（最近几条提交的输入）与单行长度上限。 */
 const ECHO_INPUT_CAP = 8;
@@ -1257,13 +1327,21 @@ function noteSubmittedInput(session, data) {
 function echoStrippable(session, text) {
     if (session.recentInputs.length === 0)
         return false;
+    /*
+     * 命令正在跑时（D101 修正）：启用与否**不能**只看 inCommand —— 真机现场是「命令已经被接受
+     * （B 早于注册）、回显稍后才回到缓冲区」，那时精确命中命令行文本的就是回显（Windows
+     * PowerShell 上 432ms 就 matched，而命令还在 Start-Sleep）。
+     *
+     * 判据换成「最近一次提交**早于本条命令的开始**」：那是命令行本身（回显就该剔掉）；提交晚于
+     * 命令开始的，是往在跑的程序里敲的键 —— 它在屏上出现属于**真实输出**，不许剔（D75 的边界）。
+     */
     if (session.shellState.inCommand)
-        return false;
+        return session.lastInputAt < session.shellState.commandStartedAt;
     return lastCommandStart(text) === -1;
 }
 /**
  * 把回显候选行从文本里削掉（保行结构）。按**行尾**匹配：cmd 的回显与提示符同行
- * （`C:\>echo X`），所以只削后缀、保留提示符前缀。行尾空白（含 `\r`）先归一。
+ * （`C:\>echo X`），所以只削后缀、保留提示符前缀。行尾空白与控制字节先归一。
  */
 function stripEchoLines(text, echoes) {
     if (echoes.length === 0)
@@ -1272,7 +1350,12 @@ function stripEchoLines(text, echoes) {
     return text
         .split('\n')
         .map((line) => {
-        const trimmed = line.replace(/[ \t\r]+$/, '');
+        /*
+         * 行尾的空白与**控制字节**都算噪音（D101 真机实测）：zsh 在命令行后面紧跟着写
+         * bracketed-paste 开关 `\e[?2004l`，不把它剥掉，「按行尾削」就永远削不掉那一行——
+         * 于是回显被当成真输出（macOS/zsh 上实测 1ms 命中）。
+         */
+        const trimmed = line.replace(/[\s\x00-\x1f\x7f]+$/, '');
         for (const echo of sorted) {
             if (trimmed.endsWith(echo))
                 return trimmed.slice(0, trimmed.length - echo.length);
@@ -1283,14 +1366,16 @@ function stripEchoLines(text, echoes) {
 }
 /**
  * 命中是否**只**落在回显上（纯回显 → 不算命中）。
- * 原始流与清洗后文本各削一次：回显行里可能夹着 ANSI（zsh 的 zle / 彩色提示符）。
+ *
+ * D101 起只看**清洗后**的文本：原来原始流与清洗文本各削一次、要求「两边都不再命中」才算回显，
+ * 于是原始流里跟在命令行后面的转义序列（`\e[?2004l`、zle 的光标移动……）让 raw 变体削不干净、
+ * 照样命中 → 整条判据失效。清洗后的文本才是「agent 真正看得到的那一份」（`tty_capture` 与
+ * `tty_expect` 返回的也是它），按它判定既够用又不自相矛盾。
  */
 function echoOnlyMatch(re, text, session) {
     if (!echoStrippable(session, text))
         return false;
-    const stripped = stripEchoLines(text, session.recentInputs);
-    const strippedClean = stripEchoLines(cleanAnsiTail(text), session.recentInputs);
-    return !testPattern(re, stripped) && !testPattern(re, strippedClean);
+    return !testPattern(re, stripEchoLines(cleanAnsiTail(text), session.recentInputs));
 }
 /** 宽松清洗一份 tunnels 输入；输入不是数组时返回 undefined（表示「未提供，保持原值」）。 */
 function sanitizeTunnels(input) {
@@ -5614,7 +5699,10 @@ const plugin = definePlugin({
                                 // 的收窄，闭包里就得再判一次 undefined。
                                 const onData = (chunk) => {
                                     acc = (acc + decoder.write(chunk)).slice(-64 * 1024);
-                                    const hay = acc.length > 16 * 1024 ? acc.slice(-16 * 1024) : acc;
+                                    // D101：先按 shell 集成的命令边界裁掉提示符/回显段（见 liveOutputRegion），
+                                    // 再取 16KB 尾部窗口。反过来（先切 16KB 再裁）会切掉段首那个 B，回显又漏回窗口里。
+                                    const region = liveOutputRegion(acc, state);
+                                    const hay = region.length > 16 * 1024 ? region.slice(-16 * 1024) : region;
                                     if (testPattern(re, hay)) {
                                         // D75：命中的若**只是刚送进去那行命令的回显**，不算命中——继续等真输出
                                         if (echoOnlyMatch(re, hay, session))