diff --git a/docs/plans/2026-04-02-fix-opencode-startup-probes.md b/docs/plans/2026-04-02-fix-opencode-startup-probes.md new file mode 100644 index 00000000..67aaf6ae --- /dev/null +++ b/docs/plans/2026-04-02-fix-opencode-startup-probes.md @@ -0,0 +1,503 @@ +# Fix OpenCode Startup Probes Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use trycycle-executing to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Restore OpenCode startup inside Freshell by handling the exact terminal startup probes that current OpenCode emits during bootstrap, without regressing existing terminal protocol behavior. + +**Architecture:** Keep the existing CSI request-mode bypass exactly as-is; it solves a separate compatibility contract and should not be reworked unless new failing tests prove it is wrong. Add a small incremental non-CSI startup-probe parser on the client side, but drive it from the exact failing websocket `terminal.output` frame sequence instead of a reconstructed combined payload: the real contract starts with a probe-only frame and continues with later post-reply frames, plus a synthetic split-frame variant only for buffering coverage. Strip recognized probes from both live and replayed output, emit synthetic replies only for live frames outside replay, apply the startup-probe preprocessor regardless of terminal mode, and reset parser state whenever an attach generation starts or replay completes, including replay completion announced by `terminal.output.gap`, so replay fragments cannot leak into later live traffic. Reuse one shared frame fixture across the pure-parser, `TerminalView`, and attach/replay regression tests so the fix stays narrow and protocol-accurate, while keeping the picker handoff as a separate boundary regression. + +**Tech Stack:** React 18, TypeScript, xterm.js, Vitest, Testing Library, Freshell websocket terminal protocol + +--- + +## Strategy Gate + +Why this is the right problem: +- The PTY launches and stays alive, so this is not a pane-picker, cwd, or spawn failure. +- The repro differs by OpenCode version under the same Freshell build, which points to a compatibility change in OpenCode startup negotiation. +- The observed stall happens before UI rendering and after startup probe output begins, so the missing contract is terminal-probe handling. + +Why this architecture is the right one: +- Terminal capability negotiation belongs in the terminal client path, not in server-side OpenCode-specific launch hacks. +- A narrow incremental parser matches Freshell’s existing OSC52 and turn-complete preprocessing pattern and avoids destabilizing xterm parser registration for unrelated traffic. +- One shared captured-fixture source prevents three tests from drifting into three different guesses about what OpenCode really sent. + +Execution risks this plan must avoid: +- Do not replace or broaden `registerTerminalRequestModeBypass()` unless a new failing test proves the CSI path is part of this bug. +- Do not invent reply formats or websocket frame shapes from memory. First capture the exact websocket bytes and frame boundaries, then encode that contract in shared fixtures and tests. +- Do not collapse a captured multi-frame startup sequence into a synthetic `probe + visible output` websocket payload just because it is easier to test. +- Do not assume kitty/APC handling is required unless the capture proves OpenCode emitted an APC probe that matters. +- Do not claim support for a terminal feature Freshell does not actually implement. Unsupported replies must be explicit and truthful. +- Do not emit synthetic replies while processing replayed attach history or stale attach generations. Replay needs cleanup, not new PTY input. +- Do not let pending recognized probe bytes survive from replay hydration into the first accepted live frame, or from one attach generation into the next. +- Do not rely on manual QA for completion. Manual repro is optional supporting evidence after automated checks are green. + +## User-Visible Behavior And Invariants + +- Selecting a directory for an `opencode` pane must lead to a visible OpenCode UI instead of a blank hanging pane. +- Recognized startup probe bytes must not be written into visible terminal output or retained in replayed scrollback. +- For the captured live startup sequence, Freshell must send truthful replies for the standalone probe frame before writing any later captured post-reply output to xterm. +- If a live frame completes a split recognized probe and also carries later output, Freshell must send the reply before writing the cleaned remainder of that same frame. +- Replayed startup bytes during attach hydration must be stripped from visible output but must not generate fresh `terminal.input` traffic. +- Pending recognized probe fragments from replay hydration must be discarded before the first accepted live frame, including when replay completion is announced by `terminal.output.gap`, and pending probe state must reset across attach generations. +- Partial recognized probe sequences split across websocket frames must be buffered and completed correctly. +- Unknown, malformed, or unrelated OSC/APC traffic must pass through unchanged. +- Existing CSI request-mode replies must continue to work exactly as they do today. +- Identical captured startup-probe bytes must be handled the same way regardless of pane mode; the helper's startup-only contract, not an `opencode`-only gate, defines the safe scope. + +## File Structure + +- Create: `src/lib/terminal-startup-probes.ts` + - Pure incremental parser for the exact captured non-CSI OpenCode startup probes plus truthful reply builders. +- Modify: `src/components/TerminalView.tsx` + - Run startup-probe extraction before OSC52 and turn-complete processing; send any generated replies over the existing `terminal.input` websocket path and reset parser state at attach/replay boundaries. +- Create: `test/helpers/opencode-startup-probes.ts` + - Single shared fixture module containing the exact captured websocket startup frame sequence, expected cleaned output, expected replies, and split-frame variants used by all tests. +- Create: `test/unit/client/lib/terminal-startup-probes.test.ts` + - Pure parser coverage for the shared fixture contract, partial-frame buffering, and passthrough behavior. +- Modify: `test/unit/client/components/TerminalView.osc52.test.tsx` + - Extend the existing terminal-output preprocessing harness to assert startup-probe replies, probe-only-frame handling, cleaned writes, reply-before-write ordering, preserved OSC52 behavior, and mode-agnostic handling with deterministic terminal theme colors. +- Create: `test/e2e/opencode-startup-probes.test.tsx` + - Attach/replay regression using the shared fixture frames, including replay/live boundary handling and replay completion via `terminal.output.gap`. +- Modify: `test/e2e/directory-picker-flow.test.tsx` + - Boundary regression for the real picker handoff into an `opencode` terminal pane with the confirmed cwd. +- Modify: `src/components/TabsView.tsx` + - Verification-only accessibility cleanup required so Task 4 Step 3's repo-wide lint gate passes without unrelated a11y errors in this worktree. +- Modify: `src/components/Sidebar.tsx` + - Verification-only dead-code cleanup required so Task 4 Step 3's repo-wide lint gate passes without unrelated unused-variable errors in this worktree. +- Modify: `src/components/context-menu/ContextMenuProvider.tsx` + - Verification-only dead-code cleanup required so Task 4 Step 3's repo-wide lint gate passes without unrelated unused-variable errors in this worktree. +- Modify: `src/store/persistMiddleware.ts` + - Verification-only dead-import cleanup required so Task 4 Step 3's repo-wide lint gate passes without unrelated unused-import errors in this worktree. +- Modify: `test/unit/client/components/TabsView.test.tsx` + - Keep the `TabsView` accessibility assertion aligned with the required lint-gate cleanup above. + +## Protocol Scope + +- **Keep as-is:** `CSI Ps $ p` and `CSI ? Ps $ p` handling in `src/components/terminal/request-mode-bypass.ts`. +- **Add only if capture proves it:** non-CSI startup probe forms emitted by the failing OpenCode session. +- **Preserve:** unrelated OSC/APC/DCS traffic untouched. + +If the capture shows only an OSC color query, implement only that. If it shows an APC or other non-CSI probe that requires a reply, implement exactly that form and no more. If a captured form appears only in replay coverage and does not require a live reply, strip it without inventing a reply. + +## Task 1: Freeze The Real OpenCode Websocket Probe Contract + +**Files:** +- Create: `test/helpers/opencode-startup-probes.ts` +- Modify: `test/unit/client/components/TerminalView.osc52.test.tsx` +- Create: `test/e2e/opencode-startup-probes.test.tsx` + +- [ ] **Step 1: Identify the exact failing websocket startup frames and encode them once** + +Source the probe contract from the real failing OpenCode websocket repro before writing parser logic. Do not guess from release notes, raw PTY chunks, or terminal lore. + +Capture the first hung `terminal.output.data` websocket frames from the real failing Freshell session, because that is the exact client-side contract this fix must process. Save the raw bytes exactly as delivered to `handleTerminalOutput`, including the frame boundaries for: +- the first standalone recognized probe frame +- the later post-reply startup frames that arrive after the truthful reply is written +- one split-sequence variant for buffering coverage; this split case may be synthetic if it is derived directly from the captured recognized probe bytes and is only used for the buffering boundary test + +Use a one-off local logging patch or devtools capture during repro, but do not keep temporary instrumentation in the repo. A raw `node-pty` harness may corroborate the byte values inside a frame, but it is not allowed to define the websocket frame boundaries for the fixture. If you cannot freeze the websocket sequence, stop and recapture instead of inventing one. + +Create `test/helpers/opencode-startup-probes.ts` exporting: + +```ts +export const OPEN_CODE_STARTUP_PROBE_FRAME = '...exact raw bytes...' +export const OPEN_CODE_STARTUP_PROBE_SPLIT_FRAMES = ['...part 1...', '...part 2...'] +export const OPEN_CODE_STARTUP_POST_REPLY_FRAMES = ['...frame 1...', '...frame 2...'] +export const OPEN_CODE_STARTUP_POST_REPLY_OUTPUT = OPEN_CODE_STARTUP_POST_REPLY_FRAMES.join('') +export const OPEN_CODE_STARTUP_EXPECTED_REPLIES = ['...exact reply 1...', '...exact reply 2...'] +export const OPEN_CODE_STARTUP_EXPECTED_CLEANED = OPEN_CODE_STARTUP_POST_REPLY_OUTPUT +``` + +Rules: +- Record bytes exactly as captured, including ESC/BEL/ST delimiters. +- Preserve the real websocket frame boundaries for the captured live startup path; do not concatenate the probe frame and post-reply frames into a synthetic single payload. +- If the capture proves there is no APC probe, do not export APC expectations. +- Add a short comment naming the exact capture source so future debugging can reproduce the fixture source. + +- [ ] **Step 2: Write the failing tests against the shared contract** + +Create `test/unit/client/lib/terminal-startup-probes.test.ts` with tests shaped by the shared fixture: + +```ts +it('extracts the captured standalone startup probe and passes the post-reply frames through unchanged', () => {}) +it('buffers a captured startup probe split across frames', () => {}) +it('passes unrelated OSC/APC traffic through unchanged', () => {}) +it('preserves incomplete unknown escape traffic until the frame completes', () => {}) +``` + +Extend `test/unit/client/components/TerminalView.osc52.test.tsx` so the startup path follows the real websocket contract: +- first emit `OPEN_CODE_STARTUP_PROBE_FRAME` by itself and assert that it generates replies but no write +- then emit one or more `OPEN_CODE_STARTUP_POST_REPLY_FRAMES`, with an OSC52 sequence in a later frame +- run the same startup-probe assertions for at least one non-`opencode` terminal mode so a `mode === 'opencode'` gate cannot satisfy the tests + +Assert: +- `ws.send` includes the expected `terminal.input` reply messages +- xterm `write()` receives only `OPEN_CODE_STARTUP_EXPECTED_CLEANED` +- the reply messages are sent before the first cleaned post-reply write +- the same reply-before-write behavior occurs in both the `opencode` case and the non-`opencode` case +- existing OSC52 policy behavior still works + +Use a deterministic mocked terminal theme in this file so any color-query reply bytes are stable and explicit. + +Create `test/e2e/opencode-startup-probes.test.tsx` using the existing attach/replay harness style from `test/e2e/terminal-create-attach-ordering.test.tsx`. Cover the real multi-frame startup contract plus the boundary cases that can regress it: +- live startup: emit `OPEN_CODE_STARTUP_PROBE_FRAME`, assert replies and no writes, then emit `OPEN_CODE_STARTUP_POST_REPLY_FRAMES` and assert the cleaned writes +- replay startup: emit the same historical frames during replay hydration and assert they are stripped from visible output without fresh reply traffic +- replay/live boundary on `terminal.output`: prove a replay fragment cannot be completed by the first live frame, but a complete recognized probe on the first accepted post-replay live frame still replies normally +- replay/live boundary on `terminal.output.gap`: emit only a replay fragment, complete replay with a gap message, then prove the first accepted live frame discards the stale fragment instead of completing it +- split live startup: prove a live split probe buffers until completion and replies exactly once + +- [ ] **Step 3: Run the new tests to verify the contract is red** + +Run: + +```bash +npm run test:vitest -- --run \ + test/unit/client/lib/terminal-startup-probes.test.ts \ + test/unit/client/components/TerminalView.osc52.test.tsx \ + test/e2e/opencode-startup-probes.test.tsx +``` + +Expected: +- the new pure parser test fails because the implementation module does not exist yet +- the `TerminalView` and attach/replay tests fail because startup probes are still written through, replay/live boundaries are not handled correctly, the gap-completion boundary leaks stale probe fragments, the path is still mode-gated, and no replies are sent + +- [ ] **Step 4: Commit the frozen failing contract** + +```bash +git add \ + test/helpers/opencode-startup-probes.ts \ + test/unit/client/components/TerminalView.osc52.test.tsx \ + test/e2e/opencode-startup-probes.test.tsx \ + test/unit/client/lib/terminal-startup-probes.test.ts +git commit -m "test: capture opencode startup probe contract" +``` + +## Task 2: Implement The Narrow Startup-Probe Parser + +**Files:** +- Create: `src/lib/terminal-startup-probes.ts` +- Modify: `test/unit/client/lib/terminal-startup-probes.test.ts` + +- [ ] **Step 1: Write the failing pure-parser test or confirm it is still failing** + +Use the parser test from Task 1 as the red target. Confirm it is failing for the missing-implementation reason, not because the shared fixture is malformed. + +- [ ] **Step 2: Run the pure parser test to verify it fails for the expected reason** + +Run: + +```bash +npm run test:vitest -- --run test/unit/client/lib/terminal-startup-probes.test.ts +``` + +Expected: FAIL because `src/lib/terminal-startup-probes.ts` does not exist or does not yet satisfy the captured contract. + +- [ ] **Step 3: Write the minimal implementation** + +Create `src/lib/terminal-startup-probes.ts` with a narrow API: + +```ts +export type TerminalStartupProbeState = { + pending: string +} + +export type TerminalStartupProbeColors = { + foreground?: string + background?: string + cursor?: string +} + +export type TerminalStartupProbeResult = { + cleaned: string + replies: string[] +} + +export function createTerminalStartupProbeState(): TerminalStartupProbeState + +export function extractTerminalStartupProbes( + chunk: string, + state: TerminalStartupProbeState, + colors: TerminalStartupProbeColors, +): TerminalStartupProbeResult +``` + +Implementation constraints: +- support only the exact captured probe forms exported by `test/helpers/opencode-startup-probes.ts` +- preserve unrelated content in `cleaned` +- buffer incomplete escape sequences in `state.pending` +- generate only truthful replies for the recognized captured forms +- keep the module pure and independent of React/xterm/websocket concerns + +- [ ] **Step 4: Run the pure parser test to verify it passes** + +Run: + +```bash +npm run test:vitest -- --run test/unit/client/lib/terminal-startup-probes.test.ts +``` + +Expected: PASS. + +- [ ] **Step 5: Refactor and verify** + +Tighten the parser without broadening scope: +- keep one buffering path for incomplete escape traffic +- keep reply builders query-specific and small +- keep fixture-driven expectations readable + +Re-run: + +```bash +npm run test:vitest -- --run test/unit/client/lib/terminal-startup-probes.test.ts +``` + +Expected: PASS. + +- [ ] **Step 6: Commit** + +```bash +git add \ + src/lib/terminal-startup-probes.ts \ + test/unit/client/lib/terminal-startup-probes.test.ts +git commit -m "fix: parse opencode startup probes" +``` + +## Task 3: Wire Startup-Probe Replies Into TerminalView + +**Files:** +- Modify: `src/components/TerminalView.tsx` +- Modify: `test/unit/client/components/TerminalView.osc52.test.tsx` +- Modify: `test/e2e/opencode-startup-probes.test.tsx` + +- [ ] **Step 1: Confirm the integration tests are still red** + +Before changing `TerminalView`, confirm: +- the pure parser test is green +- the `TerminalView` and attach/replay tests are still red for integration reasons + +- [ ] **Step 2: Run the integration tests to verify they fail for the expected reason** + +Run: + +```bash +npm run test:vitest -- --run \ + test/unit/client/components/TerminalView.osc52.test.tsx \ + test/e2e/opencode-startup-probes.test.tsx +``` + +Expected: FAIL because `TerminalView` does not yet strip the captured startup probes or send replies for them. + +- [ ] **Step 3: Write the minimal implementation** + +Update `src/components/TerminalView.tsx`: +- add `startupProbeStateRef` alongside `osc52ParserRef` and `turnCompleteSignalStateRef` +- reset `startupProbeStateRef` in the same lifecycle effect that resets the other parser states, at the start of each attach generation, and again when replay completes so replay fragments cannot leak into later live frames +- derive reply colors from the same resolved theme object that is applied to xterm +- call `extractTerminalStartupProbes()` before `extractOsc52Events()` and `extractTurnCompleteSignals()` for every terminal mode; rely on the helper's startup-only contract rather than a `mode === 'opencode'` gate +- thread an explicit `allowReplies` flag from the output-frame handling path so live frames can reply and replay hydration frames can only strip +- send each permitted reply through the existing `sendInput()` path +- when replay completion is detected on `terminal.output.gap`, call the same discard-remainder reset path used for replay completion on `terminal.output` so a replay-carried probe prefix cannot leak into the next live frame +- keep `registerTerminalRequestModeBypass(term, sendInput)` unchanged + +Intended output flow: + +```ts +const startup = extractTerminalStartupProbes(raw, startupProbeStateRef.current, { + foreground: resolvedTheme.foreground, + background: resolvedTheme.background, + cursor: resolvedTheme.cursor, +}) + +if (allowReplies) { + for (const reply of startup.replies) { + sendInput(reply) + } +} + +const osc = extractOsc52Events(startup.cleaned, osc52ParserRef.current) +const { cleaned, count } = extractTurnCompleteSignals( + osc.cleaned, + mode, + turnCompleteSignalStateRef.current, +) +``` + +Keep the implementation narrow: +- do not keep or add a `mode === 'opencode'` gate around startup-probe extraction unless a new failing test proves the captured handling is unsafe outside OpenCode +- do not move protocol logic to the server +- do not reorder OSC52 or turn-complete handling after visible writes +- do not send replies for replay hydration or stale attach output just because the parser recognized a probe +- do not let replay-carried pending probe bytes complete on the first accepted live frame after replay, including when replay completion was announced by `terminal.output.gap`; use discard-before-live semantics for both completion paths + +- [ ] **Step 4: Run the integration tests to verify they pass** + +Run: + +```bash +npm run test:vitest -- --run \ + test/unit/client/components/TerminalView.osc52.test.tsx \ + test/e2e/opencode-startup-probes.test.tsx +``` + +Expected: PASS. + +- [ ] **Step 5: Refactor and verify** + +Re-run the focused regression stack: + +```bash +npm run test:vitest -- --run \ + test/unit/client/lib/terminal-startup-probes.test.ts \ + test/unit/client/components/TerminalView.osc52.test.tsx \ + test/unit/client/components/terminal/request-mode-bypass.test.ts \ + test/e2e/opencode-startup-probes.test.tsx +``` + +Expected: PASS, including unchanged request-mode coverage. + +- [ ] **Step 6: Commit** + +```bash +git add \ + src/components/TerminalView.tsx \ + test/unit/client/components/TerminalView.osc52.test.tsx \ + test/e2e/opencode-startup-probes.test.tsx +git commit -m "fix: answer opencode startup probes" +``` + +## Task 4: Protect The Picker Handoff Boundary + +**Files:** +- Modify: `test/e2e/directory-picker-flow.test.tsx` + +- [ ] **Step 1: Confirm the picker path still needs explicit OpenCode coverage** + +Use the existing picker flow harness as the red target for the user entry path. Confirm there is no existing `opencode` coverage that proves directory confirmation still yields an `opencode` terminal pane with the confirmed cwd. + +- [ ] **Step 2: Extend the picker regression** + +Update `test/e2e/directory-picker-flow.test.tsx` to cover: +- selecting `opencode` in the real provider picker +- confirming a directory through the existing directory picker flow +- asserting the resulting pane becomes `kind: 'terminal'` with `mode: 'opencode'` and `initialCwd` equal to the confirmed directory +- asserting the provider cwd patch is persisted for `opencode` + +- [ ] **Step 3: Run the picker regression** + +Run: + +```bash +npm run test:vitest -- --run test/e2e/directory-picker-flow.test.tsx +``` + +Expected: PASS, including the new `opencode` path. + +- [ ] **Step 4: Refactor and verify** + +Re-run the focused regression stack including the user entry path: + +```bash +npm run test:vitest -- --run \ + test/unit/client/lib/terminal-startup-probes.test.ts \ + test/unit/client/components/TerminalView.osc52.test.tsx \ + test/unit/client/components/terminal/request-mode-bypass.test.ts \ + test/e2e/opencode-startup-probes.test.tsx \ + test/e2e/directory-picker-flow.test.tsx +``` + +Expected: PASS. + +- [ ] **Step 5: Commit** + +```bash +git add test/e2e/directory-picker-flow.test.tsx +git commit -m "test: cover opencode picker handoff" +``` + +## Task 5: Broad Verification + +**Files:** +- Modify only if broad verification exposes a real defect that requires code or test changes + +- [ ] **Step 1: Run the focused regression stack one more time** + +Run: + +```bash +npm run test:vitest -- --run \ + test/unit/client/lib/terminal-startup-probes.test.ts \ + test/unit/client/components/TerminalView.osc52.test.tsx \ + test/unit/client/components/terminal/request-mode-bypass.test.ts \ + test/e2e/opencode-startup-probes.test.tsx \ + test/e2e/directory-picker-flow.test.tsx +``` + +Expected: PASS. + +- [ ] **Step 2: Check broad-suite coordination status** + +Run: + +```bash +npm run test:status +``` + +Expected: no conflicting holder that requires waiting. If another holder is active, wait rather than interrupt it. + +- [ ] **Step 3: Run lint before the broad suite** + +Run: + +```bash +npm run lint +``` + +Expected: PASS. + +- [ ] **Step 4: Run the required broad verification** + +Run: + +```bash +FRESHELL_TEST_SUMMARY="opencode startup probe fix" npm run check +``` + +Expected: PASS with typecheck plus the coordinated full test suite green. + +- [ ] **Step 5: If broad verification reveals a real defect, fix it before proceeding** + +If any valid check fails: +- diagnose the actual defect +- update code and/or tests without weakening coverage +- re-run the focused stack, `npm run lint`, and `FRESHELL_TEST_SUMMARY="opencode startup probe fix" npm run check` +- make an additional commit only if this step required real file changes + +- [ ] **Step 6: Optional manual repro for extra confidence** + +Only after automated checks are green, optionally confirm the original user path in a worktree-local server: + +```bash +PORT=3344 npm run dev:server > /tmp/freshell-3344.log 2>&1 & echo $! > /tmp/freshell-3344.pid +``` + +Check: +- create an `opencode` pane through the normal directory-picker flow +- confirm OpenCode renders instead of hanging +- confirm raw startup probe bytes are not visible + +Then stop only the worktree-owned process: + +```bash +ps -fp "$(cat /tmp/freshell-3344.pid)" +kill "$(cat /tmp/freshell-3344.pid)" && rm -f /tmp/freshell-3344.pid +``` + +## Notes For The Implementer + +- The shared probe fixture is the source of truth for both bytes and websocket frame boundaries. Do not collapse the standalone probe frame and later post-reply frames into one synthetic payload. +- Preserve existing request-mode behavior unless a new failing test proves a defect there. +- Do not pin OpenCode versions, do not add server-side OpenCode fallbacks, and do not fake support for unsupported terminal features. +- If the capture proves only one probe form matters, keep the implementation limited to that one form. +- Apply the startup-probe extractor independent of pane mode; the helper's own startup-only semantics are the scope limiter. +- Reset the startup-probe parser whenever replay or attach-generation state changes, and use discard-remainder reset when replay completes on either `terminal.output` or `terminal.output.gap`; otherwise a replay fragment can be completed incorrectly by the next live frame. diff --git a/docs/plans/2026-04-03-fix-opencode-startup-probes-test-plan.md b/docs/plans/2026-04-03-fix-opencode-startup-probes-test-plan.md new file mode 100644 index 00000000..d8cf7aaa --- /dev/null +++ b/docs/plans/2026-04-03-fix-opencode-startup-probes-test-plan.md @@ -0,0 +1,166 @@ +# Fix OpenCode Startup Probes Test Plan + +## Strategy Reconciliation +No strategy changes requiring user approval are needed. + +The approved strategy still holds: acceptance should stay centered on the real `terminal.create -> terminal.created -> terminal.attach -> terminal.attach.ready -> terminal.output` path in `TerminalView`, with the pure startup-probe parser used only as supporting proof and the directory-picker flow kept as the user entry regression. The implementation plan and current branch state only require a narrower adjustment: the websocket fixture and the focused harnesses already exist in this worktree, so this revision is limited to encoding the two remaining round-9 blockers without widening scope. + +The required adjustments are: +- The `TerminalView` acceptance surface must instantiate at least one explicit non-`opencode` terminal mode, because the finalized plan forbids a `mode === 'opencode'` gate once the captured startup-probe handling is proven safe generically. +- The attach/replay acceptance surface must drive an attach that completes on `terminal.output.gap` after only a replay-carried startup-probe fragment, then prove the first accepted live frame discards that stale fragment instead of leaking `1;?\u0007...` bytes or suppressing a later legitimate live reply. + +No paid services, external infrastructure, browser automation, or live OpenCode binary runs are needed for this revision. The frozen websocket fixture, existing Vitest/Testing Library harnesses, and the repo `lint`/`check` gates remain sufficient. + +## Sources Of Truth +- `S1 User-visible bug statement`: the transcript establishes that selecting a directory for an `opencode` pane must lead to a visible OpenCode UI instead of a blank hanging pane. +- `S2 Finalized implementation invariants`: [2026-04-02-fix-opencode-startup-probes.md](/home/user/code/freshell/.worktrees/trycycle-fix-opencode-startup-probes-20260402/docs/plans/2026-04-02-fix-opencode-startup-probes.md) requires captured startup probes to be stripped from live and replay output, truthful replies to be emitted only for the captured live forms, startup-probe handling to be mode-agnostic if safe, and replay-carried probe fragments to be discarded before later live traffic, including replay completion on `terminal.output.gap`. +- `S3 WebSocket protocol contract`: [ws-protocol.ts](/home/user/code/freshell/.worktrees/trycycle-fix-opencode-startup-probes-20260402/shared/ws-protocol.ts) defines the observable `terminal.create`, `terminal.attach`, `terminal.attach.ready`, `terminal.output`, `terminal.output.gap`, and `terminal.input` surfaces. +- `S4 Adjacent parser contracts`: [terminal-osc52.ts](/home/user/code/freshell/.worktrees/trycycle-fix-opencode-startup-probes-20260402/src/lib/terminal-osc52.ts), [turn-complete-signal.ts](/home/user/code/freshell/.worktrees/trycycle-fix-opencode-startup-probes-20260402/src/lib/turn-complete-signal.ts), and [request-mode-bypass.ts](/home/user/code/freshell/.worktrees/trycycle-fix-opencode-startup-probes-20260402/src/components/terminal/request-mode-bypass.ts) define neighboring output-preprocessing behavior that must not regress. +- `S5 Picker handoff contract`: [PaneContainer.tsx](/home/user/code/freshell/.worktrees/trycycle-fix-opencode-startup-probes-20260402/src/components/panes/PaneContainer.tsx) and [directory-picker-flow.test.tsx](/home/user/code/freshell/.worktrees/trycycle-fix-opencode-startup-probes-20260402/test/e2e/directory-picker-flow.test.tsx) define the user entry path from provider selection and directory confirmation to `TerminalPaneContent.initialCwd`. +- `S6 Frozen websocket startup fixture`: [opencode-startup-probes.ts](/home/user/code/freshell/.worktrees/trycycle-fix-opencode-startup-probes-20260402/test/helpers/opencode-startup-probes.ts) is the single source of truth for the exact captured probe-only websocket frame, later post-reply frames, split-frame variant, expected cleaned output, and truthful replies. +- `S7 Existing acceptance surfaces`: [opencode-startup-probes.test.tsx](/home/user/code/freshell/.worktrees/trycycle-fix-opencode-startup-probes-20260402/test/e2e/opencode-startup-probes.test.tsx), [TerminalView.osc52.test.tsx](/home/user/code/freshell/.worktrees/trycycle-fix-opencode-startup-probes-20260402/test/unit/client/components/TerminalView.osc52.test.tsx), [terminal-startup-probes.test.ts](/home/user/code/freshell/.worktrees/trycycle-fix-opencode-startup-probes-20260402/test/unit/client/lib/terminal-startup-probes.test.ts), and [directory-picker-flow.test.tsx](/home/user/code/freshell/.worktrees/trycycle-fix-opencode-startup-probes-20260402/test/e2e/directory-picker-flow.test.tsx) are the harnesses to extend or rerun. +- `S8 Branch verification gate`: the finalized implementation plan keeps repo-wide `npm run lint` and `FRESHELL_TEST_SUMMARY="opencode startup probe fix" npm run check` in scope, plus the retained cleanup files required for those gates to pass in this worktree. +- `S9 Generic-safety proof for removing the mode gate`: [terminal-startup-probes.ts](/home/user/code/freshell/.worktrees/trycycle-fix-opencode-startup-probes-20260402/src/lib/terminal-startup-probes.ts) and [terminal-startup-probes.test.ts](/home/user/code/freshell/.worktrees/trycycle-fix-opencode-startup-probes-20260402/test/unit/client/lib/terminal-startup-probes.test.ts) already show the helper only recognizes the captured startup OSC 11 query while it remains startup-armed and passes later or embedded OSC 11 traffic through unchanged. + +## Action Space +- Click the `OpenCode` provider button in the pane picker. +- Submit the directory-picker form for `OpenCode`. +- Convert the picker pane into a terminal pane with `mode: 'opencode'` and `initialCwd`. +- Send `terminal.create` for the new pane. +- Receive `terminal.created`. +- Send `terminal.attach`. +- Receive `terminal.attach.ready`. +- Receive a live `terminal.output` frame containing only the captured startup probe. +- Receive the later live `terminal.output` frames carrying the captured post-reply startup bytes. +- Receive the same captured startup-probe bytes while the pane mode is `shell`. +- Receive replay `terminal.output` frames containing historical startup bytes. +- Receive replay completion on a terminal-output frame. +- Receive replay completion on `terminal.output.gap`. +- Receive the first accepted live `terminal.output` frame after replay completion. +- Send synthetic `terminal.input` replies for live recognized startup probes. +- Process a later OSC52 clipboard sequence on the same output path. +- Run the existing request-mode bypass path for CSI request-mode replies. +- Run the repo `lint` and `check` verification gates for the retained branch scope. + +## Harness Requirements +No new harness families are required. Extend the existing harnesses first. + +| Harness | What it does | What it exposes | Estimated complexity | Tests that depend on it | +| --- | --- | --- | --- | --- | +| `H1 Shared websocket startup fixture` | Reuses the existing exact websocket startup fixture and, if needed, tightens comments or names so every suite consumes the same captured frame boundaries and split-frame variant. | `OPEN_CODE_STARTUP_PROBE_FRAME`, `OPEN_CODE_STARTUP_POST_REPLY_FRAMES`, `OPEN_CODE_STARTUP_PROBE_SPLIT_FRAMES`, `OPEN_CODE_STARTUP_EXPECTED_REPLIES`, and `OPEN_CODE_STARTUP_EXPECTED_CLEANED`. | Low | 1, 2, 3, 4, 5, 6, 8, 9 | +| `H2 TerminalView output-preprocessing harness` | Extends the existing `TerminalView.osc52` harness so it can render the same output path in both `opencode` and `shell` modes, capture `terminal.input` sends, capture xterm writes, and assert send-before-write ordering with deterministic theme colors. | Frame-by-frame `terminal.output` injection, outgoing `terminal.input`, xterm `write()`, clipboard side effects, and exact ordering across pane modes. | Medium | 2, 8, 10 | +| `H3 Attach/replay startup scenario harness` | Extends the existing `opencode-startup-probes` scenario harness so it can drive replay windows, replay completion on `terminal.output` and `terminal.output.gap`, stale-fragment discard, split probes, and first-live-frame assertions through the real create/attach/output path. | End-to-end `terminal.created -> terminal.attach -> terminal.attach.ready -> terminal.output` sequencing, replay/live transitions, visible writes, and outgoing reply traffic. | Medium | 1, 3, 4, 5, 6 | +| `H4 OpenCode picker handoff harness` | Reuses the existing directory-picker flow so the user entry path from provider selection to terminal-pane creation remains protected. | Provider selection, directory confirmation, resulting pane content, and persisted provider cwd patch. | Low | 7 | +| `H5 Broad branch verification gate` | Reuses existing repo commands and retained unit suites so the branch-scoped cleanup files remain honest and adjacent protocol behavior stays green. | `npm run lint`, `npm run check`, and targeted adjacent suites for request-mode, OSC52, turn-complete, lifecycle, and `TabsView`. | Low | 10 | + +## Test Plan +1. **Name:** Replay completion on `terminal.output.gap` discards a stale startup-probe fragment before the first live frame. + **Type:** boundary + **Disposition:** extend + **Harness:** `H3` + **Preconditions:** An attach is in replay mode; replay has delivered only the first element of `OPEN_CODE_STARTUP_PROBE_SPLIT_FRAMES`; replay completion will arrive on `terminal.output.gap`; the first accepted live frame begins with the remaining probe bytes followed by captured startup output. + **Actions:** Emit the first split fragment during replay. Emit `terminal.output.gap` that closes the replay window. Then emit the first accepted live `terminal.output` frame containing the remainder of the split probe plus the first captured post-reply bytes. + **Expected outcome:** No `terminal.input` reply is emitted for the replay-carried fragment. The first accepted live write contains only the cleaned post-reply startup bytes from `OPEN_CODE_STARTUP_EXPECTED_CLEANED`; no raw or partial startup-probe bytes such as `1;?\u0007` leak into the write stream. Source of truth: `S2`, `S3`, `S6`, `S7`. + **Interactions:** Attach sequence state, replay completion on `terminal.output.gap`, startup-probe parser pending state, websocket reply path, xterm write queue. + +2. **Name:** `TerminalView` strips captured startup probes in both `opencode` and `shell` modes and still preserves OSC52 behavior. + **Type:** integration + **Disposition:** extend + **Harness:** `H2` + **Preconditions:** `TerminalView` is rendered twice with deterministic theme colors and the same startup fixture from `H1`: once with `mode: 'opencode'` and once with `mode: 'shell'`; an OSC52 clipboard sequence is appended to a later post-reply frame. + **Actions:** For each mode, emit `OPEN_CODE_STARTUP_PROBE_FRAME`, then emit `OPEN_CODE_STARTUP_POST_REPLY_FRAMES` in order with the OSC52 payload attached to a later frame. + **Expected outcome:** In both modes, `ws.send` emits `OPEN_CODE_STARTUP_EXPECTED_REPLIES` before the first cleaned write; xterm `write()` never receives the probe bytes; the later OSC52 payload still follows the configured clipboard policy. This test must fail if `handleTerminalOutput` keeps a `mode === 'opencode'` gate. Source of truth: `S2`, `S4`, `S6`, `S7`, `S9`. + **Interactions:** Startup-probe parser, pane mode handling, OSC52 parser, clipboard side effects, theme-derived reply bytes, xterm write scheduling. + +3. **Name:** The first live probe-only websocket frame is answered before any later startup output is written. + **Type:** scenario + **Disposition:** extend + **Harness:** `H3` + **Preconditions:** An `opencode` terminal pane has completed `terminal.created` and `terminal.attach.ready` with no replay window; `H1` provides the captured probe-only frame and later post-reply frames. + **Actions:** Emit `OPEN_CODE_STARTUP_PROBE_FRAME` as the first live `terminal.output` frame. Assert the intermediate state. Then emit each `OPEN_CODE_STARTUP_POST_REPLY_FRAMES` item in captured order. + **Expected outcome:** The probe-only frame emits one `terminal.input` per `OPEN_CODE_STARTUP_EXPECTED_REPLIES` and causes no xterm write. The later frames write only `OPEN_CODE_STARTUP_EXPECTED_CLEANED`. The reply sequence is fully sent before the first visible write. Source of truth: `S1`, `S2`, `S3`, `S6`, `S7`. + **Interactions:** `TerminalView` output pipeline, websocket `terminal.input`/`terminal.output`, xterm write queue, terminal theme resolution. + +4. **Name:** Replay hydration strips historical startup bytes without sending late replies. + **Type:** scenario + **Disposition:** extend + **Harness:** `H3` + **Preconditions:** `terminal.attach.ready` announces a replay window covering the captured startup sequence from `H1`. + **Actions:** Emit the captured probe-only frame and captured post-reply frames during replay hydration. After replay completes, emit one later live visible-output frame. + **Expected outcome:** Replay writes contain only cleaned historical startup output with the probe bytes removed. No `terminal.input` reply traffic is emitted during replay hydration. Later live output still renders normally after replay ends. Source of truth: `S1`, `S2`, `S3`, `S6`, `S7`. + **Interactions:** Attach/replay sequencing, replay-window tracking, websocket reply path, xterm write queue. + +5. **Name:** The first accepted live frame after replay still replies to a complete startup probe. + **Type:** boundary + **Disposition:** extend + **Harness:** `H3` + **Preconditions:** Replay has completed and the next accepted live frame is the captured standalone `OPEN_CODE_STARTUP_PROBE_FRAME`. + **Actions:** Emit `OPEN_CODE_STARTUP_PROBE_FRAME` as the first accepted post-replay live frame, then emit `OPEN_CODE_STARTUP_POST_REPLY_FRAMES` in order. + **Expected outcome:** The parser emits `OPEN_CODE_STARTUP_EXPECTED_REPLIES` exactly once and writes `OPEN_CODE_STARTUP_EXPECTED_CLEANED` exactly once, proving replay cleanup does not suppress legitimate later live probes. Source of truth: `S2`, `S3`, `S6`, `S7`. + **Interactions:** Replay reset behavior, live output path, websocket reply ordering, xterm write queue. + +6. **Name:** A startup probe split across live websocket frames buffers until complete and replies exactly once. + **Type:** boundary + **Disposition:** extend + **Harness:** `H3` + **Preconditions:** A live `opencode` attach is ready and `OPEN_CODE_STARTUP_PROBE_SPLIT_FRAMES` represents one recognized startup probe split across websocket boundaries. + **Actions:** Emit the first split frame alone. Then emit the second split frame followed by the first captured post-reply bytes, followed by any remaining captured post-reply frames. + **Expected outcome:** After the first frame there is no reply and no visible write. After the second frame completes the probe, the exact expected reply sequence is sent once and the cleaned startup output is written once, with no duplicate replies or raw probe bytes. Source of truth: `S2`, `S3`, `S6`, `S7`. + **Interactions:** Startup-probe parser buffering, live output path, websocket reply path, xterm write queue. + +7. **Name:** Selecting `OpenCode` in the directory picker launches a terminal pane with the confirmed cwd. + **Type:** regression + **Disposition:** existing + **Harness:** `H4` + **Preconditions:** The pane picker exposes an enabled `OpenCode` provider and directory validation resolves the entered path. + **Actions:** Open the picker, select `OpenCode`, enter a directory, and confirm it through the existing directory-picker flow. + **Expected outcome:** The pane content becomes `kind: 'terminal'` with `mode: 'opencode'` and `initialCwd` equal to the resolved directory, and the provider cwd patch is persisted. Source of truth: `S1`, `S5`, `S7`. + **Interactions:** `PanePicker`, `DirectoryPicker`, pane content creation, provider settings persistence. + +8. **Name:** The shared parser fixture maps the captured websocket startup sequence to exact replies and cleaned output. + **Type:** differential + **Disposition:** existing + **Harness:** `H1` + **Preconditions:** `H1` exports the captured probe-only frame, captured post-reply frames, expected replies, and expected cleaned output; deterministic colors are available. + **Actions:** Call `extractTerminalStartupProbes()` with `OPEN_CODE_STARTUP_PROBE_FRAME`, then feed each `OPEN_CODE_STARTUP_POST_REPLY_FRAMES` item in order using the same colors as the live harness. + **Expected outcome:** The probe-only frame yields `OPEN_CODE_STARTUP_EXPECTED_REPLIES` and no cleaned output. The later frames yield `OPEN_CODE_STARTUP_EXPECTED_CLEANED` with no extra replies for forms not present in the frozen capture. Source of truth: `S2`, `S6`, `S7`, `S9`. + **Interactions:** Pure startup-probe parser only. + +9. **Name:** Unrecognized, malformed, or incomplete OSC/APC traffic is preserved unless it matches the frozen startup contract. + **Type:** invariant + **Disposition:** existing + **Harness:** `H1` + **Preconditions:** Parser state is fresh; inputs include incomplete unknown escape traffic, malformed startup-probe traffic, and unrelated OSC/APC examples outside the frozen capture. + **Actions:** Feed the parser the sample inputs across one or more calls. + **Expected outcome:** Unknown incomplete traffic is buffered and later re-emitted unchanged; malformed or unrelated OSC/APC traffic remains in `cleaned` unchanged and emits no synthetic replies. Source of truth: `S2`, `S4`, `S6`, `S7`, `S9`. + **Interactions:** Pure startup-probe parser buffering and passthrough logic. + +10. **Name:** Adjacent protocol suites and retained lint-gate cleanup stay green with the startup-probe fix. + **Type:** regression + **Disposition:** existing + **Harness:** `H5` + **Preconditions:** Startup-probe changes are complete and the retained cleanup files remain in branch scope. + **Actions:** Run the existing request-mode bypass suite, the existing `terminal-osc52` and `turn-complete-signal` parser suites, the relevant `TerminalView` lifecycle/OSC52 suites, the retained `TabsView` unit suite, `npm run lint`, and `FRESHELL_TEST_SUMMARY="opencode startup probe fix" npm run check`. + **Expected outcome:** All suites and repo gates pass unchanged, proving the new startup-probe handling does not steal CSI request-mode replies, regress neighboring output preprocessors, or leave the retained cleanup surface unverified. Source of truth: `S2`, `S4`, `S7`, `S8`. + **Interactions:** xterm CSI parser registration, client-side escape-sequence preprocessors, `TerminalView` lifecycle behavior, `TabsView` accessibility expectations, lint/typecheck/coordinated repo suite. + +## Coverage Summary +Covered: +- The actual user-visible failure surface after directory confirmation: live `terminal.output` handling in `TerminalView`, including reply-before-write ordering. +- The two remaining acceptance blockers: mode-agnostic startup-probe stripping and replay-fragment discard when replay completes on `terminal.output.gap`. +- Replay hydration semantics, split-frame buffering, and first-live-frame behavior after replay. +- Coexistence with adjacent output preprocessors, especially OSC52, turn-complete, and CSI request-mode bypass. +- The user entry path from picker selection to an `opencode` terminal pane with the confirmed cwd. +- The retained branch verification gates needed to keep the current worktree mergeable. + +Explicitly excluded per the agreed strategy: +- Launching a real OpenCode binary in automated CI after the websocket fixture is frozen. +- Using raw PTY chunk boundaries as the acceptance source of truth for websocket-frame tests. +- Broad server-side spawn or launcher tests, because the investigation and implementation plan both place the bug after PTY launch and after `terminal.output` begins. +- Manual QA or human visual inspection as a pass/fail gate. +- Guessing support for startup-probe forms not present in the frozen websocket capture. + +Risks carried by those exclusions: +- If a future OpenCode release changes its startup probes again, the fixture-driven suites will need a new captured websocket sequence; they will not predict unseen upstream probe formats ahead of time. +- Because the automated suite does not launch a live OpenCode process, it proves Freshell's client behavior against the frozen failing bytes rather than every future upstream OpenCode version. +- Because server spawn is excluded from the acceptance stack, a future bug that combines launch-path and startup-probe failures would need a separate integrated scenario. diff --git a/src/components/Sidebar.tsx b/src/components/Sidebar.tsx index cd498b9c..22078cec 100644 --- a/src/components/Sidebar.tsx +++ b/src/components/Sidebar.tsx @@ -185,7 +185,6 @@ export default function Sidebar({ const dispatch = useAppDispatch() const store = useAppStore() const settings = useAppSelector((s) => s.settings.settings) - const tabs = useAppSelector((s) => s.tabs.tabs) const activeTabId = useAppSelector((s) => s.tabs.activeTabId) const activeSessionKeyFromPanes = useAppSelector((s) => { const tabId = s.tabs.activeTabId diff --git a/src/components/TabsView.tsx b/src/components/TabsView.tsx index 3bd52bc5..6165664b 100644 --- a/src/components/TabsView.tsx +++ b/src/components/TabsView.tsx @@ -296,35 +296,28 @@ function TabCard({ const actionLabel = isLocal && isOpen ? 'Jump' : 'Pull' return ( -
{ - if (e.key === 'Enter' || e.key === ' ') { - e.preventDefault() - onAction() - } - }} > {showDevice && ( -
+ {record.displayDeviceLabel} -
+ )} -
{record.tabName}
+ {record.tabName} -
+ {paneKinds.map((kind) => { const Icon = paneKindIcon(kind) return ( @@ -349,9 +342,9 @@ function TabCard({ · {formatRelativeTime(timestamp, now)} -
+ -
-
-
+ + ) } diff --git a/src/components/TerminalView.tsx b/src/components/TerminalView.tsx index 36393dd5..2f3b4310 100644 --- a/src/components/TerminalView.tsx +++ b/src/components/TerminalView.tsx @@ -52,6 +52,10 @@ import { type Osc52Event, type Osc52Policy, } from '@/lib/terminal-osc52' +import { + createTerminalStartupProbeState, + extractTerminalStartupProbes, +} from '@/lib/terminal-startup-probes' import { ContextIds } from '@/components/context-menu/context-menu-constants' import { resolveTerminalFontFamily } from '@/lib/terminal-fonts' import { ConnectionErrorOverlay } from '@/components/terminal/ConnectionErrorOverlay' @@ -83,6 +87,7 @@ export const RATE_LIMIT_RETRY_MAX_MS = 12000 const KEYBOARD_INSET_ACTIVATION_PX = 80 const MOBILE_KEYBAR_HEIGHT_PX = 40 const MOBILE_KEY_REPEAT_INITIAL_DELAY_MS = 320 +const STARTUP_PROBE_OSC11_QUERY = '\u001b]11;?\u0007' function isClaudeTurnSubmit(data: string): boolean { return data.includes('\r') || data.includes('\n') @@ -96,10 +101,62 @@ const DEFAULT_MIN_CONTRAST_RATIO = 1 const MAX_LAST_SENT_VIEWPORT_CACHE_ENTRIES = 200 const TRUNCATED_REPLAY_BYTES = 128 * 1024 +type StartupProbeReplayDiscardState = { + remainder: string | null + buffered: string +} + function resolveMinimumContrastRatio(theme?: { isDark?: boolean } | null): number { return theme?.isDark === false ? LIGHT_THEME_MIN_CONTRAST_RATIO : DEFAULT_MIN_CONTRAST_RATIO } +function consumeStartupProbeReplayDiscard(raw: string, state: StartupProbeReplayDiscardState): string { + const remainder = state.remainder + if (!remainder) { + state.buffered = '' + return raw + } + + let matched = state.buffered + let index = 0 + while ( + index < raw.length + && matched.length < remainder.length + && raw[index] === remainder[matched.length] + ) { + matched += raw[index] + index += 1 + } + + if (matched.length === remainder.length) { + state.remainder = null + state.buffered = '' + return raw.slice(index) + } + + if (index < raw.length) { + state.remainder = null + state.buffered = '' + return `${matched}${raw.slice(index)}` + } + + if (index === raw.length) { + state.buffered = matched + return '' + } + + return raw +} + +function getStartupProbeReplayRemainder(pending: string): string | null { + if (!pending || pending === STARTUP_PROBE_OSC11_QUERY) { + return null + } + return STARTUP_PROBE_OSC11_QUERY.startsWith(pending) + ? STARTUP_PROBE_OSC11_QUERY.slice(pending.length) + : null +} + function deferTerminalPointerMutation(callback: () => void): void { // xterm link activation runs inside element-level mouse handlers while it may // still have document-level mouseup/move listeners in flight. Reparenting the @@ -270,7 +327,13 @@ export default function TerminalView({ tabId, paneId, paneContent, hidden }: Ter const restoreRequestIdRef = useRef(null) const restoreFlagRef = useRef(false) const turnCompleteSignalStateRef = useRef(createTurnCompleteSignalParserState()) + const startupProbeStateRef = useRef(createTerminalStartupProbeState()) + const startupProbeReplayDiscardStateRef = useRef({ + remainder: null, + buffered: '', + }) const osc52ParserRef = useRef(createOsc52ParserState()) + const resolvedThemeRef = useRef(getTerminalTheme(settings.terminal.theme, settings.theme)) const osc52PolicyRef = useRef(settings.terminal.osc52Clipboard) const pendingOsc52EventRef = useRef(null) const osc52QueueRef = useRef([]) @@ -825,8 +888,63 @@ export default function TerminalView({ tabId, paneId, paneContent, hidden }: Ter setPendingOsc52Event(event) }, [attemptOsc52ClipboardWrite]) - const handleTerminalOutput = useCallback((raw: string, mode: TerminalPaneContent['mode'], tid?: string) => { - const osc = extractOsc52Events(raw, osc52ParserRef.current) + const sendInput = useCallback((data: string) => { + const tid = terminalIdRef.current + if (!tid) return + // In 'type' mode, clear attention when user sends input. + // In 'click' mode, attention is cleared by the notification hook on tab switch. + if (attentionDismissRef.current === 'type') { + if (hasAttentionRef.current) { + dispatch(clearTabAttention({ tabId })) + } + if (hasPaneAttentionRef.current) { + dispatch(clearPaneAttention({ paneId })) + } + } + if (contentRef.current?.mode === 'claude' && isClaudeTurnSubmit(data)) { + turnCompletedSinceLastInputRef.current = false + dispatch(setPaneRuntimeActivity({ + paneId: paneIdRef.current, + source: 'terminal', + phase: 'pending', + })) + } + ws.send({ type: 'terminal.input', terminalId: tid, data }) + }, [dispatch, tabId, paneId, ws]) + + const resetStartupProbeParser = useCallback((opts?: { discardReplayRemainder?: boolean }) => { + const pendingProbe = startupProbeStateRef.current.pending + if (opts?.discardReplayRemainder) { + const remainder = getStartupProbeReplayRemainder(pendingProbe) + startupProbeReplayDiscardStateRef.current = { + remainder, + buffered: '', + } + } else { + startupProbeReplayDiscardStateRef.current = { remainder: null, buffered: '' } + } + startupProbeStateRef.current = createTerminalStartupProbeState() + }, []) + + const handleTerminalOutput = useCallback(( + raw: string, + mode: TerminalPaneContent['mode'], + tid: string | undefined, + allowReplies: boolean, + ) => { + const startup = extractTerminalStartupProbes(raw, startupProbeStateRef.current, { + foreground: resolvedThemeRef.current.foreground, + background: resolvedThemeRef.current.background, + cursor: resolvedThemeRef.current.cursor, + }) + + if (allowReplies) { + for (const reply of startup.replies) { + sendInput(reply) + } + } + + const osc = extractOsc52Events(startup.cleaned, osc52ParserRef.current) const { cleaned, count } = extractTurnCompleteSignals(osc.cleaned, mode, turnCompleteSignalStateRef.current) if (count > 0 && tid) { @@ -863,31 +981,7 @@ export default function TerminalView({ tabId, paneId, paneContent, hidden }: Ter for (const event of osc.events) { handleOsc52Event(event) } - }, [dispatch, enqueueTerminalWrite, handleOsc52Event, tabId]) - - const sendInput = useCallback((data: string) => { - const tid = terminalIdRef.current - if (!tid) return - // In 'type' mode, clear attention when user sends input. - // In 'click' mode, attention is cleared by the notification hook on tab switch. - if (attentionDismissRef.current === 'type') { - if (hasAttentionRef.current) { - dispatch(clearTabAttention({ tabId })) - } - if (hasPaneAttentionRef.current) { - dispatch(clearPaneAttention({ paneId })) - } - } - if (contentRef.current?.mode === 'claude' && isClaudeTurnSubmit(data)) { - turnCompletedSinceLastInputRef.current = false - dispatch(setPaneRuntimeActivity({ - paneId: paneIdRef.current, - source: 'terminal', - phase: 'pending', - })) - } - ws.send({ type: 'terminal.input', terminalId: tid, data }) - }, [dispatch, tabId, paneId, ws]) + }, [dispatch, enqueueTerminalWrite, handleOsc52Event, sendInput, tabId]) const findNext = useCallback((value: string = searchQuery) => { const terminalId = terminalIdRef.current @@ -1029,6 +1123,7 @@ export default function TerminalView({ tabId, paneId, paneContent, hidden }: Ter } const resolvedTheme = getTerminalTheme(settings.terminal.theme, settings.theme) + resolvedThemeRef.current = resolvedTheme const term = new Terminal({ allowProposedApi: true, convertEol: true, @@ -1462,6 +1557,9 @@ export default function TerminalView({ tabId, paneId, paneContent, hidden }: Ter const deltaSeq = Math.max(seqStateRef.current.lastSeq, persistedSeq) const sinceSeq = intent === 'viewport_hydrate' ? 0 : deltaSeq + // Startup probes must not leak across attach generations. + resetStartupProbeParser() + if (intent === 'viewport_hydrate') { if (opts?.clearViewportFirst) { try { @@ -1506,7 +1604,7 @@ export default function TerminalView({ tabId, paneId, paneContent, hidden }: Ter }) rememberSentViewport(tid, cols, rows) lastSentViewportRef.current = { terminalId: tid, cols, rows } - }, [suppressNetworkEffects, ws, applySeqState]) + }, [suppressNetworkEffects, ws, applySeqState, resetStartupProbeParser]) const runRefreshAttach = useCallback((request: PaneRefreshRequest | null | undefined) => { if (suppressNetworkEffects) return false @@ -1543,6 +1641,7 @@ export default function TerminalView({ tabId, paneId, paneContent, hidden }: Ter const term = termRef.current if (!term) return const resolvedTheme = getTerminalTheme(settings.terminal.theme, settings.theme) + resolvedThemeRef.current = resolvedTheme term.options.cursorBlink = settings.terminal.cursorBlink term.options.fontSize = settings.terminal.fontSize term.options.fontFamily = resolveTerminalFontFamily(settings.terminal.fontFamily) @@ -1603,6 +1702,7 @@ export default function TerminalView({ tabId, paneId, paneContent, hidden }: Ter if (!termCandidate) return const term = termCandidate turnCompleteSignalStateRef.current = createTurnCompleteSignalParserState() + resetStartupProbeParser() osc52ParserRef.current = createOsc52ParserState() osc52QueueRef.current = [] pendingOsc52EventRef.current = null @@ -1760,9 +1860,24 @@ export default function TerminalView({ tabId, paneId, paneContent, hidden }: Ter if (tid && frameDecision.freshReset) { clearTerminalCursor(tid) } - const raw = msg.data || '' + let raw = msg.data || '' const mode = contentRef.current?.mode || 'shell' - handleTerminalOutput(raw, mode, tid) + const frameOverlapsReplay = Boolean( + previousSeqState.pendingReplay + && msg.seqEnd >= previousSeqState.pendingReplay.fromSeq + && msg.seqStart <= previousSeqState.pendingReplay.toSeq, + ) + const enteringFreshLiveOutput = !frameOverlapsReplay + && (Boolean(previousSeqState.pendingReplay) || previousSeqState.awaitingFreshSequence) + if ( + enteringFreshLiveOutput + && !startupProbeReplayDiscardStateRef.current.remainder + && !startupProbeReplayDiscardStateRef.current.buffered + ) { + resetStartupProbeParser({ discardReplayRemainder: Boolean(previousSeqState.pendingReplay) }) + } + raw = consumeStartupProbeReplayDiscard(raw, startupProbeReplayDiscardStateRef.current) + handleTerminalOutput(raw, mode, tid, !frameOverlapsReplay) if ( raw.length > 0 && !terminalFirstOutputMarkedRef.current @@ -1781,6 +1896,9 @@ export default function TerminalView({ tabId, paneId, paneContent, hidden }: Ter const completedAttachOnFrame = !frameDecision.state.pendingReplay && (Boolean(previousSeqState.pendingReplay) || previousSeqState.awaitingFreshSequence) if (completedAttachOnFrame) { + if (frameOverlapsReplay) { + resetStartupProbeParser({ discardReplayRemainder: true }) + } setIsAttaching(false) markAttachComplete() } @@ -1822,6 +1940,7 @@ export default function TerminalView({ tabId, paneId, paneContent, hidden }: Ter const completedAttachOnGap = !nextSeqState.pendingReplay && (Boolean(previousSeqState.pendingReplay) || previousSeqState.awaitingFreshSequence) if (completedAttachOnGap) { + resetStartupProbeParser({ discardReplayRemainder: Boolean(previousSeqState.pendingReplay) }) setIsAttaching(false) markAttachComplete() } @@ -2213,6 +2332,7 @@ export default function TerminalView({ tabId, paneId, paneContent, hidden }: Ter handleTerminalOutput, attachTerminal, markAttachComplete, + resetStartupProbeParser, runRefreshAttach, ]) diff --git a/src/components/context-menu/ContextMenuProvider.tsx b/src/components/context-menu/ContextMenuProvider.tsx index 447cf49b..128bc47d 100644 --- a/src/components/context-menu/ContextMenuProvider.tsx +++ b/src/components/context-menu/ContextMenuProvider.tsx @@ -392,10 +392,6 @@ export function ContextMenuProvider({ const mode = (provider || session.provider || 'claude') as CodingCliProviderName const sessionType = (target?.kind === 'sidebar-session' ? target.sessionType : undefined) || session.sessionType || mode - const runningTerminalId = - target?.kind === 'sidebar-session' && target.sessionId === sessionId - ? target.runningTerminalId - : undefined const agentConfig = getAgentChatProviderConfig(sessionType) const providerSettings = agentConfig ? appSettings.agentChat?.providers?.[agentConfig.name] diff --git a/src/lib/terminal-startup-probes.ts b/src/lib/terminal-startup-probes.ts new file mode 100644 index 00000000..2845adf3 --- /dev/null +++ b/src/lib/terminal-startup-probes.ts @@ -0,0 +1,148 @@ +const ESC = '\u001b' +const BEL = '\u0007' +const C1_ST = '\u009c' + +export type TerminalStartupProbeState = { + pending: string + armed: boolean +} + +export type TerminalStartupProbeColors = { + foreground?: string + background?: string + cursor?: string +} + +export type TerminalStartupProbeResult = { + cleaned: string + replies: string[] +} + +type StringSequenceTerminator = { + start: number + end: number + terminator: string +} + +export function createTerminalStartupProbeState(): TerminalStartupProbeState { + return { pending: '', armed: true } +} + +function findStringSequenceTerminator(data: string, from: number): StringSequenceTerminator | null { + for (let i = from; i < data.length; i += 1) { + const ch = data[i] + if (ch === BEL || ch === C1_ST) { + return { start: i, end: i + 1, terminator: ch } + } + if (ch === ESC) { + if (i + 1 >= data.length) return null + if (data[i + 1] === '\\') { + return { start: i, end: i + 2, terminator: `${ESC}\\` } + } + } + } + + return null +} + +function normalizeHexColor(color: string): [number, number, number] | null { + if (!color.startsWith('#')) return null + const hex = color.slice(1) + + if (hex.length === 3) { + const [r, g, b] = hex.split('') + if (!r || !g || !b) return null + return [ + parseInt(`${r}${r}`, 16), + parseInt(`${g}${g}`, 16), + parseInt(`${b}${b}`, 16), + ] + } + + if (hex.length !== 6) return null + + return [ + parseInt(hex.slice(0, 2), 16), + parseInt(hex.slice(2, 4), 16), + parseInt(hex.slice(4, 6), 16), + ] +} + +function pad16Bit(value: number): string { + const hex = value.toString(16).padStart(2, '0') + return `${hex}${hex}` +} + +function buildOsc11BackgroundReply(color: string | undefined): string | null { + if (!color) return null + const rgb = normalizeHexColor(color) + if (!rgb) return null + + const [r, g, b] = rgb + return `${ESC}]11;rgb:${pad16Bit(r)}/${pad16Bit(g)}/${pad16Bit(b)}${ESC}\\` +} + +export function extractTerminalStartupProbes( + chunk: string, + state: TerminalStartupProbeState, + colors: TerminalStartupProbeColors, +): TerminalStartupProbeResult { + const parserState = state ?? createTerminalStartupProbeState() + const input = `${parserState.pending}${chunk}` + const replies: string[] = [] + let cleaned = '' + let i = 0 + let armed = parserState.armed + parserState.pending = '' + + while (i < input.length) { + const ch = input[i] + if (ch !== ESC) { + armed = false + cleaned += ch + i += 1 + continue + } + + if (i + 1 >= input.length) { + parserState.pending = input.slice(i) + break + } + + const introducer = input[i + 1] + if (introducer !== ']' && introducer !== 'P' && introducer !== '_') { + armed = false + cleaned += ch + i += 1 + continue + } + + const terminator = findStringSequenceTerminator(input, i + 2) + if (!terminator) { + parserState.pending = input.slice(i) + break + } + + const sequence = input.slice(i, terminator.end) + const content = input.slice(i + 2, terminator.start) + + if (armed && i === 0 && introducer === ']' && content === '11;?' && terminator.terminator === BEL) { + const reply = buildOsc11BackgroundReply(colors.background) + if (reply) { + replies.push(reply) + } else { + cleaned += sequence + } + armed = false + } else { + cleaned += sequence + armed = false + } + + i = terminator.end + } + + parserState.armed = armed + + return { cleaned, replies } +} diff --git a/src/store/persistMiddleware.ts b/src/store/persistMiddleware.ts index a803aff0..255144fb 100644 --- a/src/store/persistMiddleware.ts +++ b/src/store/persistMiddleware.ts @@ -5,8 +5,8 @@ import type { Tab } from './types' import { nanoid } from 'nanoid' import { broadcastPersistedRaw } from './persistBroadcast' import { isWellFormedPaneTree } from './paneTreeValidation.js' -import { PANES_SCHEMA_VERSION, LAYOUT_SCHEMA_VERSION, parsePersistedLayoutRaw, parsePersistedTabsRaw, parsePersistedPanesRaw } from './persistedState.js' -import { LAYOUT_STORAGE_KEY, PANES_STORAGE_KEY, TABS_STORAGE_KEY } from './storage-keys' +import { PANES_SCHEMA_VERSION, LAYOUT_SCHEMA_VERSION, parsePersistedLayoutRaw } from './persistedState.js' +import { LAYOUT_STORAGE_KEY, PANES_STORAGE_KEY } from './storage-keys' import { createLogger } from '@/lib/client-logger' diff --git a/test/e2e/directory-picker-flow.test.tsx b/test/e2e/directory-picker-flow.test.tsx index 8be3c6d5..bbe3aba1 100644 --- a/test/e2e/directory-picker-flow.test.tsx +++ b/test/e2e/directory-picker-flow.test.tsx @@ -30,6 +30,11 @@ const defaultCliExtensions: ClientExtensionEntry[] = [ picker: { shortcut: 'X' }, cli: { supportsModel: true, supportsSandbox: true, supportsResume: true, resumeCommandTemplate: ['codex', 'resume', '{{sessionId}}'] }, }, + { + name: 'opencode', version: '1.0.0', label: 'OpenCode', description: '', category: 'cli', + picker: { shortcut: 'O' }, + cli: { supportsModel: true, supportsPermissionMode: true, supportsResume: true, resumeCommandTemplate: ['opencode', '--session', '{{sessionId}}'] }, + }, ] const { mockApiGet, mockApiPost, mockApiPatch, saveServerSettingsPatchSpy } = vi.hoisted(() => ({ @@ -84,7 +89,11 @@ function createSettingsState(options: { } } -function renderPickerFlow() { +function renderPickerFlow(options: { + availableClis?: Record + enabledProviders?: string[] + providerCwds?: Record +} = {}) { const node: PaneNode = { type: 'leaf', id: 'pane-1', @@ -115,7 +124,7 @@ function renderPickerFlow() { connection: { status: 'ready' as const, platform: 'linux', - availableClis: { claude: true }, + availableClis: options.availableClis ?? { claude: true }, }, settings: createSettingsState({ server: { @@ -123,8 +132,8 @@ function renderPickerFlow() { safety: { autoKillIdleMinutes: 180 }, panes: { defaultNewPane: 'ask' }, codingCli: { - enabledProviders: ['claude'], - providers: { claude: { cwd: '/home/user/work' } }, + enabledProviders: options.enabledProviders ?? ['claude'], + providers: options.providerCwds ?? { claude: { cwd: '/home/user/work' } }, }, logging: { debug: false }, }, @@ -296,6 +305,40 @@ describe('directory picker flow (e2e)', () => { }) }) + it('launches OpenCode terminal with confirmed directory', async () => { + const { store } = renderPickerFlow({ + availableClis: { opencode: true }, + enabledProviders: ['opencode'], + providerCwds: { opencode: { cwd: '/home/user/work' } }, + }) + + fireEvent.click(screen.getByRole('button', { name: 'OpenCode' })) + const picker = document.querySelector('[data-context="pane-picker"]') + if (!picker) throw new Error('Pane picker not found') + fireEvent.transitionEnd(picker) + + const input = screen.getByLabelText('Starting directory for OpenCode') + fireEvent.change(input, { target: { value: '/home/user/next' } }) + fireEvent.keyDown(input, { key: 'Enter' }) + + await waitFor(() => { + const content = (store.getState().panes.layouts['tab-1'] as Extract).content + expect(content.kind).toBe('terminal') + if (content.kind === 'terminal') { + expect(content.mode).toBe('opencode') + expect(content.initialCwd).toBe('/home/user/next') + } + }) + + expect(saveServerSettingsPatchSpy).toHaveBeenCalledWith({ + codingCli: { + providers: { + opencode: expect.objectContaining({ cwd: '/home/user/next' }), + }, + }, + }) + }) + it('enters path mode for quoted Windows drive input and requests directory completions', async () => { mockApiGet.mockImplementation(async (requestPath: string) => { if (requestPath.startsWith('/api/files/complete')) { diff --git a/test/e2e/opencode-startup-probes.test.tsx b/test/e2e/opencode-startup-probes.test.tsx new file mode 100644 index 00000000..1c8c9121 --- /dev/null +++ b/test/e2e/opencode-startup-probes.test.tsx @@ -0,0 +1,988 @@ +import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest' +import { cleanup, render, waitFor } from '@testing-library/react' +import { Provider } from 'react-redux' +import { configureStore } from '@reduxjs/toolkit' + +import TerminalView from '@/components/TerminalView' +import connectionReducer from '@/store/connectionSlice' +import panesReducer from '@/store/panesSlice' +import settingsReducer, { defaultSettings } from '@/store/settingsSlice' +import tabsReducer from '@/store/tabsSlice' +import turnCompletionReducer from '@/store/turnCompletionSlice' +import type { PaneNode, TerminalPaneContent } from '@/store/paneTypes' +import { + OPEN_CODE_STARTUP_EXPECTED_CLEANED, + OPEN_CODE_STARTUP_EXPECTED_REPLIES, + OPEN_CODE_STARTUP_POST_REPLY_FRAMES, + OPEN_CODE_STARTUP_PROBE_FRAME, + OPEN_CODE_STARTUP_PROBE_SPLIT_FRAMES, +} from '@test/helpers/opencode-startup-probes' + +const terminalTheme = { + foreground: '#aabbcc', + background: '#112233', + cursor: '#ddeeff', +} + +const ioEvents: Array<{ kind: 'send' | 'write', type?: string, data: string }> = [] + +const wsHarness = vi.hoisted(() => { + const messageHandlers = new Set<(msg: any) => void>() + const reconnectHandlers = new Set<() => void>() + const latestAttachRequestIdByTerminal = new Map() + + const withCurrentAttachRequestId = (msg: any) => { + if ( + msg?.attachRequestId + || typeof msg?.terminalId !== 'string' + || (msg?.type !== 'terminal.attach.ready' && msg?.type !== 'terminal.output' && msg?.type !== 'terminal.output.gap') + ) { + return msg + } + const attachRequestId = latestAttachRequestIdByTerminal.get(msg.terminalId) + return attachRequestId ? { ...msg, attachRequestId } : msg + } + + return { + send: vi.fn(), + connect: vi.fn().mockResolvedValue(undefined), + onMessage: vi.fn((handler: (msg: any) => void) => { + messageHandlers.add(handler) + return () => messageHandlers.delete(handler) + }), + onReconnect: vi.fn((handler: () => void) => { + reconnectHandlers.add(handler) + return () => reconnectHandlers.delete(handler) + }), + emit(msg: any) { + const normalized = withCurrentAttachRequestId(msg) + for (const handler of messageHandlers) handler(normalized) + }, + rememberAttach(msg: any) { + if ( + msg?.type === 'terminal.attach' + && typeof msg?.terminalId === 'string' + && typeof msg?.attachRequestId === 'string' + ) { + latestAttachRequestIdByTerminal.set(msg.terminalId, msg.attachRequestId) + } + }, + reset() { + messageHandlers.clear() + reconnectHandlers.clear() + latestAttachRequestIdByTerminal.clear() + }, + } +}) + +vi.mock('@/lib/ws-client', () => ({ + getWsClient: () => ({ + send: wsHarness.send, + connect: wsHarness.connect, + onMessage: wsHarness.onMessage, + onReconnect: wsHarness.onReconnect, + }), +})) + +vi.mock('@/lib/terminal-themes', () => ({ + getTerminalTheme: () => terminalTheme, +})) + +vi.mock('@/components/terminal/terminal-runtime', () => ({ + createTerminalRuntime: () => ({ + attachAddons: vi.fn(), + fit: vi.fn(), + findNext: vi.fn(() => false), + findPrevious: vi.fn(() => false), + clearDecorations: vi.fn(), + onDidChangeResults: vi.fn(() => ({ dispose: vi.fn() })), + dispose: vi.fn(), + webglActive: vi.fn(() => false), + }), +})) + +const terminalInstances: Array<{ + write: ReturnType +}> = [] + +vi.mock('@xterm/xterm', () => { + class MockTerminal { + options: Record = {} + cols = 80 + rows = 24 + open = vi.fn() + registerLinkProvider = vi.fn(() => ({ dispose: vi.fn() })) + onData = vi.fn(() => ({ dispose: vi.fn() })) + onTitleChange = vi.fn(() => ({ dispose: vi.fn() })) + attachCustomKeyEventHandler = vi.fn() + dispose = vi.fn() + focus = vi.fn() + getSelection = vi.fn(() => '') + clear = vi.fn() + writeln = vi.fn() + write = vi.fn((data: string, cb?: () => void) => { + ioEvents.push({ kind: 'write', data: String(data) }) + cb?.() + return data.length + }) + + constructor() { + terminalInstances.push(this as unknown as { write: ReturnType }) + } + } + + return { Terminal: MockTerminal } +}) + +vi.mock('@xterm/xterm/css/xterm.css', () => ({})) + +class MockResizeObserver { + observe = vi.fn() + disconnect = vi.fn() + unobserve = vi.fn() +} + +function createStore(options: { + requestId: string + terminalId?: string + status?: 'creating' | 'running' +}) { + const terminalId = options.terminalId + const status = options.status ?? (terminalId ? 'running' : 'creating') + const paneContent: TerminalPaneContent = { + kind: 'terminal', + createRequestId: options.requestId, + status, + mode: 'opencode', + shell: 'system', + ...(terminalId ? { terminalId } : {}), + } + + const stableId = terminalId ?? options.requestId + const layout: PaneNode = { type: 'leaf', id: `pane-${stableId}`, content: paneContent } + + return configureStore({ + reducer: { + tabs: tabsReducer, + panes: panesReducer, + settings: settingsReducer, + connection: connectionReducer, + turnCompletion: turnCompletionReducer, + }, + preloadedState: { + tabs: { + tabs: [{ + id: `tab-${stableId}`, + mode: 'opencode', + status, + title: 'OpenCode', + createRequestId: options.requestId, + ...(terminalId ? { terminalId } : {}), + }], + activeTabId: `tab-${stableId}`, + }, + panes: { + layouts: { [`tab-${stableId}`]: layout }, + activePane: { [`tab-${stableId}`]: `pane-${stableId}` }, + paneTitles: {}, + }, + settings: { settings: defaultSettings, status: 'loaded' }, + connection: { status: 'ready', error: null }, + turnCompletion: { seq: 0, lastEvent: null, pendingEvents: [], attentionByTab: {}, attentionByPane: {} }, + } as any, + }) +} + +function sentMessages() { + return wsHarness.send.mock.calls.map(([msg]) => msg) +} + +function lastSent(type: string, terminalId?: string) { + return sentMessages().reverse().find((msg) => { + if (msg?.type !== type) return false + if (terminalId && msg?.terminalId !== terminalId) return false + return true + }) +} + +function writeEvents() { + return ioEvents.filter((event) => event.kind === 'write') +} + +function postReplySeqRange(index: number, afterProbeSeqEnd: number) { + if (index === 0) { + return { + seqStart: afterProbeSeqEnd + 1, + seqEnd: afterProbeSeqEnd + 3, + } + } + + const seq = afterProbeSeqEnd + 3 + index + return { seqStart: seq, seqEnd: seq } +} + +function emitCapturedPostReplyFrames( + terminalId: string, + attachRequestId: string, + afterProbeSeqEnd: number, + opts?: { + prependFirstFrame?: string + }, +) { + OPEN_CODE_STARTUP_POST_REPLY_FRAMES.forEach((frame, index) => { + const range = postReplySeqRange(index, afterProbeSeqEnd) + wsHarness.emit({ + type: 'terminal.output', + terminalId, + seqStart: range.seqStart, + seqEnd: range.seqEnd, + data: `${index === 0 ? opts?.prependFirstFrame ?? '' : ''}${frame}`, + attachRequestId, + }) + }) +} + +async function renderCreatedTerminal(terminalId: string) { + const requestId = `req-${terminalId}` + const store = createStore({ requestId }) + const stableId = requestId + + render( + + , + ) + + await waitFor(() => { + expect(lastSent('terminal.create')).toMatchObject({ + type: 'terminal.create', + requestId, + mode: 'opencode', + }) + }) + + wsHarness.send.mockClear() + + wsHarness.emit({ + type: 'terminal.created', + requestId, + terminalId, + createdAt: Date.now(), + }) + + await waitFor(() => { + expect(lastSent('terminal.attach', terminalId)).toMatchObject({ + type: 'terminal.attach', + terminalId, + attachRequestId: expect.any(String), + }) + }) + + const attach = lastSent('terminal.attach', terminalId) + + return { + store, + attach, + terminalId, + } +} + +describe('opencode startup probes (e2e)', () => { + beforeEach(() => { + wsHarness.reset() + wsHarness.send.mockClear() + wsHarness.send.mockImplementation((msg: any) => { + if (msg?.type === 'terminal.input' && typeof msg?.data === 'string') { + ioEvents.push({ kind: 'send', type: msg.type, data: msg.data }) + } + wsHarness.rememberAttach(msg) + }) + wsHarness.connect.mockClear() + terminalInstances.length = 0 + ioEvents.length = 0 + vi.stubGlobal('ResizeObserver', MockResizeObserver) + vi.spyOn(window, 'requestAnimationFrame').mockImplementation((cb: FrameRequestCallback) => { + cb(0) + return 1 + }) + vi.spyOn(window, 'cancelAnimationFrame').mockImplementation(() => {}) + }) + + afterEach(() => { + cleanup() + vi.restoreAllMocks() + vi.unstubAllGlobals() + }) + + it('replies to live startup probes before writing the first captured post-reply output', async () => { + const terminalId = 'term-opencode-live' + const { attach } = await renderCreatedTerminal(terminalId) + wsHarness.emit({ + type: 'terminal.attach.ready', + terminalId, + headSeq: 0, + replayFromSeq: 1, + replayToSeq: 0, + attachRequestId: attach.attachRequestId, + }) + + wsHarness.send.mockClear() + ioEvents.length = 0 + + wsHarness.emit({ + type: 'terminal.output', + terminalId, + seqStart: 1, + seqEnd: 1, + data: OPEN_CODE_STARTUP_PROBE_FRAME, + attachRequestId: attach.attachRequestId, + }) + + expect(terminalInstances[0]!.write).not.toHaveBeenCalled() + + expect(sentMessages().filter((msg) => msg?.type === 'terminal.input')).toEqual( + OPEN_CODE_STARTUP_EXPECTED_REPLIES.map((data) => ({ + type: 'terminal.input', + terminalId, + data, + })), + ) + expect(ioEvents).toEqual([ + ...OPEN_CODE_STARTUP_EXPECTED_REPLIES.map((data) => ({ kind: 'send' as const, type: 'terminal.input', data })), + ]) + + emitCapturedPostReplyFrames(terminalId, attach.attachRequestId, 1) + + await waitFor(() => { + expect(writeEvents().map((event) => event.data).join('')).toBe(OPEN_CODE_STARTUP_EXPECTED_CLEANED) + }) + + const inputMessages = sentMessages().filter((msg) => msg?.type === 'terminal.input') + expect(inputMessages).toEqual( + OPEN_CODE_STARTUP_EXPECTED_REPLIES.map((data) => ({ + type: 'terminal.input', + terminalId, + data, + })), + ) + expect(ioEvents).toEqual([ + ...OPEN_CODE_STARTUP_EXPECTED_REPLIES.map((data) => ({ kind: 'send' as const, type: 'terminal.input', data })), + ...OPEN_CODE_STARTUP_POST_REPLY_FRAMES.map((data) => ({ kind: 'write' as const, data })), + ]) + }) + + it('passes later standalone OSC 11 queries through unchanged after startup completes', async () => { + const terminalId = 'term-opencode-runtime-osc11' + const { attach } = await renderCreatedTerminal(terminalId) + wsHarness.emit({ + type: 'terminal.attach.ready', + terminalId, + headSeq: 0, + replayFromSeq: 1, + replayToSeq: 0, + attachRequestId: attach.attachRequestId, + }) + + wsHarness.send.mockClear() + ioEvents.length = 0 + + wsHarness.emit({ + type: 'terminal.output', + terminalId, + seqStart: 1, + seqEnd: 1, + data: OPEN_CODE_STARTUP_PROBE_FRAME, + attachRequestId: attach.attachRequestId, + }) + emitCapturedPostReplyFrames(terminalId, attach.attachRequestId, 1) + + await waitFor(() => { + expect(writeEvents().map((event) => event.data).join('')).toBe(OPEN_CODE_STARTUP_EXPECTED_CLEANED) + }) + + wsHarness.emit({ + type: 'terminal.output', + terminalId, + seqStart: 5, + seqEnd: 5, + data: OPEN_CODE_STARTUP_PROBE_FRAME, + attachRequestId: attach.attachRequestId, + }) + + await waitFor(() => { + expect(writeEvents().map((event) => event.data)).toEqual([ + ...OPEN_CODE_STARTUP_POST_REPLY_FRAMES, + OPEN_CODE_STARTUP_PROBE_FRAME, + ]) + }) + + expect(sentMessages().filter((msg) => msg?.type === 'terminal.input')).toEqual( + OPEN_CODE_STARTUP_EXPECTED_REPLIES.map((data) => ({ + type: 'terminal.input', + terminalId, + data, + })), + ) + expect(ioEvents).toEqual([ + ...OPEN_CODE_STARTUP_EXPECTED_REPLIES.map((data) => ({ kind: 'send' as const, type: 'terminal.input', data })), + ...OPEN_CODE_STARTUP_POST_REPLY_FRAMES.map((data) => ({ kind: 'write' as const, data })), + { kind: 'write' as const, data: OPEN_CODE_STARTUP_PROBE_FRAME }, + ]) + }) + + it('strips historical startup probes during replay without sending late replies', async () => { + const terminalId = 'term-opencode-replay' + const { attach } = await renderCreatedTerminal(terminalId) + wsHarness.emit({ + type: 'terminal.attach.ready', + terminalId, + headSeq: 4, + replayFromSeq: 1, + replayToSeq: 4, + attachRequestId: attach.attachRequestId, + }) + + wsHarness.send.mockClear() + ioEvents.length = 0 + + wsHarness.emit({ + type: 'terminal.output', + terminalId, + seqStart: 1, + seqEnd: 1, + data: OPEN_CODE_STARTUP_PROBE_FRAME, + attachRequestId: attach.attachRequestId, + }) + emitCapturedPostReplyFrames(terminalId, attach.attachRequestId, 1) + wsHarness.emit({ + type: 'terminal.output', + terminalId, + seqStart: 5, + seqEnd: 5, + data: 'live tail', + attachRequestId: attach.attachRequestId, + }) + + await waitFor(() => { + expect(terminalInstances[0]!.write).toHaveBeenCalled() + }) + + expect(sentMessages().filter((msg) => msg?.type === 'terminal.input')).toEqual([]) + expect(ioEvents).toEqual([ + ...OPEN_CODE_STARTUP_POST_REPLY_FRAMES.map((data) => ({ kind: 'write' as const, data })), + { kind: 'write', data: 'live tail' }, + ]) + }) + + it('does not complete a replay-fragment startup probe from the first live frame', async () => { + const terminalId = 'term-opencode-replay-live-boundary' + const [firstSplitFrame, secondSplitFrame] = OPEN_CODE_STARTUP_PROBE_SPLIT_FRAMES + const { attach } = await renderCreatedTerminal(terminalId) + wsHarness.emit({ + type: 'terminal.attach.ready', + terminalId, + headSeq: 1, + replayFromSeq: 1, + replayToSeq: 1, + attachRequestId: attach.attachRequestId, + }) + + wsHarness.send.mockClear() + ioEvents.length = 0 + + wsHarness.emit({ + type: 'terminal.output', + terminalId, + seqStart: 1, + seqEnd: 1, + data: firstSplitFrame, + attachRequestId: attach.attachRequestId, + }) + + expect(sentMessages().filter((msg) => msg?.type === 'terminal.input')).toEqual([]) + expect(ioEvents).toEqual([]) + + wsHarness.emit({ + type: 'terminal.output', + terminalId, + seqStart: 2, + seqEnd: 4, + data: `${secondSplitFrame}${OPEN_CODE_STARTUP_POST_REPLY_FRAMES[0] ?? ''}`, + attachRequestId: attach.attachRequestId, + }) + + await waitFor(() => { + expect(terminalInstances[0]!.write).toHaveBeenCalled() + }) + + expect(sentMessages().filter((msg) => msg?.type === 'terminal.input')).toEqual([]) + expect(ioEvents).toHaveLength(1) + expect(ioEvents[0]).toEqual({ + kind: 'write', + data: OPEN_CODE_STARTUP_EXPECTED_CLEANED, + }) + }) + + it('discards replay fragments that end before the final startup-probe bytes', async () => { + const terminalId = 'term-opencode-replay-early-fragment' + const { attach } = await renderCreatedTerminal(terminalId) + const replayFragment = OPEN_CODE_STARTUP_PROBE_FRAME.slice(0, -2) + const liveRemainder = OPEN_CODE_STARTUP_PROBE_FRAME.slice(replayFragment.length) + + wsHarness.emit({ + type: 'terminal.attach.ready', + terminalId, + headSeq: 1, + replayFromSeq: 1, + replayToSeq: 1, + attachRequestId: attach.attachRequestId, + }) + + wsHarness.send.mockClear() + ioEvents.length = 0 + + wsHarness.emit({ + type: 'terminal.output', + terminalId, + seqStart: 1, + seqEnd: 1, + data: replayFragment, + attachRequestId: attach.attachRequestId, + }) + + expect(sentMessages().filter((msg) => msg?.type === 'terminal.input')).toEqual([]) + expect(ioEvents).toEqual([]) + + wsHarness.emit({ + type: 'terminal.output', + terminalId, + seqStart: 2, + seqEnd: 4, + data: `${liveRemainder}${OPEN_CODE_STARTUP_POST_REPLY_FRAMES[0] ?? ''}`, + attachRequestId: attach.attachRequestId, + }) + + await waitFor(() => { + expect(terminalInstances[0]!.write).toHaveBeenCalled() + }) + + expect(sentMessages().filter((msg) => msg?.type === 'terminal.input')).toEqual([]) + expect(ioEvents).toEqual([ + { kind: 'write', data: OPEN_CODE_STARTUP_EXPECTED_CLEANED }, + ]) + }) + + it('discards replay fragments when replay completion arrives via terminal.output.gap', async () => { + const terminalId = 'term-opencode-replay-gap-fragment' + const { attach } = await renderCreatedTerminal(terminalId) + const replayFragment = OPEN_CODE_STARTUP_PROBE_FRAME.slice(0, -2) + const liveRemainder = OPEN_CODE_STARTUP_PROBE_FRAME.slice(replayFragment.length) + + wsHarness.emit({ + type: 'terminal.attach.ready', + terminalId, + headSeq: 2, + replayFromSeq: 1, + replayToSeq: 2, + attachRequestId: attach.attachRequestId, + }) + + wsHarness.send.mockClear() + ioEvents.length = 0 + + wsHarness.emit({ + type: 'terminal.output', + terminalId, + seqStart: 1, + seqEnd: 1, + data: replayFragment, + attachRequestId: attach.attachRequestId, + }) + + wsHarness.emit({ + type: 'terminal.output.gap', + terminalId, + fromSeq: 2, + toSeq: 2, + reason: 'replay_budget_exceeded', + attachRequestId: attach.attachRequestId, + }) + + wsHarness.emit({ + type: 'terminal.output', + terminalId, + seqStart: 3, + seqEnd: 5, + data: `${liveRemainder}${OPEN_CODE_STARTUP_POST_REPLY_FRAMES[0] ?? ''}`, + attachRequestId: attach.attachRequestId, + }) + + await waitFor(() => { + expect(terminalInstances[0]!.write).toHaveBeenCalled() + }) + + expect(sentMessages().filter((msg) => msg?.type === 'terminal.input')).toEqual([]) + expect(ioEvents).toEqual([ + { kind: 'write', data: OPEN_CODE_STARTUP_EXPECTED_CLEANED }, + ]) + }) + + it('does not trim unrelated live bytes that only share a stale replay-suffix prefix', async () => { + const terminalId = 'term-opencode-replay-gap-prefix-match' + const { attach } = await renderCreatedTerminal(terminalId) + const replayFragment = OPEN_CODE_STARTUP_PROBE_FRAME.slice(0, 2) + + wsHarness.emit({ + type: 'terminal.attach.ready', + terminalId, + headSeq: 2, + replayFromSeq: 1, + replayToSeq: 2, + attachRequestId: attach.attachRequestId, + }) + + wsHarness.send.mockClear() + ioEvents.length = 0 + + wsHarness.emit({ + type: 'terminal.output', + terminalId, + seqStart: 1, + seqEnd: 1, + data: replayFragment, + attachRequestId: attach.attachRequestId, + }) + + wsHarness.emit({ + type: 'terminal.output.gap', + terminalId, + fromSeq: 2, + toSeq: 2, + reason: 'replay_budget_exceeded', + attachRequestId: attach.attachRequestId, + }) + + wsHarness.emit({ + type: 'terminal.output', + terminalId, + seqStart: 3, + seqEnd: 3, + data: '1hello', + attachRequestId: attach.attachRequestId, + }) + + await waitFor(() => { + expect(terminalInstances[0]!.write).toHaveBeenCalled() + }) + + expect(sentMessages().filter((msg) => msg?.type === 'terminal.input')).toEqual([]) + expect(ioEvents).toEqual([ + { kind: 'write', data: '1hello' }, + ]) + }) + + it('discards a stale startup-probe remainder even when it completes across two live frames', async () => { + const terminalId = 'term-opencode-replay-gap-split-stale-remainder' + const { attach } = await renderCreatedTerminal(terminalId) + const replayFragment = OPEN_CODE_STARTUP_PROBE_FRAME.slice(0, -2) + const [firstLiveFrame, secondLiveFrame] = OPEN_CODE_STARTUP_PROBE_FRAME.slice(replayFragment.length).split('') + + wsHarness.emit({ + type: 'terminal.attach.ready', + terminalId, + headSeq: 2, + replayFromSeq: 1, + replayToSeq: 2, + attachRequestId: attach.attachRequestId, + }) + + wsHarness.send.mockClear() + ioEvents.length = 0 + + wsHarness.emit({ + type: 'terminal.output', + terminalId, + seqStart: 1, + seqEnd: 1, + data: replayFragment, + attachRequestId: attach.attachRequestId, + }) + + wsHarness.emit({ + type: 'terminal.output.gap', + terminalId, + fromSeq: 2, + toSeq: 2, + reason: 'replay_budget_exceeded', + attachRequestId: attach.attachRequestId, + }) + + wsHarness.emit({ + type: 'terminal.output', + terminalId, + seqStart: 3, + seqEnd: 3, + data: firstLiveFrame ?? '', + attachRequestId: attach.attachRequestId, + }) + + expect(sentMessages().filter((msg) => msg?.type === 'terminal.input')).toEqual([]) + expect(ioEvents).toEqual([]) + + wsHarness.emit({ + type: 'terminal.output', + terminalId, + seqStart: 4, + seqEnd: 4, + data: `${secondLiveFrame ?? ''}hello`, + attachRequestId: attach.attachRequestId, + }) + + await waitFor(() => { + expect(writeEvents()).toEqual([ + { kind: 'write', data: 'hello' }, + ]) + }) + + expect(sentMessages().filter((msg) => msg?.type === 'terminal.input')).toEqual([]) + }) + + it('restores buffered live bytes when a stale startup-probe remainder diverges on the next frame', async () => { + const terminalId = 'term-opencode-replay-gap-stale-remainder-mismatch' + const { attach } = await renderCreatedTerminal(terminalId) + const replayFragment = OPEN_CODE_STARTUP_PROBE_FRAME.slice(0, -2) + const [firstLiveFrame] = OPEN_CODE_STARTUP_PROBE_FRAME.slice(replayFragment.length).split('') + + wsHarness.emit({ + type: 'terminal.attach.ready', + terminalId, + headSeq: 2, + replayFromSeq: 1, + replayToSeq: 2, + attachRequestId: attach.attachRequestId, + }) + + wsHarness.send.mockClear() + ioEvents.length = 0 + + wsHarness.emit({ + type: 'terminal.output', + terminalId, + seqStart: 1, + seqEnd: 1, + data: replayFragment, + attachRequestId: attach.attachRequestId, + }) + + wsHarness.emit({ + type: 'terminal.output.gap', + terminalId, + fromSeq: 2, + toSeq: 2, + reason: 'replay_budget_exceeded', + attachRequestId: attach.attachRequestId, + }) + + wsHarness.emit({ + type: 'terminal.output', + terminalId, + seqStart: 3, + seqEnd: 3, + data: firstLiveFrame ?? '', + attachRequestId: attach.attachRequestId, + }) + + expect(sentMessages().filter((msg) => msg?.type === 'terminal.input')).toEqual([]) + expect(ioEvents).toEqual([]) + + wsHarness.emit({ + type: 'terminal.output', + terminalId, + seqStart: 4, + seqEnd: 4, + data: 'xhello', + attachRequestId: attach.attachRequestId, + }) + + await waitFor(() => { + expect(writeEvents()).toEqual([ + { kind: 'write', data: `${firstLiveFrame ?? ''}xhello` }, + ]) + }) + + expect(sentMessages().filter((msg) => msg?.type === 'terminal.input')).toEqual([]) + }) + + it('drops replay-carried non-startup OSC fragments at the replay boundary', async () => { + const terminalId = 'term-opencode-replay-gap-non-startup-osc' + const { attach } = await renderCreatedTerminal(terminalId) + const replayFragment = 'prefix\u001b]0;Window title' + + wsHarness.emit({ + type: 'terminal.attach.ready', + terminalId, + headSeq: 2, + replayFromSeq: 1, + replayToSeq: 2, + attachRequestId: attach.attachRequestId, + }) + + wsHarness.send.mockClear() + ioEvents.length = 0 + + wsHarness.emit({ + type: 'terminal.output', + terminalId, + seqStart: 1, + seqEnd: 1, + data: replayFragment, + attachRequestId: attach.attachRequestId, + }) + + expect(sentMessages().filter((msg) => msg?.type === 'terminal.input')).toEqual([]) + expect(ioEvents).toEqual([ + { kind: 'write', data: 'prefix' }, + ]) + + wsHarness.emit({ + type: 'terminal.output.gap', + terminalId, + fromSeq: 2, + toSeq: 2, + reason: 'replay_budget_exceeded', + attachRequestId: attach.attachRequestId, + }) + + wsHarness.emit({ + type: 'terminal.output', + terminalId, + seqStart: 3, + seqEnd: 3, + data: '\u0007after', + attachRequestId: attach.attachRequestId, + }) + + await waitFor(() => { + expect(writeEvents()).toEqual([ + { kind: 'write', data: 'prefix' }, + { kind: 'write', data: '\u0007after' }, + ]) + }) + + expect(sentMessages().filter((msg) => msg?.type === 'terminal.input')).toEqual([]) + }) + + it('buffers a split live startup probe and replies exactly once when it completes', async () => { + const terminalId = 'term-opencode-split-live' + const [firstSplitFrame, secondSplitFrame] = OPEN_CODE_STARTUP_PROBE_SPLIT_FRAMES + const { attach } = await renderCreatedTerminal(terminalId) + wsHarness.emit({ + type: 'terminal.attach.ready', + terminalId, + headSeq: 0, + replayFromSeq: 1, + replayToSeq: 0, + attachRequestId: attach.attachRequestId, + }) + + wsHarness.send.mockClear() + ioEvents.length = 0 + + wsHarness.emit({ + type: 'terminal.output', + terminalId, + seqStart: 1, + seqEnd: 1, + data: firstSplitFrame, + attachRequestId: attach.attachRequestId, + }) + + expect(sentMessages().filter((msg) => msg?.type === 'terminal.input')).toEqual([]) + expect(ioEvents).toEqual([]) + + wsHarness.emit({ + type: 'terminal.output', + terminalId, + seqStart: 2, + seqEnd: 4, + data: `${secondSplitFrame}${OPEN_CODE_STARTUP_POST_REPLY_FRAMES[0] ?? ''}`, + attachRequestId: attach.attachRequestId, + }) + + await waitFor(() => { + expect(terminalInstances[0]!.write).toHaveBeenCalled() + }) + + const inputMessages = sentMessages().filter((msg) => msg?.type === 'terminal.input') + expect(inputMessages).toEqual( + OPEN_CODE_STARTUP_EXPECTED_REPLIES.map((data) => ({ + type: 'terminal.input', + terminalId, + data, + })), + ) + expect(ioEvents).toEqual([ + ...OPEN_CODE_STARTUP_EXPECTED_REPLIES.map((data) => ({ kind: 'send' as const, type: 'terminal.input', data })), + { kind: 'write' as const, data: OPEN_CODE_STARTUP_POST_REPLY_FRAMES[0] ?? '' }, + ]) + }) + + it('answers a complete startup probe on the first accepted post-replay live frame', async () => { + const terminalId = 'term-opencode-first-live-after-replay' + const { attach } = await renderCreatedTerminal(terminalId) + wsHarness.emit({ + type: 'terminal.attach.ready', + terminalId, + headSeq: 4, + replayFromSeq: 1, + replayToSeq: 4, + attachRequestId: attach.attachRequestId, + }) + + wsHarness.send.mockClear() + ioEvents.length = 0 + + wsHarness.emit({ + type: 'terminal.output', + terminalId, + seqStart: 5, + seqEnd: 5, + data: OPEN_CODE_STARTUP_PROBE_FRAME, + attachRequestId: attach.attachRequestId, + }) + + expect(terminalInstances[0]!.write).not.toHaveBeenCalled() + + expect(sentMessages().filter((msg) => msg?.type === 'terminal.input')).toEqual( + OPEN_CODE_STARTUP_EXPECTED_REPLIES.map((data) => ({ + type: 'terminal.input', + terminalId, + data, + })), + ) + + emitCapturedPostReplyFrames(terminalId, attach.attachRequestId, 5) + + await waitFor(() => { + expect(writeEvents().map((event) => event.data).join('')).toBe(OPEN_CODE_STARTUP_EXPECTED_CLEANED) + }) + + const inputMessages = sentMessages().filter((msg) => msg?.type === 'terminal.input') + expect(inputMessages).toEqual( + OPEN_CODE_STARTUP_EXPECTED_REPLIES.map((data) => ({ + type: 'terminal.input', + terminalId, + data, + })), + ) + expect(ioEvents).toEqual([ + ...OPEN_CODE_STARTUP_EXPECTED_REPLIES.map((data) => ({ kind: 'send' as const, type: 'terminal.input', data })), + ...OPEN_CODE_STARTUP_POST_REPLY_FRAMES.map((data) => ({ kind: 'write' as const, data })), + ]) + }) +}) diff --git a/test/helpers/opencode-startup-probes.ts b/test/helpers/opencode-startup-probes.ts new file mode 100644 index 00000000..b29c9315 --- /dev/null +++ b/test/helpers/opencode-startup-probes.ts @@ -0,0 +1,14 @@ +// Captured on 2026-04-03 from a one-off Freshell websocket repro against +// `opencode` 1.3.13. The real startup contract begins with a standalone +// `terminal.output.data` frame containing the OSC 11 background-color query, +// followed by a later websocket frame carrying the first post-reply startup +// bytes. Split-boundary tests reuse the same captured probe bytes through this +// shared synthetic two-frame variant. +export const OPEN_CODE_STARTUP_PROBE_FRAME = '\u001b]11;?\u0007' +export const OPEN_CODE_STARTUP_PROBE_SPLIT_FRAMES = ['\u001b]11;?', '\u0007'] as const +export const OPEN_CODE_STARTUP_POST_REPLY_FRAMES = [ + '\u001b[>0q\u001b[?25l\u001b[s\u001b[?1016$p\u001b[?2027$p\u001b[?2031$p\u001b[?1004$p\u001b[?2004$p\u001b[?2026$p\u001b[?u\u001b[H\u001b]66;w=1; \u001b\\\u001b[6n\u001b[H\u001b]66;s=2; \u001b\\\u001b[6n\u001b[u\u001b[s\u001b[?1049h\u001b[>4;1m\u001b[?2027h\u001b[?2004h\u001b[?2031h\u001b[?996n\u001b[?1000h\u001b[?1002h\u001b[?1003h\u001b[?1006h\u001b[14t', +] as const +export const OPEN_CODE_STARTUP_POST_REPLY_OUTPUT = OPEN_CODE_STARTUP_POST_REPLY_FRAMES.join('') +export const OPEN_CODE_STARTUP_EXPECTED_REPLIES = ['\u001b]11;rgb:1111/2222/3333\u001b\\'] +export const OPEN_CODE_STARTUP_EXPECTED_CLEANED = OPEN_CODE_STARTUP_POST_REPLY_OUTPUT diff --git a/test/unit/client/components/TabsView.test.tsx b/test/unit/client/components/TabsView.test.tsx index 005ee4c2..be829785 100644 --- a/test/unit/client/components/TabsView.test.tsx +++ b/test/unit/client/components/TabsView.test.tsx @@ -105,7 +105,7 @@ describe('TabsView', () => { expect(screen.getByLabelText(/Expand Recently closed/i)).toBeInTheDocument() }) - it('renders tab cards as clickable articles with aria-labels', () => { + it('renders tab cards as native buttons with aria-labels', () => { const store = createStore() render( @@ -114,8 +114,8 @@ describe('TabsView', () => { ) const remoteCard = screen.getByLabelText('remote-device: remote open') - expect(remoteCard.tagName).toBe('ARTICLE') - expect(remoteCard).toHaveAttribute('role', 'button') + expect(remoteCard.tagName).toBe('BUTTON') + expect(remoteCard).toHaveAttribute('type', 'button') }) it('opens a copy when clicking a remote tab card', () => { diff --git a/test/unit/client/components/TerminalView.osc52.test.tsx b/test/unit/client/components/TerminalView.osc52.test.tsx index 9e151ecb..5f7d5d90 100644 --- a/test/unit/client/components/TerminalView.osc52.test.tsx +++ b/test/unit/client/components/TerminalView.osc52.test.tsx @@ -13,6 +13,12 @@ import { createDefaultServerSettings, resolveLocalSettings, } from '@shared/settings' +import { + OPEN_CODE_STARTUP_EXPECTED_CLEANED, + OPEN_CODE_STARTUP_EXPECTED_REPLIES, + OPEN_CODE_STARTUP_POST_REPLY_FRAMES, + OPEN_CODE_STARTUP_PROBE_FRAME, +} from '@test/helpers/opencode-startup-probes' const wsMocks = vi.hoisted(() => ({ send: vi.fn(), @@ -30,6 +36,12 @@ const apiMocks = vi.hoisted(() => ({ patch: vi.fn().mockResolvedValue({}), })) +const terminalTheme = { + foreground: '#aabbcc', + background: '#112233', + cursor: '#ddeeff', +} + vi.mock('@/lib/ws-client', () => ({ getWsClient: () => ({ send: wsMocks.send, @@ -51,7 +63,7 @@ vi.mock('@/lib/api', () => ({ })) vi.mock('@/lib/terminal-themes', () => ({ - getTerminalTheme: () => ({}), + getTerminalTheme: () => terminalTheme, })) vi.mock('@/components/terminal/terminal-runtime', () => ({ @@ -73,6 +85,7 @@ vi.mock('lucide-react', () => ({ const terminalInstances: any[] = [] const latestAttachRequestIdByTerminal = new Map() +const ioEvents: Array<{ kind: 'send' | 'write', type?: string, data: string }> = [] function withCurrentAttachRequestId(msg: any) { if ( @@ -93,7 +106,9 @@ vi.mock('@xterm/xterm', () => { rows = 24 open = vi.fn() loadAddon = vi.fn() - write = vi.fn() + write = vi.fn((data: string) => { + ioEvents.push({ kind: 'write', data: String(data) }) + }) writeln = vi.fn() clear = vi.fn() dispose = vi.fn() @@ -142,7 +157,10 @@ function createSettingsState(policy: 'ask' | 'always' | 'never') { } } -function createStore(policy: 'ask' | 'always' | 'never') { +function createStore( + policy: 'ask' | 'always' | 'never', + mode: TerminalPaneContent['mode'] = 'opencode', +) { const tabId = 'tab-osc52' const paneId = 'pane-osc52' const terminalId = 'term-osc52' @@ -151,7 +169,7 @@ function createStore(policy: 'ask' | 'always' | 'never') { kind: 'terminal', createRequestId: 'req-osc52', status: 'running', - mode: 'codex', + mode, shell: 'system', terminalId, } @@ -170,9 +188,9 @@ function createStore(policy: 'ask' | 'always' | 'never') { tabs: { tabs: [{ id: tabId, - mode: 'codex', + mode, status: 'running', - title: 'Codex', + title: mode === 'opencode' ? 'OpenCode' : 'Terminal', terminalId, createRequestId: 'req-osc52', }], @@ -198,8 +216,12 @@ describe('TerminalView OSC52 policy handling', () => { beforeEach(() => { terminalInstances.length = 0 latestAttachRequestIdByTerminal.clear() + ioEvents.length = 0 wsMocks.send.mockClear() wsMocks.send.mockImplementation((msg: any) => { + if (msg?.type === 'terminal.input' && typeof msg?.data === 'string') { + ioEvents.push({ kind: 'send', type: msg.type, data: msg.data }) + } if ( msg?.type === 'terminal.attach' && typeof msg?.terminalId === 'string' @@ -225,8 +247,11 @@ describe('TerminalView OSC52 policy handling', () => { messageHandler = null }) - async function renderView(policy: 'ask' | 'always' | 'never') { - const { store, tabId, paneId, paneContent, terminalId } = createStore(policy) + async function renderView( + policy: 'ask' | 'always' | 'never', + mode: TerminalPaneContent['mode'] = 'opencode', + ) { + const { store, tabId, paneId, paneContent, terminalId } = createStore(policy, mode) render( @@ -238,6 +263,18 @@ describe('TerminalView OSC52 policy handling', () => { return { store, terminalId } } + function writeEvents() { + return ioEvents.filter((event) => event.kind === 'write') + } + + function postReplySeqRange(index: number) { + if (index === 0) { + return { seqStart: 2, seqEnd: 4 } + } + const seq = index + 4 + return { seqStart: seq, seqEnd: seq } + } + it('always policy copies silently without prompt', async () => { const { terminalId } = await renderView('always') messageHandler!({ type: 'terminal.output', terminalId, seqStart: 1, seqEnd: 1, data: `before${OSC52_COPY}after` }) @@ -249,6 +286,112 @@ describe('TerminalView OSC52 policy handling', () => { expect(screen.queryByRole('dialog', { name: 'Clipboard access request' })).not.toBeInTheDocument() }) + it('strips startup probes, sends replies before writing visible output, and preserves OSC52 handling', async () => { + const { terminalId } = await renderView('always') + wsMocks.send.mockClear() + ioEvents.length = 0 + + messageHandler!({ + type: 'terminal.output', + terminalId, + seqStart: 1, + seqEnd: 1, + data: OPEN_CODE_STARTUP_PROBE_FRAME, + }) + + expect(terminalInstances[0].write).not.toHaveBeenCalled() + + const probeInputMessages = wsMocks.send.mock.calls + .map(([msg]) => msg) + .filter((msg) => msg?.type === 'terminal.input') + expect(probeInputMessages).toEqual( + OPEN_CODE_STARTUP_EXPECTED_REPLIES.map((data) => ({ + type: 'terminal.input', + terminalId, + data, + })), + ) + expect(ioEvents).toEqual([ + ...OPEN_CODE_STARTUP_EXPECTED_REPLIES.map((data) => ({ kind: 'send' as const, type: 'terminal.input', data })), + ]) + + OPEN_CODE_STARTUP_POST_REPLY_FRAMES.forEach((frame, index) => { + const range = postReplySeqRange(index) + messageHandler!({ + type: 'terminal.output', + terminalId, + seqStart: range.seqStart, + seqEnd: range.seqEnd, + data: `${frame}${index === OPEN_CODE_STARTUP_POST_REPLY_FRAMES.length - 1 ? OSC52_COPY : ''}`, + }) + }) + + await waitFor(() => { + expect(writeEvents().map((event) => event.data).join('')).toBe(OPEN_CODE_STARTUP_EXPECTED_CLEANED) + }) + + expect(clipboardMocks.copyText).toHaveBeenCalledWith('copy') + expect(screen.queryByRole('dialog', { name: 'Clipboard access request' })).not.toBeInTheDocument() + + const inputMessages = wsMocks.send.mock.calls + .map(([msg]) => msg) + .filter((msg) => msg?.type === 'terminal.input') + expect(inputMessages).toEqual( + OPEN_CODE_STARTUP_EXPECTED_REPLIES.map((data) => ({ + type: 'terminal.input', + terminalId, + data, + })), + ) + + expect(ioEvents).toEqual([ + ...OPEN_CODE_STARTUP_EXPECTED_REPLIES.map((data) => ({ kind: 'send' as const, type: 'terminal.input', data })), + ...OPEN_CODE_STARTUP_POST_REPLY_FRAMES.map((data) => ({ kind: 'write' as const, data })), + ]) + }) + + it('strips startup probes for shell terminal modes too', async () => { + const { terminalId } = await renderView('always', 'shell') + wsMocks.send.mockClear() + ioEvents.length = 0 + + messageHandler!({ + type: 'terminal.output', + terminalId, + seqStart: 1, + seqEnd: 1, + data: OPEN_CODE_STARTUP_PROBE_FRAME, + }) + + expect(terminalInstances[0].write).not.toHaveBeenCalled() + + const probeInputMessages = wsMocks.send.mock.calls + .map(([msg]) => msg) + .filter((msg) => msg?.type === 'terminal.input') + expect(probeInputMessages).toEqual( + OPEN_CODE_STARTUP_EXPECTED_REPLIES.map((data) => ({ + type: 'terminal.input', + terminalId, + data, + })), + ) + + OPEN_CODE_STARTUP_POST_REPLY_FRAMES.forEach((frame, index) => { + const range = postReplySeqRange(index) + messageHandler!({ + type: 'terminal.output', + terminalId, + seqStart: range.seqStart, + seqEnd: range.seqEnd, + data: frame, + }) + }) + + await waitFor(() => { + expect(writeEvents().map((event) => event.data).join('')).toBe(OPEN_CODE_STARTUP_EXPECTED_CLEANED) + }) + }) + it('never policy does not copy and does not prompt', async () => { const { terminalId } = await renderView('never') messageHandler!({ type: 'terminal.output', terminalId, seqStart: 1, seqEnd: 1, data: `before${OSC52_COPY}after` }) diff --git a/test/unit/client/lib/terminal-startup-probes.test.ts b/test/unit/client/lib/terminal-startup-probes.test.ts new file mode 100644 index 00000000..97b1ed31 --- /dev/null +++ b/test/unit/client/lib/terminal-startup-probes.test.ts @@ -0,0 +1,101 @@ +import { describe, expect, it } from 'vitest' + +import { + createTerminalStartupProbeState, + extractTerminalStartupProbes, +} from '@/lib/terminal-startup-probes' +import { + OPEN_CODE_STARTUP_EXPECTED_CLEANED, + OPEN_CODE_STARTUP_EXPECTED_REPLIES, + OPEN_CODE_STARTUP_POST_REPLY_FRAMES, + OPEN_CODE_STARTUP_PROBE_FRAME, + OPEN_CODE_STARTUP_PROBE_SPLIT_FRAMES, +} from '@test/helpers/opencode-startup-probes' + +const COLORS = { + foreground: '#aabbcc', + background: '#112233', + cursor: '#ddeeff', +} + +describe('terminal-startup-probes', () => { + it('extracts the captured startup probe and passes the captured post-reply frames through unchanged', () => { + const state = createTerminalStartupProbeState() + const probe = extractTerminalStartupProbes(OPEN_CODE_STARTUP_PROBE_FRAME, state, COLORS) + + expect(probe.cleaned).toBe('') + expect(probe.replies).toEqual(OPEN_CODE_STARTUP_EXPECTED_REPLIES) + + const cleaned = OPEN_CODE_STARTUP_POST_REPLY_FRAMES.map((frame) => { + const result = extractTerminalStartupProbes(frame, state, COLORS) + expect(result.replies).toEqual([]) + return result.cleaned + }).join('') + + expect(cleaned).toBe(OPEN_CODE_STARTUP_EXPECTED_CLEANED) + }) + + it('buffers the shared split startup-probe fixture across frames', () => { + const state = createTerminalStartupProbeState() + const [firstFrame, secondFrame] = OPEN_CODE_STARTUP_PROBE_SPLIT_FRAMES + const [firstPostReplyFrame = ''] = OPEN_CODE_STARTUP_POST_REPLY_FRAMES + + const first = extractTerminalStartupProbes( + firstFrame, + state, + COLORS, + ) + expect(first.cleaned).toBe('') + expect(first.replies).toEqual([]) + + const second = extractTerminalStartupProbes( + `${secondFrame}${firstPostReplyFrame}`, + state, + COLORS, + ) + expect(second.cleaned).toBe(OPEN_CODE_STARTUP_EXPECTED_CLEANED) + expect(second.replies).toEqual(OPEN_CODE_STARTUP_EXPECTED_REPLIES) + }) + + it('passes unrelated OSC/APC traffic through unchanged', () => { + const state = createTerminalStartupProbeState() + const input = 'prefix\u001b]0;Window title\u0007middle\u001b_Gi=31337;AAAA\u001b\\suffix' + + const result = extractTerminalStartupProbes(input, state, COLORS) + + expect(result.cleaned).toBe(input) + expect(result.replies).toEqual([]) + }) + + it('passes malformed recognized startup-probe traffic through unchanged', () => { + const state = createTerminalStartupProbeState() + const input = 'prefix\u001b]11;?\u001b\\suffix' + + const result = extractTerminalStartupProbes(input, state, COLORS) + + expect(result.cleaned).toBe(input) + expect(result.replies).toEqual([]) + }) + + it('passes OSC 11 queries through unchanged when they are embedded in ordinary output', () => { + const state = createTerminalStartupProbeState() + const input = `before${OPEN_CODE_STARTUP_PROBE_FRAME}after` + + const result = extractTerminalStartupProbes(input, state, COLORS) + + expect(result.cleaned).toBe(input) + expect(result.replies).toEqual([]) + }) + + it('preserves incomplete unknown escape traffic until the frame completes', () => { + const state = createTerminalStartupProbeState() + + const first = extractTerminalStartupProbes('before\u001b]0;Window title', state, COLORS) + expect(first.cleaned).toBe('before') + expect(first.replies).toEqual([]) + + const second = extractTerminalStartupProbes('\u0007after', state, COLORS) + expect(second.cleaned).toBe('\u001b]0;Window title\u0007after') + expect(second.replies).toEqual([]) + }) +})