3 Commits

Include renames

Author	SHA1	Message	Date
Rounak DattaandClaude Opus 5	abf1d1f1ca	fix(terminal): the PTY and the browser terminal must never disagree about size ... Issue #464, "text gets muffled sometimes, in both TUI default and fullscreen". The screenshot is not a dropped frame or a frozen renderer — it is arithmetic. Claude Code's TUI wraps its frame at the width the PTY reported and erases the previous frame by walking the cursor up the rows it believes that frame took. A browser terminal of a different width makes each logical line occupy more physical rows than Ink counted, so `eraseLines(n)` clears too few and the new frame paints over rows nothing erased: doubled lines, and short tool summaries sitting inside longer prose rows with the prose's tail still visible. Reproduced against this repo's own xterm before changing anything — a 120-column PTY against a 62-column terminal renders every wrapped line twice. `test/ terminal-pty-geometry.test.ts` pins that, and pins the clean render at matching widths beside it, so the assertion cannot be satisfied by code that fixes nothing. Four ways the two drifted apart, none of them observable from either end: 1. `fitAddon.fit()` resizes xterm to `proposeDimensions()` RAW while every server-facing path reported those floored at 40x10. Measured in Chrome at 430px: font size 44 proposed 13 columns, the server was told 40, and xterm stayed at 13. Three call sites each did their own fit-then-floor, and two re-read the proposal after the fit — `_shrinkPaddingToFit()` runs exactly there, so the container had moved. 2. `throttledResize` (keyboard up) and `sendResize` (session detached into its own window) reflowed locally and withheld only the SIGWINCH. That is the one combination that cannot be right: a reflow nothing is rendering for buys nothing and costs correctness. Both now withhold everything, and the keyboard's settle timer still sends the one resize that stops the PTY going stale. 3. `setFontSize`/`setFontFamily`/`setFontWeight` move the cell size — a geometry change — and told the server nothing at all, so raising the font on a phone left the CLI wrapping at the old column count. 4. `Session.resize` DECLINES a small-viewport request while a desktop connection holds an active sizing claim, and said nothing, because resize was write-only. `syncTerminalGeometry()` is now the one function that may change the terminal's size: it fits, floors and applies as a single step, so the numbers xterm holds are the numbers the server is told. A test sweeps every module for a bare `fit()` on the main terminal, and finds exactly one — the owner's own. For (4) the client cannot win, so it is told the truth instead: both transports answer a resize with `session.ptyCols`/`ptyRows` (`{"t":"zc"}` on the socket, the body of the resize POST) and `_onPtyGeometryReport` adopts them. A terminal that keeps a shape the PTY refused does not render "too narrow", it renders garbled. Adopting can leave the pane wider than the screen and the container is `overflow: hidden`, so `.pty-oversized` grants horizontal reach for exactly as long as the mismatch lasts: correct-and-reachable beats correct-and-clipped beats garbled. That rule sets both overflow axes and its own `touch-action` because mobile.css loads later and sets `.terminal-container { overflow: visible; touch-action: none }` — a bare `overflow-x` would leave overflow-y computing to `auto` and hand the browser a vertical scroll container the terminal's touch handler knows nothing about. Verified in Chrome at 430px against a live server, with a desktop client holding the claim: the phone adopts 198x43, gets `overflow-x: auto` / `overflow-y: hidden` / `touch-action: pan-x`, 758px of reach to the right, and keeps its own vertical scrolling. The pre-fix build was measured in the same harness for the control. Two things this deliberately does not do. It does not change who owns the pane size — the desktop still wins, and `_startMobileResizeRetry` still takes it back once that goes idle. And `throttledResize` still holds the PTY's shape for the whole keyboard animation rather than sending a SIGWINCH per step; that decision predates this and was not re-tested here. Also in this commit, Ark0N's third-pass review items on #431: - The response viewer's byte-buffer fallback and `_onSessionClearTerminal` both used the no-param `/terminal` form, capped only by `terminalBufferMaxBytes` (32MB) — the largest body the frontend asks for anywhere. One carried no deadline at all and the other got the 15s tail budget. Both now take the full-history budget. - A `?full=1` capture that outruns its deadline falls back to the bounded tail. The pane is blanked before that fetch, so an abort used to leave a black rectangle, discard the queued live output and never reach `_connectWs`. A failed load now still opens the socket, says one dim line where the content would have been, and clears the tab's spinner — which nothing did, so a failed select left `aria-busy="true"` set forever. - `_wsOutputGapSession` is cleared at the repaint that settles it, not in a `finally` that also ran on the catch. A reconcile that threw, or hit the new deadline — the flaky link the marker exists for — dropped the gap with nothing to retry it. `ws.onopen` no longer clears it up front either. - The replay-clear invariant is pinned in the gate, which is the drift this PR exists to fix: `_resetTerminalForReplay` must be a queued write and nothing else, and no module may blank the terminal with a `clear()+reset()` pair. - `DIAG_ENTRY_MAX_CHARS` replaces the hardcoded 300, bound through a local first: `CodemanDiag?.x` still throws a ReferenceError when the identifier was never declared, and that is the one function in the app that must not throw. - panels-ui's two kill-all clears route through the same helper, and the xterm-version guard's comment says "resolved lockfile version" rather than "dependency RANGE", which is what it has pinned since the last round. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>	2026-09-22 13:07:33 +05:30
Rounak DattaandClaude Opus 5	abd39318e6	fix(terminal): deadline must cover the body, precache must ignore the cache-bust query ... Review fixes. Two of these are defects in the previous commit. 1. The fetch deadline only covered time-to-headers. `await fetch()` settles on response headers, so clearing the abort timer in a finally around it left the body — the multi-megabyte `?full=1` capture the deadline exists for — completely unbounded; it only ever bounded a server that accepts a connection and never replies. Measured against a server that sends headers immediately and stalls the body 4s under a 1s deadline: fetch resolved at 30ms, timer cleared there, body completed at 4026ms unaborted. Now the body is read inside `_fetchTerminalCapture`, which returns {json, headers, headersAt} — headers because two callers read server-timing, headersAt because those same callers measure header-vs-body time and can no longer observe that moment. `_terminalCaptureInflight` is scoped the same way, so a body still streaming counts toward a capture starting beside it. Same test now aborts at 1005ms. 2. The precache could never be hit, and the previous commit made that expensive rather than free. `renderIndexHtml` runs `cacheBustAssets`, which appends `?v=<mtime>` to every same-origin .js/.css reference INCLUDING content-hashed names — confirmed against a running instance: `vendor/xterm-zerolag-input.6fee72f2.js?v=1789402869101`. `caches.match` is query-sensitive, so entries keyed on the bare hashed path were unreachable; deriving the list from the manifest turned cheap 404s into ~1.3MB downloaded at every install that nothing could read back, once per deploy now that CACHE_NAME rotates. The fallback match takes `{ ignoreSearch: true }`, which also lets runtime-cached entries survive an mtime change. 3. `_wsOutputGapSession` was only cleared in ws.onopen, so paths that already repaint the buffer left it set and the socket replayed everything a second time. `selectSession` loads the buffer and only THEN calls `_connectWs`, so neither the _isLoadingBuffer nor the _terminalRefreshOwner guard applied. `_markTerminalBufferReconciled()` is now called from _onSessionNeedsRefresh's finally, from selectSession after its load, and from _cleanupSessionData. The scope claim was also wrong and is corrected in the comment: when the network drops, SSE drops with it and handleInit's keepTerminal branch already reconciles. The genuinely uncovered case is the WS dying while SSE stays up, where _onSSETerminal discards SSE terminal frames until _wsReady flips in onclose — up to the ping+pong window of output nothing writes. 4. CLAUDE.md said "all of them measured rather than reasoned", which the PR's own "not verified" section contradicted. Split explicitly: the replay race is measured, the watchdog mechanism is verified against xterm 6.0.0 under jsdom (field path resolves, a forced stale handle makes refreshRows a no-op, the kick schedules a fresh frame), and the iOS rAF-discard premise is reasoned and still wants a device. Adds the two missing entries — the WebSocket reconcile and the sw.js/build.mjs "keep these in sync or the build throws" contract. Also: test/xterm-private-api.test.ts pins the RESOLVED lockfile version instead of the declared `^6.0.0` range, which was the wrong assertion in both directions — a real upgrade to 6.4.0 can rename a private field while resolving inside the range, and an innocuous range edit failed while changing nothing installed. And test/sw-precache-manifest.test.ts now parses HASHABLE out of scripts/build.mjs rather than hand-copying it, which was the same drift this PR exists to fix; the parse is guarded against silently matching nothing. The deadline fix has a behavioural test against a real socket plus a source guard asserting `await res.json()` precedes the finally — verified to fail when the helper is reverted to the old shape, so it is not vacuous. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>	2026-09-22 12:25:36 +05:30
Rounak DattaandClaude Opus 5	c0422c4e21	feat(terminal): renderer watchdog, atomic replay clear, fetch deadlines, reconnect recovery ... Four ways the terminal can silently stop being correct — in each case the buffer keeps updating, nothing throws, and the only recourse is a reload. 1. Renderer freeze after backgrounding. iOS DISCARDS scheduled rAF callbacks when a PWA backgrounds, and xterm's RenderDebouncer only clears its `_animationFrame` handle from inside that callback — so one drop leaves it permanently set and every later refresh() early-returns. Parsing is decoupled from rendering, so bytes keep filling the buffer correctly while nothing paints. Codeman has exactly ONE xterm for the whole page load, so a single backgrounding wedges it until a reload. Adds a 2s liveness poll and `_kickRenderer()`, which does what the dropped `_innerRefresh` would have. 2. Replay clears raced live output. xterm's write() is async-queued while reset() is synchronous and, per upstream, "does not clear input buffers and does not reset the parser" — so bytes queued before a reset are parsed after it and fuse into the snapshot. Verified against the real xterm 6 here: write('p8'); reset(); write('rmissions') renders "p8rmissions". The main path was already safe via a queued erase; the needsRefresh and clearTerminal paths were not. All three now share one queued `\x1bc` (RIS), which unlike 3J/H/2J also resets modes, charsets, scroll regions and SGR state. 3. Output lost on WebSocket reconnect. Input frames carry seq+cid and are delivered exactly once; output frames carry nothing. ws.onopen re-sends dims and flushes queued input, and needsRefresh only fires on external-CLI startup and SSE backpressure drain — never on reconnect. Output produced while offline was simply absent afterwards. Interim fix: reaching onclose means the drop was unintentional, so the session is marked and the next open reconciles from the server buffer. Sequencing output is the follow-up. 4. Terminal captures had no deadline. No AbortController anywhere in the frontend, including `?full=1`, which the code itself calls "unbounded-ish work: at the default history limit it can be megabytes". Adds a budget that scales with full-vs-tail and with captures in flight, degrading to a plain fetch where AbortController is missing. Also: the service-worker precache was dead — the build content-hashes assets but sw.js listed pre-hash names, so 15 of 23 entries 404'd (verified against a running instance) and cache.add().catch() hid it. Offline still worked via runtime caching, but CACHE_NAME was a constant so activate's cleanup never deleted anything and every past release's assets accumulated. Both are now derived from the build manifest. Crash-trail entries are flattened and capped, since they are joined with \n into one value and one call site interpolates a server-controlled WS close reason. The watchdog reads xterm privates — there is no public API. Every access is optional-chained so a shape change degrades to a no-op. `_renderService` only exists after open(), which needs a real DOM, so the gate cannot assert the field path; test/xterm-private-api.test.ts pins the dependency range instead. Tests: 23 new (terminal-resilience, sw-precache-manifest, xterm-private-api), all pure/static so they run in the gate, which excludes the mobile suite. One static source guard in history-truncation-notice updated for the renamed call; the behaviour it pins is unchanged. Not verified: no browser available, so no runtime reproduction of the freeze and no real-device test of the reconnect path. Both warrant a device pass. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>	2026-09-22 12:24:52 +05:30