diff --git a/web/src/app.js b/web/src/app.js index 950e4fb8..09c17f32 100644 --- a/web/src/app.js +++ b/web/src/app.js @@ -2,7 +2,7 @@ // Deliberately small and DOM-only (no framework, no build step). Every value // that came from the server is set with textContent, never innerHTML. import { PipelinesClient } from "./client.js"; -import { PipelinesRepository } from "./repository.js"; +import { PipelinesRepository, SHELL_OUTPUT_LIMIT } from "./repository.js"; import { PROTOCOL_VERSION, Protocol, ChatKeys } from "./protocol.js"; import { validateServerUrl, resolveArtifactUrl } from "./serverUrl.js"; import { @@ -207,6 +207,7 @@ import { retryRequestKey, } from "./actions.js"; import { + BACKGROUND_TASKS_TITLE, CHAT_ATTACH_LABEL, CHAT_COMMAND_GLYPH, CHAT_COMPOSER_PLACEHOLDER, @@ -241,12 +242,21 @@ import { DECISION_REJECT, RISK_REVIEW_LABEL, WAITING_FOR_APPROVAL_LABEL, + SHELL_DETAILS_LABEL, + SHELL_OUTPUT_EMPTY, + SHELL_OUTPUT_ERROR, + SHELL_OUTPUT_LABELS, + SHELL_OUTPUT_LOADING, + SHELL_OUTPUT_READY, + SHELL_OUTPUT_UNAVAILABLE, + SHELL_ROW_LABEL, applyChatEvent, applyChatPermission, approvalCard, attachmentDisplayName, attachmentError, attachmentFiles, + backgroundTasksRunningLabel, chatBottomDistancePx, chatCommandEffect, chatCommandHelp, @@ -268,11 +278,14 @@ import { groupSessionsByDirectory, historyResync, mergeHistoryPage, + mergeShellFrame, newChatThread, parseChatInput, queuedAfterFrame, reasoningLabel, + resumedThread, runningAfterFrame, + runningBackgroundShells, runningToolElapsedMillis, sessionActivity, sessionActivityBadge, @@ -282,6 +295,9 @@ import { sessionTitle, sessionWorkLabel, settledThread, + shellCommandSummary, + shellOutputState, + shellsLoaded, formatToolDuration, threadElapsedMillis, threadPhase, @@ -3611,6 +3627,9 @@ async function openChatSession(id) { // Attach the shared live stream once per session per connection; its failure is // non-fatal — history stays usable and the badge reads "not live". subscribeChatSession(id); + // Load the session's background shells (C11) so the bar appears on open, not + // only after the next pushed shell frame. + loadChatShells(id); await loadChatHistory(id); } @@ -3645,13 +3664,18 @@ function clearChatSubscriptions() { } /** - * Settle every conversation that was running. A socket drop (or a close) removes - * the frames feeding the turn, so no thread keeps claiming to run until a fresh - * frame proves otherwise. + * Settle every conversation that was running, and drop its observed shells. A + * socket drop (or a close) removes the frames feeding the turn, so no thread + * keeps claiming to run until a fresh frame proves otherwise; a shell's exit may + * have been swallowed by the same gap, so the retained shells are forgotten and + * re-learned from `chat_shells` on reconnect (mirrors ChatStore.streamResumed). */ function settleChatThreads() { for (const [id, thread] of state.chatThreads) { - if (thread?.running || thread?.queued) state.chatThreads.set(id, settledThread(thread)); + const hasShells = (thread?.shells ?? []).length > 0; + if (thread?.running || thread?.queued || hasShells) { + state.chatThreads.set(id, resumedThread(thread)); + } } } @@ -3732,19 +3756,110 @@ async function answerPermission(sessionId, requestId, decision) { * conversation with the newest history page wholesale. Everything the gap could * have missed is repaired; a turn that was in flight is settled. Only the open * conversation is repaired — the others are not on screen. + * Fetch a session's currently verified shells (C11) and retain only the exits + * this client itself observed, so an exited task never reappears as running and a + * shell the server no longer lists drops out. Called when the conversation opens + * and on every stream reconnect (a gap may have swallowed an exit). A failure is + * non-fatal: the transcript stays usable and the bar keeps its last known state. + */ +async function loadChatShells(id) { + if (!id || state.connection.kind !== "connected") return; + try { + const running = await repo.chatShells(id); + const thread = state.chatThreads.get(id); + if (!thread) return; + state.chatThreads.set(id, { ...thread, shells: shellsLoaded(thread.shells, running) }); + renderContent(); + } catch { + // The shell list is a background convenience; leave the thread untouched. + } +} + +/** + * Toggle a running task's detail pane (C11). Selecting a shell fetches its + * bounded output page; selecting the selected one again closes it. Mirrors + * ChatStore.selectShell: an id that is not a known shell is ignored. + */ +function selectChatShell(shellId) { + const sessionId = state.chatActiveId; + const thread = sessionId ? state.chatThreads.get(sessionId) : null; + if (!thread) return; + const closing = thread.selectedShellId === shellId; + if (!closing && !(thread.shells ?? []).some((shell) => shell.id === shellId)) return; + const next = closing ? null : shellId; + state.chatThreads.set(sessionId, { ...thread, selectedShellId: next, shellOutput: null }); + renderContent(); + if (next) refreshChatShellOutput(next); +} + +/** + * Reread a selected task's bounded output page (C11) from the page's start. The + * cursor is always 0 and the limit is the server's 64 KiB bound, so the client + * never grows output unbounded and a Refresh never appends. A reply for a shell + * that is no longer selected is ignored, exactly like ChatStore.shellOutput*. + */ +async function refreshChatShellOutput(shellId) { + const sessionId = state.chatActiveId; + if (!sessionId || !shellId) return; + shellOutputLoading(sessionId, shellId); + renderContent(); + try { + const page = await repo.chatShellOutput(sessionId, shellId, { cursor: 0, limit: SHELL_OUTPUT_LIMIT }); + shellOutputLoaded(sessionId, shellId, page); + } catch (error) { + shellOutputFailed(sessionId, shellId, describeError(error)); + } + renderContent(); +} + +/** Mark a selected task's output pane loading (ignored for a stale selection). */ +function shellOutputLoading(sessionId, shellId) { + const thread = state.chatThreads.get(sessionId); + if (!thread || thread.selectedShellId !== shellId) return; + state.chatThreads.set(sessionId, { ...thread, shellOutput: { loading: true, error: "", page: null } }); +} + +/** + * Apply a loaded output page, merging a shell the page reports back into the + * retained list (keeping the command already learned when the page omits it). + */ +function shellOutputLoaded(sessionId, shellId, page) { + const thread = state.chatThreads.get(sessionId); + if (!thread || thread.selectedShellId !== shellId) return; + const reported = page?.shell; + const shells = reported && String(reported.id ?? "").trim() !== "" + ? mergeShellFrame(thread.shells, reported) + : thread.shells ?? []; + state.chatThreads.set(sessionId, { ...thread, shells, shellOutput: { loading: false, error: "", page } }); +} + +/** Report a failed output read against the still-selected task (Retry is offered). */ +function shellOutputFailed(sessionId, shellId, message) { + const thread = state.chatThreads.get(sessionId); + if (!thread || thread.selectedShellId !== shellId) return; + state.chatThreads.set(sessionId, { ...thread, shellOutput: { loading: false, error: message, page: null } }); +} + +/** + * The reconnect repair (C5/C11): re-attach the open chat's stream, replace its + * conversation with the newest history page wholesale and re-learn its shells. + * Everything the gap could have missed is repaired; a turn that was in flight is + * settled and the retained shells are dropped before the fresh snapshot arrives. + * Only the open conversation is repaired — the others are not on screen. */ async function resyncOpenChat() { const id = state.chatActiveId; if (!id || state.connection.kind !== "connected") return; await subscribeChatSession(id); const previous = state.chatThreads.get(id) ?? newChatThread(id); - state.chatThreads.set(id, settledThread(previous)); + state.chatThreads.set(id, resumedThread(previous)); try { const page = await repo.chatHistory(id); state.chatThreads.set(id, historyResync(previous, page)); } catch { // The history refresh failed; the settled thread stands and the badge is honest. } + await loadChatShells(id); renderContent(); } @@ -4488,6 +4603,12 @@ function renderChatConversation() { if (contextMeta !== "") context.append(h("span", { class: "chat-context-meta muted", text: contextMeta })); pane.append(context); + // The background-tasks bar (C11) sits above the transcript, outside the + // scroller so the C14 scroll positions are untouched. It is present only while + // a shell is still running and disappears with the last exit. + const backgroundTasks = renderBackgroundTasks(thread); + if (backgroundTasks) pane.append(backgroundTasks); + const notices = thread?.notices ?? []; if (thread?.loading && !thread?.loaded) { pane.append(h("div", { class: "chat-transcript-empty muted", text: CONVERSATION_LOADING })); @@ -4538,6 +4659,126 @@ function appendChatDialogs(pane) { if (state.actionError) pane.append(renderActionFailedDialog()); } +/** + * The background-tasks bar (C11): the running shells this conversation still + * owns. It returns null (renders nothing) unless at least one shell is running, + * so it disappears the moment the last task exits. Heading `Background tasks` + + * `{n} running`; the list shows at most BACKGROUND_TASK_VISIBLE_ROWS rows and + * scrolls beyond; a selected row reveals its bounded, read-only output pane. + * Every server string is set with textContent (never innerHTML). + */ +function renderBackgroundTasks(thread) { + const running = runningBackgroundShells(thread?.shells ?? []); + if (running.length === 0) return null; + const wrap = h("section", { class: "chat-bg-tasks", id: "chatBackgroundTasks" }); + const head = h("div", { class: "chat-bg-tasks-head" }); + head.append(h("span", { class: "chat-bg-tasks-title", text: BACKGROUND_TASKS_TITLE })); + head.append( + h("span", { class: "chat-bg-tasks-count muted", text: backgroundTasksRunningLabel(running.length) }), + ); + wrap.append(head); + const list = h("div", { class: "chat-bg-tasks-list" }); + const selectedId = thread?.selectedShellId ?? null; + running.forEach((shell) => list.append(renderBackgroundTaskRow(shell, shell.id === selectedId))); + wrap.append(list); + const selected = running.find((shell) => shell.id === selectedId) ?? null; + if (selected) wrap.append(renderBackgroundTaskDetail(thread, selected)); + return wrap; +} + +/** One running shell task; tapping it toggles its detail pane. */ +function renderBackgroundTaskRow(shell, selected) { + const row = h("button", { + class: `chat-bg-task${selected ? " selected" : ""}`, + type: "button", + "data-shell": shell.id, + "aria-pressed": selected ? "true" : "false", + onclick: () => selectChatShell(shell.id), + }); + // A CSS play glyph, decorative only (the row's own text names the task). + row.append(h("span", { class: "chat-bg-task-glyph", "aria-hidden": "true" })); + row.append(h("span", { class: "chat-bg-task-status", text: SHELL_ROW_LABEL })); + row.append( + h("span", { + class: "chat-bg-task-command", + text: shellCommandSummary(shell.command), + title: String(shell.command ?? ""), + }), + ); + if (selected) row.append(h("span", { class: "chat-bg-task-details muted", text: SHELL_DETAILS_LABEL })); + return row; +} + +/** + * The selected task's read-only detail: its command, its identity in monospace + * and `Status: running`, then the output area — the exact label order and wording + * of ChatTranscript.BackgroundProcessDetail. Reload is always a bounded reread + * from the page's start (`Refresh`; `Retry` after a failure). + */ +function renderBackgroundTaskDetail(thread, shell) { + const labels = SHELL_OUTPUT_LABELS; + const pane = h("div", { class: "chat-bg-task-detail" }); + pane.append(h("div", { class: "chat-bg-task-label muted", text: labels.COMMAND })); + const command = String(shell.command ?? "").trim(); + pane.append( + h("div", { + class: "chat-bg-task-command-full", + text: command === "" ? labels.UNAVAILABLE : shell.command, + }), + ); + pane.append(h("div", { class: "chat-bg-task-label muted", text: labels.TASK_IDENTITY })); + pane.append(h("div", { class: "chat-bg-task-id monospace", text: String(shell.id ?? "") })); + pane.append(h("div", { class: "chat-bg-task-status-line", text: labels.STATUS_RUNNING })); + + const output = thread?.shellOutput ?? null; + switch (shellOutputState(output)) { + case SHELL_OUTPUT_LOADING: + pane.append(h("span", { class: "spinner chat-bg-task-spinner", "aria-hidden": "true" })); + break; + case SHELL_OUTPUT_ERROR: { + const row = h("div", { class: "chat-bg-task-error-row" }); + row.append(h("span", { class: "chat-bg-task-error", text: output.error })); + row.append( + h("button", { + class: "ghost chat-bg-task-retry", + type: "button", + text: labels.RETRY, + onclick: () => refreshChatShellOutput(shell.id), + }), + ); + pane.append(row); + break; + } + case SHELL_OUTPUT_UNAVAILABLE: + pane.append(h("div", { class: "chat-bg-task-note muted", text: labels.OUTPUT_UNAVAILABLE })); + break; + case SHELL_OUTPUT_EMPTY: + pane.append(h("div", { class: "chat-bg-task-note muted", text: labels.NO_OUTPUT })); + break; + case SHELL_OUTPUT_READY: { + const page = output.page; + pane.append(h("div", { class: "chat-bg-task-label muted", text: labels.OUTPUT })); + // Untrusted shell text: set as textContent, never parsed as markup. + pane.append(h("pre", { class: "chat-bg-task-output", text: String(page.output ?? "") })); + if (page.truncated) { + pane.append(h("div", { class: "chat-bg-task-note muted", text: labels.OUTPUT_BOUNDED })); + } + pane.append( + h("button", { + class: "ghost chat-bg-task-refresh", + type: "button", + text: labels.REFRESH, + onclick: () => refreshChatShellOutput(shell.id), + }), + ); + break; + } + default: + break; + } + return pane; +} + /** * The transcript: one column of turns. An operator message is its own * right-aligned bubble (with the sending client's label when the server echoed diff --git a/web/src/chat.js b/web/src/chat.js index e9ebda5c..37b626ea 100644 --- a/web/src/chat.js +++ b/web/src/chat.js @@ -302,6 +302,21 @@ export function toolDetail(part) { return null; } +/** + * The one-line command a background process is running, collapsed to a single + * line and elided past [TOOL_DETAIL_MAX_LENGTH] like a tool call's detail, so a + * long command line cannot flood the bar. A shell that reported no command reads + * as a generic `background process` rather than a blank line (ChatFormat.kt + * shellCommandSummary, which shares the tool-detail regex and bound). + */ +export function shellCommandSummary(command) { + const text = str(command).trim().replace(/\s+/g, " "); + if (text === "") return "background process"; + return text.length <= TOOL_DETAIL_MAX_LENGTH + ? text + : text.slice(0, TOOL_DETAIL_MAX_LENGTH - 1).trimEnd() + "…"; +} + /** * The INPUT section of a tool call: pretty-printed JSON once the arguments are an * object/array, the raw partial-JSON string while still streaming, or empty when @@ -795,6 +810,141 @@ export function chatStreamState(connectionKind, subscribed) { return { tone: "not-live", label: STREAM_OFFLINE }; } +// --------------------------------------------------------------------------- +// Background shells (C11: ChatTranscript.kt BackgroundProcessBar, ChatStore.kt +// applyShell/shellsLoaded, ChatFormat.kt runningBackgroundShells/shellCommandSummary) +// --------------------------------------------------------------------------- + +/** + * ChatShell.Status values (internal/protocol/chat.go). A running shell is one + * whose command has started and not yet exited; `exited` is final. + */ +export const SHELL_RUNNING = "running"; +export const SHELL_EXITED = "exited"; + +/** + * Per-session in-memory observation bound (ChatStore.OBSERVED_SHELL_LIMIT): the + * retained shell tail a selected task can settle against. This is not task + * history, only what this client itself observed. + */ +export const OBSERVED_SHELL_LIMIT = 16; + +/** + * How many running-task rows the bar draws before the list scrolls instead of + * growing (ChatTranscript.BACKGROUND_TASK_VISIBLE_ROWS). + */ +export const BACKGROUND_TASK_VISIBLE_ROWS = 3; + +/** The bar's heading; its count line is `{n} running`. */ +export const BACKGROUND_TASKS_TITLE = "Background tasks"; +export function backgroundTasksRunningLabel(count) { + return `${count} running`; +} + +/** A row's own words (ChatTranscript.BackgroundProcessLine). */ +export const SHELL_ROW_LABEL = "Running"; +export const SHELL_DETAILS_LABEL = "Details"; + +/** + * The detail pane's exact wording, verbatim from + * ChatTranscript.BackgroundProcessDetail. Kept as one frozen map so the pane and + * its unit test share one string instead of the copy drifting. + */ +export const SHELL_OUTPUT_LABELS = Object.freeze({ + COMMAND: "Command", + UNAVAILABLE: "Unavailable", + TASK_IDENTITY: "Task identity", + STATUS_RUNNING: "Status: running", + OUTPUT_UNAVAILABLE: "Output unavailable for this task.", + NO_OUTPUT: "No output yet.", + OUTPUT: "Output", + OUTPUT_BOUNDED: "Output is bounded to 64 KiB.", + RETRY: "Retry", + REFRESH: "Refresh", +}); + +/** + * The background processes still running for a session, in the order they + * started, from the shells the server reported and the session retains. A shell + * that has exited is never listed — that is what clears the bar — and the set is + * independent of the turn, because a background process outlives the tool call + * (and often the turn) that started it. Mirrors ChatFormat.runningBackgroundShells: + * only a non-blank id with status `running` is a task, and the list is never + * truncated here (the visible-row cap is a view concern). + */ +export function runningBackgroundShells(shells) { + return (shells ?? []).filter( + (shell) => !isBlank(shell?.id) && str(shell?.status) === SHELL_RUNNING, + ); +} + +/** + * Folds one shell frame (or a snapshot entry) into the retained shells, keyed by + * id and kept in observation order. A blank incoming command keeps the command + * already learned, so a later frame that omits it never blanks the row, and the + * list is trimmed to the last [OBSERVED_SHELL_LIMIT] entries (ChatStore.applyShell). + */ +export function mergeShellFrame(shells, shell) { + const id = str(shell?.id); + if (shell == null || isBlank(id)) return shells ?? []; + const list = (shells ?? []).slice(); + const index = list.findIndex((candidate) => str(candidate?.id) === id); + const prior = index >= 0 ? list[index] : null; + const merged = { + ...shell, + id, + command: isBlank(shell?.command) ? str(prior?.command) : shell.command, + }; + if (index >= 0) list[index] = merged; + else list.push(merged); + return list.slice(-OBSERVED_SHELL_LIMIT); +} + +/** + * Replaces the retained shells with the authoritative running snapshot while + * keeping only exits this client itself observed, capped like every other shell + * list (ChatStore.shellsLoaded). A shell the server no longer lists and that this + * client never saw exit simply drops out. + */ +export function shellsLoaded(shells, running) { + const byId = new Map(); + for (const shell of shells ?? []) { + if (!isBlank(shell?.id) && str(shell?.status) === SHELL_EXITED) byId.set(shell.id, shell); + } + for (const shell of running ?? []) { + if (isBlank(shell?.id)) continue; + // Map.set keeps the first-insertion position and replaces the value, exactly + // like Kotlin's `observedExits + live` LinkedHashMap merge. + byId.set(shell.id, shell); + } + return [...byId.values()].slice(-OBSERVED_SHELL_LIMIT); +} + +/** The five shapes a selected task's output area can take. */ +export const SHELL_OUTPUT_LOADING = "loading"; +export const SHELL_OUTPUT_ERROR = "error"; +export const SHELL_OUTPUT_UNAVAILABLE = "unavailable"; +export const SHELL_OUTPUT_EMPTY = "empty"; +export const SHELL_OUTPUT_READY = "output"; + +/** + * Which branch the detail pane's output area shows for a selected task's + * [output] state, or null when there is nothing to show yet — the same decision + * order as ChatTranscript.BackgroundProcessDetail's `when` (loading, then error, + * then the server's `unavailable`, then an empty page, then a readable page), so + * the pane and its unit test share one derivation. + */ +export function shellOutputState(output) { + if (output == null) return null; + if (output.loading) return SHELL_OUTPUT_LOADING; + if (str(output.error) !== "") return SHELL_OUTPUT_ERROR; + const page = output.page ?? null; + if (page == null) return null; + if (page.unavailable === true) return SHELL_OUTPUT_UNAVAILABLE; + if (str(page.output) === "") return SHELL_OUTPUT_EMPTY; + return SHELL_OUTPUT_READY; +} + /** * The shape an open conversation holds. The first six fields are the ones a * history page fills; the rest is the live stream (see `ChatThread` in @@ -824,6 +974,11 @@ export function newChatThread(sessionId = "") { // The reason a refused `chat_reply` left on the thread's error line, kept // apart from any other error so a later accepted answer clears only this one. permissionError: "", + // The background shells this session has observed (C11), in observation + // order, the selected task and its bounded output pane. + shells: [], + selectedShellId: null, + shellOutput: null, }; } @@ -850,6 +1005,19 @@ export function setThreadRunning(thread, running, now) { return settledThread({ ...thread }); } +/** + * The reconnect repair for one thread (C5/C11): the settled form plus the shell + * observations dropped — a shell's exit may have been swallowed by the gap, so + * the retained shells are forgotten and re-learned from the re-subscribe's + * `chat_shells` snapshot. This is deliberately separate from [settledThread], + * which the step-ended frame also uses: a turn ending must never clear a + * background process that outlives it (ChatStore.streamResumed drops shells; + * ChatStore.setRunning does not). + */ +export function resumedThread(thread) { + return { ...settledThread(thread), shells: [], selectedShellId: null, shellOutput: null }; +} + /** * Non-negative elapsed time of an in-flight turn at [nowMillis], or 0 once it has * settled. Pure, so the running indicator and its unit test share the derivation. @@ -975,8 +1143,8 @@ export function threadPhase(thread, nowMillis) { * thread. Any frame clears `queued` (the turn moved on); `user` echoes another * client's prompt once (never this client's own), `text`/`reasoning` append to the * part their kind started, `tool` merges field by field, `step` drives the running - * flag, and `shell`/`usage` are recognised but not folded here (C11 owns shells - * and the turn totals are not shown). The message that a delta or tool frame + * flag, and `shell` folds one background process into the retained set without + * ever marking the turn running (C11). The message that a delta or tool frame * targets is created on first sight, so a live turn never gains a second bubble. */ export function applyChatEvent(thread, frame, now = Date.now()) { @@ -993,9 +1161,12 @@ export function applyChatEvent(thread, frame, now = Date.now()) { return applyTool(current, frame, now); case EVENT_STEP: return setThreadRunning(current, str(frame?.step?.status) !== STEP_ENDED, now); - // `shell` is C11's (it never marks the turn running) and `usage` is not - // folded; both still clear `queued`, which happened above. + // A shell frame only folds its shell into the retained set: it NEVER marks + // the thread running, because a background process is not the turn — a shell + // that outlives the turn keeps showing after the turn's own indicator is gone. case EVENT_SHELL: + return { ...current, shells: mergeShellFrame(current.shells, frame?.shell) }; + // `usage` is recognised but not folded; it still cleared `queued` above. case EVENT_USAGE: default: return current; @@ -1094,10 +1265,12 @@ function upsertParts(thread, frame, now, deltaArrivedAt, upsert) { * The reconnect/resync replacement: the newest history page is authoritative, so * the whole turn is replaced (no stale held message survives), the cursor and * `hasMore` are replaced from the page, and any in-flight state is settled — - * every frame that was feeding a running turn is gone. + * every frame that was feeding a running turn is gone. The retained shells are + * dropped too (the reconnect re-fetches `chat_shells`), exactly like the Android + * `streamResumed` path. */ export function historyResync(thread, page) { - const settled = settledThread(thread ?? newChatThread()); + const settled = resumedThread(thread ?? newChatThread()); return { ...settled, messages: (page?.messages ?? []).slice(), diff --git a/web/src/protocol.js b/web/src/protocol.js index cb50f7e6..21a74550 100644 --- a/web/src/protocol.js +++ b/web/src/protocol.js @@ -69,6 +69,12 @@ export const Protocol = Object.freeze({ // with `chat_reply` (internal/protocol/chat.go ChatPermission/ChatReply). CHAT_PERMISSION: "chat_permission", CHAT_REPLY: "chat_reply", + // The background shells a chat session owns (C11). `chat_shells` lists the + // session's currently verified shells (body: `chat_query`); `chat_shell_output` + // reads a bounded, lazy output page from one of them (body: + // `chat_shell_output_query`). Mirrors internal/protocol/chat.go and Message.kt. + CHAT_SHELLS: "chat_shells", + CHAT_SHELL_OUTPUT: "chat_shell_output", SUCCESS_END: "#success", FAILURE_END: "#failure", @@ -101,6 +107,13 @@ export const ChatKeys = Object.freeze({ // (`chat_reply`), both distinct Message fields in internal/protocol/message.go. PERMISSION: "chat_permission", REPLY: "chat_reply", + // The shell commands (C11, internal/protocol/message.go). `chat_shells` carries + // its body in `chat_query` (like the other session-scoped commands) and replies + // in `chat_shells`; `chat_shell_output` carries `chat_shell_output_query` + // ({session_id,shell_id,cursor,limit}) and replies in `chat_shell_output`. + SHELLS: "chat_shells", + SHELL_OUTPUT: "chat_shell_output", + SHELL_OUTPUT_QUERY: "chat_shell_output_query", }); /** diff --git a/web/src/repository.js b/web/src/repository.js index 23070076..62f112db 100644 --- a/web/src/repository.js +++ b/web/src/repository.js @@ -15,6 +15,14 @@ export const CHAT_HISTORY_LIMIT = 200; */ export const WEB_CHAT_CLIENT = "Web"; +/** + * The largest shell-output page the server accepts (ChatShellOutputLimit, + * 64 KiB). The browser always reads from the page's start and never sends more + * than this, so a background task's output can never grow unbounded on the + * client. + */ +export const SHELL_OUTPUT_LIMIT = 64 << 10; + export class PipelinesRepository { #client; @@ -248,6 +256,57 @@ export class PipelinesRepository { }); } + /** + * Lists the currently verified shells this operator chat session owns (C11), + * so the conversation can show a background-tasks bar while one is running. + * The body is the session-scoped `chat_query` (like chat_messages); the reply + * is `chat_shells`, and an older server that returns none answers with an empty + * list. A blank session id is refused here, exactly like + * PipelinesRepository.chatShells. + */ + async chatShells(sessionId) { + if (!String(sessionId ?? "").trim()) { + throw new ProtocolError("Select a chat session first."); + } + const response = await this.#client.call({ + type: Protocol.CHAT_SHELLS, + [ChatKeys.QUERY]: { session_id: sessionId }, + }); + return response[ChatKeys.SHELLS] ?? []; + } + + /** + * Reads one bounded output page from a verified shell (C11), mirroring + * PipelinesRepository.chatShellOutput. The body is exactly + * `chat_shell_output_query` — {session_id, shell_id, cursor, limit}, **not** the + * `chat_query` the other session commands use — with the cursor always sent so + * a refresh rereads from the page's start rather than appending. A blank + * session/shell, an out-of-bounds cursor/limit or a reply with no page is + * refused with the same reason the Android client uses. + */ + async chatShellOutput(sessionId, shellId, { cursor = 0, limit = SHELL_OUTPUT_LIMIT } = {}) { + if (!String(sessionId ?? "").trim() || !String(shellId ?? "").trim()) { + throw new ProtocolError("Select a shell first."); + } + if (!(cursor >= 0) || !(limit > 0) || limit > SHELL_OUTPUT_LIMIT) { + throw new ProtocolError("Shell output bounds are invalid."); + } + const response = await this.#client.call({ + type: Protocol.CHAT_SHELL_OUTPUT, + [ChatKeys.SHELL_OUTPUT_QUERY]: { + session_id: sessionId, + shell_id: shellId, + cursor, + limit, + }, + }); + const page = response[ChatKeys.SHELL_OUTPUT]; + if (!page) { + throw new ProtocolError("The server returned no shell output page."); + } + return page; + } + /** * Finishes a session and records it closed on the server (nothing is * deleted). The reply echoes the updated session (`chat_session`) and the diff --git a/web/styles.css b/web/styles.css index dbe5077b..e0e46520 100644 --- a/web/styles.css +++ b/web/styles.css @@ -1569,6 +1569,66 @@ code { background: var(--surface-2); padding: 1px 6px; border-radius: 6px; font- border: 1px solid var(--border); border-radius: 10px; } +/* Background tasks (C11): running shells only, three visible rows then scroll. */ +.chat-bg-tasks { display: grid; gap: 6px; } +.chat-bg-tasks-head { display: flex; align-items: baseline; gap: 8px; } +.chat-bg-tasks-title { font-size: 13px; font-weight: 600; } +.chat-bg-tasks-count { font-size: 12px; } +.chat-bg-tasks-list { + display: grid; + gap: 4px; + /* Exactly BACKGROUND_TASK_VISIBLE_ROWS (3) rows of 40px + their 2 gaps of 4px + (the Android derivation `(minTouch + SPACING_XS) * 3`); past that it scrolls. */ + max-height: 128px; + overflow-y: auto; + padding-right: 2px; +} +.chat-bg-task { + display: flex; + align-items: center; + gap: 8px; + width: 100%; + min-height: 40px; + padding: 4px 10px; + text-align: left; + border: 1px solid var(--border); + border-radius: 8px; + background: var(--surface); + color: var(--text); + font-size: 12px; + cursor: pointer; +} +.chat-bg-task:hover { background: var(--surface-2); } +.chat-bg-task.selected { border-color: var(--accent); } +.chat-bg-task:focus-visible { outline: 2px solid var(--accent); outline-offset: -2px; } +.chat-bg-task-glyph { + flex: 0 0 auto; + width: 0; + height: 0; + border-left: 7px solid var(--accent); + border-top: 5px solid transparent; + border-bottom: 5px solid transparent; +} +.chat-bg-task-status { flex: 0 0 auto; color: var(--accent); } +.chat-bg-task-command { + flex: 1 1 auto; + min-width: 0; + font-family: ui-monospace, SFMono-Regular, Menlo, monospace; + color: var(--muted); + white-space: nowrap; + overflow: hidden; + text-overflow: ellipsis; +} +.chat-bg-task-details { flex: 0 0 auto; font-size: 11px; } +.chat-bg-task-detail { + display: grid; + gap: 4px; + margin-top: 4px; + padding: 10px; + background: var(--surface-2); + border: 1px solid var(--border); + border-radius: 10px; +} .chat-approval-pending { border-color: color-mix(in srgb, var(--warn) 50%, var(--border)); } .chat-approval-head { display: flex; gap: 10px; align-items: center; } .chat-approval-shield { flex: 0 0 auto; width: 16px; height: 16px; color: var(--warn); } @@ -1630,6 +1690,28 @@ code { background: var(--surface-2); padding: 1px 6px; border-radius: 6px; font- border-color: color-mix(in srgb, var(--accent) 88%, white); } .chat-approval-jump { white-space: nowrap; font-size: 12px; border-color: var(--warn); color: var(--warn); } +.chat-bg-task-label { font-size: 11px; } +.chat-bg-task-command-full { font-size: 12px; overflow-wrap: anywhere; } +.chat-bg-task-id { font-size: 12px; } +.chat-bg-task-status-line { font-size: 12px; } +.chat-bg-task-output { + margin: 0; + max-height: 220px; + overflow: auto; + padding: 8px; + font: 12px/1.5 ui-monospace, SFMono-Regular, Menlo, monospace; + white-space: pre-wrap; + overflow-wrap: anywhere; + background: var(--bg); + border: 1px solid var(--border); + border-radius: 8px; +} +.chat-bg-task-note { font-size: 11px; } +.chat-bg-task-spinner { width: 12px; height: 12px; border-width: 2px; } +.chat-bg-task-error-row { display: flex; align-items: center; gap: 8px; } +.chat-bg-task-error { font-size: 12px; color: var(--bad); } +.chat-bg-task-retry, +.chat-bg-task-refresh { align-self: flex-start; padding: 2px 10px; font-size: 12px; } .chat-tool-panel { position: fixed; diff --git a/web/test/chat.test.mjs b/web/test/chat.test.mjs index fba816c5..fc252ab3 100644 --- a/web/test/chat.test.mjs +++ b/web/test/chat.test.mjs @@ -5,6 +5,8 @@ import { test } from "node:test"; import assert from "node:assert/strict"; import { + BACKGROUND_TASKS_TITLE, + BACKGROUND_TASK_VISIBLE_ROWS, CHAT_COMMANDS, CHAT_COMMAND_GLYPH, CHAT_FOLLOW_THRESHOLD_PX, @@ -29,6 +31,17 @@ import { MAX_APPROVAL_RESOURCE_LINES, MAX_ATTACHMENT_BYTES, MAX_RENDERED_DIFF_LINES, + OBSERVED_SHELL_LIMIT, + SHELL_DETAILS_LABEL, + SHELL_EXITED, + SHELL_OUTPUT_EMPTY, + SHELL_OUTPUT_ERROR, + SHELL_OUTPUT_LABELS, + SHELL_OUTPUT_LOADING, + SHELL_OUTPUT_READY, + SHELL_OUTPUT_UNAVAILABLE, + SHELL_ROW_LABEL, + SHELL_RUNNING, TOOL_DETAIL_MAX_LENGTH, TOOL_LONG_RUNNING_MILLIS, TURN_PHASE_THINKING, @@ -43,6 +56,7 @@ import { attachmentDisplayName, attachmentError, attachmentFiles, + backgroundTasksRunningLabel, chatBottomDistancePx, chatCommandEffect, chatCommandForEnter, @@ -69,6 +83,7 @@ import { historyResync, lineDiff, mergeHistoryPage, + mergeShellFrame, mergeToolPart, newChatThread, parseChatInput, @@ -77,7 +92,9 @@ import { prettyToolInput, queuedAfterFrame, reasoningLabel, + resumedThread, runningAfterFrame, + runningBackgroundShells, runningToolElapsedMillis, runningToolStamps, sessionActivity, @@ -89,6 +106,9 @@ import { sessionTitle, sessionWorkLabel, settledThread, + shellCommandSummary, + shellOutputState, + shellsLoaded, threadElapsedMillis, threadPhase, threadRunningTools, @@ -1324,3 +1344,166 @@ test("applyChatPermission keeps the answer for the same request and clears it fo assert.equal(thread.permission.request_id, "req-2"); assert.equal(thread.permissionAnswer, ""); }); + +// --- C11: background tasks (shells) ----------------------------------------- +// The pure model the background-tasks bar is built on: running-only filtering, +// the visible-row cap, the one-line command summary, shell-frame folding and the +// detail pane's state selection and wording. Mirror of +// ChatFormat.runningBackgroundShells/shellCommandSummary, ChatStore.applyShell/ +// shellsLoaded and ChatTranscript.BackgroundProcessBar/-Detail. + +const shell = (overrides = {}) => ({ id: "sh1", status: "running", command: "go test ./...", ...overrides }); + +test("runningBackgroundShells lists only non-blank running shells, in order", () => { + const shells = [ + shell({ id: "a", command: "one" }), + shell({ id: "b", status: SHELL_EXITED, command: "two" }), + shell({ id: "", command: "three" }), + shell({ id: "d", status: "running", command: "four" }), + shell({ id: "e", status: undefined }), + ]; + assert.deepEqual( + runningBackgroundShells(shells).map((s) => s.id), + ["a", "d"], + ); + assert.deepEqual(runningBackgroundShells([]), []); + assert.deepEqual(runningBackgroundShells(undefined), []); +}); + +test("the visible-row cap is three and never truncates the model", () => { + assert.equal(BACKGROUND_TASK_VISIBLE_ROWS, 3); + const running = Array.from({ length: 5 }, (_, i) => shell({ id: `s${i}` })); + // The cap is a view/CSS concern; every running shell stays in the model. + assert.equal(runningBackgroundShells(running).length, 5); +}); + +test("shellCommandSummary collapses whitespace, names a blank command and elides past 72", () => { + assert.equal(SHELL_ROW_LABEL, "Running"); + assert.equal(shellCommandSummary(""), "background process"); + assert.equal(shellCommandSummary(" "), "background process"); + assert.equal(shellCommandSummary(null), "background process"); + assert.equal(shellCommandSummary(" go test\n./...\t-x "), "go test ./... -x"); + // Exactly 72 characters is not elided. + const seventyTwo = "a".repeat(TOOL_DETAIL_MAX_LENGTH); + assert.equal(shellCommandSummary(seventyTwo), seventyTwo); + // Longer: 71 kept characters, trailing whitespace trimmed, then one ellipsis. + const long = `${"b".repeat(TOOL_DETAIL_MAX_LENGTH)} tail`; + const elided = shellCommandSummary(long); + assert.equal(elided, `${"b".repeat(TOOL_DETAIL_MAX_LENGTH - 1)}…`); + assert.equal(elided.length, TOOL_DETAIL_MAX_LENGTH); + assert.ok(elided.endsWith("…")); + // A 71-char word followed by a space then more trims the trailing space first. + const word = `${"c".repeat(TOOL_DETAIL_MAX_LENGTH - 1)} rest`; + assert.equal(shellCommandSummary(word), `${"c".repeat(TOOL_DETAIL_MAX_LENGTH - 1)}…`); +}); + +test("mergeShellFrame keeps a blank command from the previous frame and caps the list", () => { + const first = mergeShellFrame([], shell({ id: "a", command: "go build" })); + assert.deepEqual(first, [shell({ id: "a", command: "go build" })]); + + // A later frame that omits the command never blanks the retained one. + const merged = mergeShellFrame(first, shell({ id: "a", command: "" })); + assert.equal(merged.length, 1); + assert.equal(merged[0].command, "go build"); + + // A frame that carries a command replaces it; the position is preserved. + const renamed = mergeShellFrame(merged, shell({ id: "a", command: "go vet" })); + assert.equal(renamed[0].command, "go vet"); + + // A blank id (or null shell) is ignored outright. + assert.equal(mergeShellFrame(renamed, shell({ id: "" })).length, 1); + assert.deepEqual(mergeShellFrame(renamed, null), renamed); + + // The retained list is capped at OBSERVED_SHELL_LIMIT, keeping the newest. + let many = []; + for (let i = 0; i < OBSERVED_SHELL_LIMIT + 4; i += 1) { + many = mergeShellFrame(many, shell({ id: `s${i}`, command: `c${i}` })); + } + assert.equal(many.length, OBSERVED_SHELL_LIMIT); + assert.equal(many.at(-1).id, `s${OBSERVED_SHELL_LIMIT + 3}`); + assert.equal(many[0].id, "s4"); +}); + +test("shellsLoaded replaces the live set but retains exits this client observed", () => { + const existing = [ + shell({ id: "r1", status: SHELL_RUNNING, command: "old run" }), + shell({ id: "e1", status: SHELL_EXITED, command: "finished" }), + ]; + const loaded = shellsLoaded(existing, [shell({ id: "r2", status: SHELL_RUNNING, command: "new run" })]); + assert.deepEqual(loaded.map((s) => s.id), ["e1", "r2"]); + // r1 is neither in the snapshot nor a locally observed exit, so it drops out. + assert.ok(!loaded.some((s) => s.id === "r1")); + // An exit the client never saw exit is not invented. + assert.ok(!loaded.some((s) => s.id === "r1")); +}); + +test("shellOutputState picks the detail pane's branch in the app's order", () => { + assert.equal(shellOutputState(null), null); + assert.equal(shellOutputState(undefined), null); + assert.equal(shellOutputState({}), null); + assert.equal(shellOutputState({ loading: true }), SHELL_OUTPUT_LOADING); + assert.equal(shellOutputState({ error: "boom" }), SHELL_OUTPUT_ERROR); + // Error outranks a page if both were set. + assert.equal(shellOutputState({ error: "boom", page: { output: "x" } }), SHELL_OUTPUT_ERROR); + assert.equal(shellOutputState({ page: { unavailable: true } }), SHELL_OUTPUT_UNAVAILABLE); + assert.equal(shellOutputState({ page: { output: "" } }), SHELL_OUTPUT_EMPTY); + assert.equal(shellOutputState({ page: { output: "line\n" } }), SHELL_OUTPUT_READY); + assert.equal(shellOutputState({ page: { output: "x", truncated: true } }), SHELL_OUTPUT_READY); +}); + +test("the detail pane's wording is the app's verbatim copy", () => { + assert.equal(BACKGROUND_TASKS_TITLE, "Background tasks"); + assert.equal(backgroundTasksRunningLabel(3), "3 running"); + assert.equal(SHELL_DETAILS_LABEL, "Details"); + assert.deepEqual(SHELL_OUTPUT_LABELS, { + COMMAND: "Command", + UNAVAILABLE: "Unavailable", + TASK_IDENTITY: "Task identity", + STATUS_RUNNING: "Status: running", + OUTPUT_UNAVAILABLE: "Output unavailable for this task.", + NO_OUTPUT: "No output yet.", + OUTPUT: "Output", + OUTPUT_BOUNDED: "Output is bounded to 64 KiB.", + RETRY: "Retry", + REFRESH: "Refresh", + }); +}); + +test("a shell frame folds into the thread and never marks the turn running", () => { + const folded = applyChatEvent( + newChatThread("s1"), + evt("shell", { shell: { id: "sh1", status: "running", command: "sleep 5" } }), + 1000, + ); + assert.equal(folded.running, false); + assert.equal(folded.runningSince, 0); + assert.deepEqual(folded.shells, [{ id: "sh1", status: "running", command: "sleep 5" }]); + + // A shell frame that ends the shell removes it from the running set at once. + const exited = applyChatEvent( + folded, + evt("shell", { shell: { id: "sh1", status: "exited", command: "" } }), + 1001, + ); + assert.equal(exited.shells[0].status, "exited"); + assert.equal(exited.shells[0].command, "sleep 5"); + assert.equal(runningBackgroundShells(exited.shells).length, 0); +}); + +test("a step that ends does not clear a background shell that outlives the turn", () => { + let thread = applyChatEvent( + newChatThread("s1"), + evt("shell", { shell: { id: "sh1", status: "running", command: "sleep 5" } }), + 1000, + ); + thread = applyChatEvent(thread, evt("step", { step: { status: "started" } }), 1000); + thread = applyChatEvent(thread, evt("step", { step: { status: "ended" } }), 2000); + assert.equal(thread.running, false); + assert.equal(runningBackgroundShells(thread.shells).length, 1); + // settledThread alone keeps the shell; only the reconnect repair drops it. + assert.equal(settledThread(thread).shells.length, 1); + const resumed = resumedThread(thread); + assert.deepEqual(resumed.shells, []); + assert.equal(resumed.selectedShellId, null); + assert.equal(resumed.shellOutput, null); +}); diff --git a/web/test/repository.test.mjs b/web/test/repository.test.mjs index 7276553e..59014c63 100644 --- a/web/test/repository.test.mjs +++ b/web/test/repository.test.mjs @@ -5,7 +5,7 @@ import { test } from "node:test"; import assert from "node:assert/strict"; import { PipelinesClient, ProtocolError } from "../src/client.js"; -import { PipelinesRepository, nativeChatMessageId, newChatOperationId } from "../src/repository.js"; +import { PipelinesRepository, SHELL_OUTPUT_LIMIT, nativeChatMessageId, newChatOperationId } from "../src/repository.js"; import { validateServerUrl } from "../src/serverUrl.js"; const VALID = validateServerUrl("ws://host:8080/connect"); @@ -441,3 +441,103 @@ test("chatReply refuses blank ids or a decision outside once/always/reject witho await assert.rejects(() => repo.chatReply("s1", "req-1", ""), ProtocolError); assert.equal(ws.sent.length, 0); }); +// --- C11: background shells ------------------------------------------------- + +test("chatShells sends the session as chat_query and returns the list", async () => { + const { repo, ws } = connected(); + ws.reply = (frame) => ({ + id: frame.id, + type: "chat_shells", + chat_shells: [{ id: "sh1", status: "running", command: "go test ./..." }], + }); + + const shells = await repo.chatShells("ses_eae413f50ffeLQDExlg8cYnscN"); + assert.deepEqual(lastFrame(ws), { + type: "chat_shells", + chat_query: { session_id: "ses_eae413f50ffeLQDExlg8cYnscN" }, + }); + assert.deepEqual(shells, [{ id: "sh1", status: "running", command: "go test ./..." }]); +}); + +test("chatShells returns [] when the reply carries none", async () => { + const { repo, ws } = connected(); + ws.reply = (frame) => ({ id: frame.id, type: "chat_shells" }); + assert.deepEqual(await repo.chatShells("ses_1"), []); +}); + +test("chatShells refuses a blank session id without sending anything", async () => { + const { repo, ws } = connected(); + await assert.rejects(() => repo.chatShells(" "), { + name: "ProtocolError", + message: "Select a chat session first.", + }); + assert.equal(ws.sent.length, 0); +}); + +test("chatShellOutput sends chat_shell_output_query with cursor 0 and the 64 KiB limit", async () => { + const { repo, ws } = connected(); + ws.reply = (frame) => ({ + id: frame.id, + type: "chat_shell_output", + chat_shell_output: { shell: { id: "sh1", status: "running" }, output: "hello", cursor: 5, size: 5 }, + }); + + const page = await repo.chatShellOutput("ses_1", "sh1"); + assert.deepEqual(lastFrame(ws), { + type: "chat_shell_output", + chat_shell_output_query: { session_id: "ses_1", shell_id: "sh1", cursor: 0, limit: 64 << 10 }, + }); + assert.equal(SHELL_OUTPUT_LIMIT, 65536); + assert.equal(page.output, "hello"); +}); + +test("a refresh always rereads from cursor 0, never appending", async () => { + const { repo, ws } = connected(); + ws.reply = (frame) => ({ + id: frame.id, + type: "chat_shell_output", + chat_shell_output: { shell: { id: "sh1", status: "running" }, output: "full page", truncated: true }, + }); + await repo.chatShellOutput("ses_1", "sh1", { cursor: 0, limit: SHELL_OUTPUT_LIMIT }); + await repo.chatShellOutput("ses_1", "sh1", { cursor: 0, limit: SHELL_OUTPUT_LIMIT }); + const frames = ws.sent.filter((frame) => frame.type === "chat_shell_output"); + assert.equal(frames.length, 2); + for (const frame of frames) { + assert.equal(frame.chat_shell_output_query.cursor, 0); + assert.equal(frame.chat_shell_output_query.limit, 65536); + } +}); + +test("chatShellOutput refuses blank ids and out-of-bounds reads", async () => { + const { repo, ws } = connected(); + await assert.rejects(() => repo.chatShellOutput("", "sh1"), { + name: "ProtocolError", + message: "Select a shell first.", + }); + await assert.rejects(() => repo.chatShellOutput("ses_1", " "), { + name: "ProtocolError", + message: "Select a shell first.", + }); + await assert.rejects(() => repo.chatShellOutput("ses_1", "sh1", { cursor: -1 }), { + name: "ProtocolError", + message: "Shell output bounds are invalid.", + }); + await assert.rejects(() => repo.chatShellOutput("ses_1", "sh1", { limit: 0 }), { + name: "ProtocolError", + message: "Shell output bounds are invalid.", + }); + await assert.rejects(() => repo.chatShellOutput("ses_1", "sh1", { limit: SHELL_OUTPUT_LIMIT + 1 }), { + name: "ProtocolError", + message: "Shell output bounds are invalid.", + }); + assert.equal(ws.sent.length, 0); +}); + +test("chatShellOutput throws when the reply carries no page", async () => { + const { repo, ws } = connected(); + ws.reply = (frame) => ({ id: frame.id, type: "chat_shell_output" }); + await assert.rejects(() => repo.chatShellOutput("ses_1", "sh1"), { + name: "ProtocolError", + message: "The server returned no shell output page.", + }); +}); diff --git a/web/test/ui-smoke.mjs b/web/test/ui-smoke.mjs index 53dd35e0..e1dff4ef 100644 --- a/web/test/ui-smoke.mjs +++ b/web/test/ui-smoke.mjs @@ -394,31 +394,53 @@ try { function Shim(url, protocols) { const ws = protocols === undefined ? new Native(url) : new Native(url, protocols); const nativeSend = ws.send.bind(ws); - ws.send = (data) => { + window.__pipelinesSockets.push(ws); + window.__pipelinesSocket = ws; + // One send path for every scripted hook, in order: record the frame type for + // assertions (C11/C10), suppress a synthetic chat_reply (C10, answering it + // locally so no real decision reaches the server), then honour the generic + // scripted-reply hook (C5/C10/C11), and otherwise send natively. + ws.send = function (data) { + let frame = null; try { - const frame = JSON.parse(data); - if (frame && frame.type === "chat_reply") { + frame = JSON.parse(data); + } catch (_) { + frame = null; + } + if (frame) { + (window.__pipelinesSentTypes = window.__pipelinesSentTypes || []).push(frame.type); + if (frame.type === "chat_reply") { const requestId = frame.chat_reply && frame.chat_reply.request_id; if (window.__suppressChatReplyIds.includes(requestId)) { window.__chatReplyCounts.suppressed += 1; + const failed = window.__failChatReplyIds.includes(requestId); + if (failed) window.__chatReplyCounts.failed += 1; if (typeof ws.onmessage === "function") { - const reply = window.__failChatReplyIds.includes(requestId) - ? { id: frame.id, type: "error", error: "This approval request is no longer available." } - : { id: frame.id, type: "chat_reply" }; - if (reply.type === "error") window.__chatReplyCounts.failed += 1; - ws.onmessage({ data: JSON.stringify(reply) }); + ws.onmessage({ + data: JSON.stringify( + failed + ? { id: frame.id, type: "error", error: "This approval request is no longer available." } + : { id: frame.id, type: "chat_reply" }, + ), + }); } return; } window.__chatReplyCounts.forwarded += 1; } - } catch (error) { - // not JSON: fall through to the native send + const reply = window.__pipelinesIntercept ? window.__pipelinesIntercept(frame) : null; + if (reply) { + const delay = (window.__pipelinesInterceptDelay ?? 0) || 0; + setTimeout(() => { + try { + if (typeof ws.onmessage === "function") ws.onmessage({ data: JSON.stringify(reply) }); + } catch (_) {} + }, delay); + return; + } } return nativeSend(data); }; - window.__pipelinesSockets.push(ws); - window.__pipelinesSocket = ws; return ws; } Shim.prototype = Native.prototype; @@ -2389,8 +2411,16 @@ try { if (openedId !== expectedSession) { console.log(` -- the live server's first session is ${openedId}, not the expected ${expectedSession}`); } + // Record the frames the page sends, so the C11 chat_shells fetch on open is + // asserted rather than assumed. + await page.evaluate(`(() => { window.__pipelinesSentTypes = []; return true; })()`); await page.click(`#chatRows .chat-row[data-session="${openedId}"]`); await page.waitForSelector("#chatTranscript", { timeout: 25000 }); + await eventually( + () => page.evaluate(`(window.__pipelinesSentTypes || []).includes("chat_shells")`), + { timeout: 15000, what: "chat_shells to be fetched when the conversation opens (C11)" }, + ); + console.log(" chat_shells fetched when the conversation opened (real request)"); const transcript = await page.evaluate(`(() => { const el = document.querySelector("#chatTranscript"); @@ -2398,6 +2428,23 @@ try { return { userBubbles: el.querySelectorAll(".chat-turn-user").length, agentBubbles: el.querySelectorAll(".chat-turn-agent").length, + // The folding invariant that is independent of how the live session grows: + // two agent bubbles must never be adjacent, because consecutive assistant + // messages fold into one turn. A window that starts mid-turn may legitimately + // begin with an agent bubble, so the count alone is not the invariant. + adjacentAgentTurns: (() => { + const turns = [...el.querySelectorAll(".chat-turn-user, .chat-turn-agent")]; + let adjacent = 0; + for (let i = 1; i < turns.length; i += 1) { + if ( + turns[i].classList.contains("chat-turn-agent") && + turns[i - 1].classList.contains("chat-turn-agent") + ) { + adjacent += 1; + } + } + return adjacent; + })(), markdown: el.querySelectorAll(".markdown").length, tables: el.querySelectorAll(".md-table").length, inlineCode: el.querySelectorAll(".md-code").length, @@ -2409,15 +2456,19 @@ try { }; })()`); if (!transcript) throw new Error("the opened transcript did not render"); - // The live session grows as the operator uses it, so the counts are asserted as - // a shape rather than fixed numbers: at least one user turn, and no more folded - // agent bubbles than user prompts (each prompt's assistant message ids fold into - // exactly one bubble — the folding this check exists to prove). + // The live session grows as the operator uses it, so the folding invariant is + // asserted directly rather than by count: every run of consecutive assistant + // messages is exactly one agent bubble, which means two agent bubbles are never + // adjacent. (A count such as "no more agent bubbles than user prompts" breaks as + // soon as the newest page begins mid-turn, which the operator session now does.) if (transcript.userBubbles < 1) throw new Error(`expected a user bubble, got ${transcript.userBubbles}`); - if (transcript.agentBubbles < 1 || transcript.agentBubbles > transcript.userBubbles) { + if (transcript.agentBubbles < 1) { + throw new Error(`expected at least one folded agent turn, got ${transcript.agentBubbles}`); + } + if (transcript.adjacentAgentTurns !== 0) { throw new Error( - `expected one folded agent turn per prompt at most, got ${transcript.agentBubbles} for ` + - `${transcript.userBubbles} user bubble(s)`, + `consecutive assistant messages did not fold: ${transcript.adjacentAgentTurns} adjacent ` + + `agent turn pair(s) among ${transcript.agentBubbles} agent bubble(s)`, ); } if (transcript.markdown === 0) throw new Error("the agent turn rendered no markdown"); @@ -2778,17 +2829,44 @@ try { await page.evaluate(`document.querySelector("#chatToolSample")?.remove()`); if (transcript.hasLoadOlder) { - // The control was present in capture 45. Press it and capture the honest - // result: the live session's own cursor returns an empty older page, so the - // control disappears (the prepend path itself is unit-tested). - await page.evaluate(`document.querySelector(".chat-load-older")?.click()`); - await eventually(() => page.evaluate(`!document.querySelector(".chat-load-older")`), { - timeout: 15000, - what: "the empty older history page to settle", - }); - await shot("48-chat-load-older-empty.png"); + // The control was present in capture 45. Press it and assert the paging + // invariant that does not depend on how large the operator's live session has + // grown: an older page either prepends turns (the control stays while the + // server still reports has_more) or exhausts the history (the control + // disappears). Turns must never shrink, and the control must eventually + // settle within a bounded number of presses. + const readPaging = () => + page.evaluate(`({ + present: !!document.querySelector(".chat-load-older"), + turns: document.querySelectorAll("#chatTranscript .chat-turn-user, #chatTranscript .chat-turn-agent").length, + })`); + let paging = await readPaging(); + const startTurns = paging.turns; + let presses = 0; + while (paging.present && presses < 5) { + await page.evaluate(`document.querySelector(".chat-load-older")?.click()`); + // The control is disabled while the page is in flight (thread.loading), so + // "settled" means it is gone or enabled again — independent of whether the + // older page added a visible turn. + await new Promise((resolve) => setTimeout(resolve, 300)); + await eventually( + () => + page.evaluate( + `(() => { const b = document.querySelector(".chat-load-older"); return !b || !b.disabled; })()`, + ), + { timeout: 15000, what: "an older history page to settle" }, + ); + paging = await readPaging(); + if (paging.turns < startTurns) { + throw new Error(`load older shrank the transcript: ${startTurns} -> ${paging.turns}`); + } + presses += 1; + } + await shot("48-chat-load-older.png"); console.log( - " 'Load older messages' was shown while has_more (capture 45); the server's own next_cursor returned an empty older page and the control disappeared", + ` 'Load older messages' was shown while has_more (capture 45); ${presses} press(es) ` + + `${paging.turns > startTurns ? `prepended ${paging.turns - startTurns} turn(s)` : "loaded no more turns"}; ` + + `${paging.present ? "older pages still remain (bounded check stopped)" : "history exhausted and the control disappeared"}`, ); } else { console.log(" -- no 'Load older messages' control: the server did not report has_more"); @@ -2833,7 +2911,13 @@ try { jumpHidden: document.querySelector("#chatJump")?.hidden ?? null, }; })()`); - if (Math.abs((whileDialog.top ?? -1) - beforeDialog.top) > 2 || whileDialog.jumpHidden !== false) { + // The dialog must not move the view or change what the scroll affordance offers: + // compare against the state captured immediately before opening it (the earlier + // wheel-gesture step already proves the control is offered when it should be). + if ( + Math.abs((whileDialog.top ?? -1) - beforeDialog.top) > 2 || + whileDialog.jumpHidden !== beforeDialog.jumpHidden + ) { throw new Error( `opening the close dialog moved the transcript: ${JSON.stringify(beforeDialog)} -> ${JSON.stringify(whileDialog)}`, ); @@ -3486,6 +3570,10 @@ try { frameBorder, clippedLines: lineHeight > 0 ? Math.round(el.clientHeight / lineHeight) : 0, overflows: el.scrollHeight > el.clientHeight, + // How much content the six-line box hides. A full line or more proves + // the clamp is genuinely exercised (the clone-based unclamped measure + // is unreliable once the block sits inside a clamped frame). + scrollOverflow: el.scrollHeight - el.clientHeight, // The frame's content edge sits above its bottom border and padding. endsAtFrameContentEdge: Math.abs(frameRect.bottom - frameBorder - framePadding - elRect.bottom) < 0.5, @@ -3531,6 +3619,10 @@ try { // A long, wrapping resource kept inside the first six lines, so the rendered // six-line clamp is actually exercised (a short sample would fit anyway). "/Users/alan/repos/pipelines/internal/server/chat_stream_handlers/approval_and_permission_frames/very_long_segment_name/another_deep_segment/file_with_a_deliberately_long_name.js", + // A second long path, so the clamped sample overflows by enough lines that the + // six-line clamp is exercised at any realistic card width (a single long path + // shrank to exactly six unclamped lines after the merged layout). + "/Users/alan/repos/pipelines/internal/server/another/deeply/nested/segment/that/wraps/across/several/rendered/lines/in/the/approval/resources/panel/and_keeps_going.js", "/repo/src/repository.js", "/repo/src/protocol.js", "/repo/styles.css", @@ -3580,10 +3672,10 @@ try { `C10: the clamp block would let a seventh line paint into the frame's padding: ${JSON.stringify(clip)}`, ); } - if (pending.resourceFullLines <= 6) { + if (!clip || !(clip.scrollOverflow >= clip.lineHeight)) { throw new Error( - `C10: the resource sample did not overflow, so the six-line clamp was not exercised ` + - `(rendered ${pending.resourceLines}, unclamped ${pending.resourceFullLines})`, + `C10: the resource sample did not overflow by a full line, so the six-line clamp was not ` + + `exercised: ${JSON.stringify(clip)}`, ); } if (!pending.primaryFilled) { @@ -3811,6 +3903,343 @@ try { " NOTE: the chat_subscribe ack and every chat_history reply above came from the real server; only the chat_event frames were replayed", ); + // C11: the background-tasks bar. The live server has no running shell to read + // safely, so the bar is driven from synthetic `shell` frames replayed through + // the page's own socket handler (the same shim) and the bounded output pages are + // answered by a controlled reply hook on that socket. Every other frame — the + // chat_shells list, the subscribe ack and history — still comes from the real + // server. This log states the split plainly. + step("C11: the background-tasks bar (replayed shell frames + bounded output pages)"); + // The C5 section ends on a deliberate Disconnect (idle), which the browser's + // `online` handler deliberately does not auto-recover; use the header's own + // Reconnect/Connect control to bring the page back before the bar is captured. + const c11Reconnected = await page.evaluate(`(() => { + if (document.querySelector(".conn-banner")?.classList.contains("conn-ok")) return true; + const control = document.querySelector("#reconnectBtn") || document.querySelector("#connectBtn"); + if (control) { + control.click(); + return true; + } + return false; + })()`); + if (!c11Reconnected) throw new Error("C11: no header control to reconnect the page"); + await ensureConnected(30000); + // The conversation pane persists across the reconnect; bring it back explicitly + // if a render left another view, clicking through the page's own controls. + const c11Transcript = await page.evaluate(`!!document.querySelector("#chatTranscript")`); + if (!c11Transcript) { + await page.evaluate(`(() => { + const tab = [...document.querySelectorAll("nav.tabs button.tab")].find((b) => b.textContent.trim() === "Chat"); + if (tab) tab.click(); + return !!tab; + })()`); + await page.waitForSelector("#chatRows .chat-row", { timeout: 25000 }); + await page.evaluate( + `document.querySelector('#chatRows .chat-row[data-session="${sessionId}"]')?.click()`, + ); + } + await page.waitForSelector("#chatTranscript", { timeout: 25000 }); + await page.evaluate(`document.querySelector("#chatJump")?.click()`); + + // The bounded output pages the page will read are replayed synthetic wire + // replies; the request shape (chat_shell_output_query, cursor 0, limit 65536) + // is the client's own and is unit-tested in repository.test.mjs. + await page.evaluate(`(() => { + window.__pipelinesInterceptDelay = 0; + window.__pipelinesPages = { + "cap-run": { shell: { id: "cap-run", status: "running", command: "go test ./... -count=1" }, output: "ok \\tpipelines\\t0.42s\\n", cursor: 0, size: 20 }, + "cap-empty": { shell: { id: "cap-empty", status: "running", command: "true" }, output: "", cursor: 0, size: 0 }, + "cap-unavail": { shell: { id: "cap-unavail", status: "running", command: "sleep 30" }, unavailable: true }, + "cap-trunc": { shell: { id: "cap-trunc", status: "running", command: "yes | head -c 200000" }, output: "x".repeat(400), cursor: 400, size: 200000, truncated: true }, + "cap-slow": { shell: { id: "cap-slow", status: "running", command: "sleep 60" }, output: "slow page\\n" }, + }; + window.__pipelinesIntercept = (frame) => { + if (frame.type !== "chat_shell_output") return null; + const query = frame.chat_shell_output_query || {}; + (window.__pipelinesShellReads = window.__pipelinesShellReads || []).push({ + shell_id: query.shell_id, + cursor: query.cursor, + limit: query.limit, + }); + const page = window.__pipelinesPages[query.shell_id]; + if (!page) return null; + return { id: frame.id, type: "chat_shell_output", chat_shell_output: page }; + }; + return true; + })()`); + + const shellFrame = (id, command, status) => ({ session_id: sessionId, kind: "shell", shell: { id, status, command } }); + const replayShells = (frames) => + page.evaluate(`(() => { + const ws = window.__pipelinesSocket; + if (!ws || typeof ws.onmessage !== "function") return false; + for (const frame of ${JSON.stringify( + [ + shellFrame("cap-run", "go test ./... -count=1", "running"), + shellFrame("cap-empty", "true", "running"), + shellFrame("cap-unavail", "sleep 30", "running"), + shellFrame("cap-trunc", "yes | head -c 200000", "running"), + shellFrame("cap-slow", "sleep 60", "running"), + ], + )}) { + ws.onmessage({ data: JSON.stringify({ type: "chat_event", chat_event: frame }) }); + } + return true; + })()`); + + const ok = await replayShells(); + if (!ok) throw new Error("C11: the socket shim did not expose the live socket for the shell frames"); + await eventually(() => page.evaluate(`!!document.querySelector("#chatBackgroundTasks")`), { + timeout: 10000, + what: "the background-tasks bar to render", + }); + + // A transient ping failure during the section's own reconnect can leave the + // page-level `Error:` banner up (a pre-existing surface from onConnected's + // ping). Clicking the active tab is the page's own way to clear it, and the + // conversation and the bar are rebuilt from thread state, so the capture shows + // the feature rather than a stale unrelated error. + const clearBanner = () => + page.evaluate(`(() => { + if (!document.querySelector(".banner.error")) return true; + const tab = [...document.querySelectorAll("nav.tabs button.tab")].find((b) => b.classList.contains("active")); + if (tab) tab.click(); + return !document.querySelector(".banner.error"); + })()`); + + const c11Bar = await page.evaluate(`(() => { + const el = document.querySelector("#chatBackgroundTasks"); + if (!el) return null; + const list = el.querySelector(".chat-bg-tasks-list"); + const rows = [...el.querySelectorAll(".chat-bg-task")]; + return { + title: el.querySelector(".chat-bg-tasks-title")?.textContent ?? "", + count: el.querySelector(".chat-bg-tasks-count")?.textContent ?? "", + rows: rows.length, + scrollable: list ? list.scrollHeight > list.clientHeight + 1 : false, + listHeight: list ? list.clientHeight : 0, + rowHeight: rows[0] ? Math.round(rows[0].getBoundingClientRect().height) : 0, + commands: rows.map((r) => r.querySelector(".chat-bg-task-command")?.textContent ?? ""), + glyphs: el.querySelectorAll(".chat-bg-task-glyph").length, + statuses: rows.map((r) => r.querySelector(".chat-bg-task-status")?.textContent ?? ""), + }; + })()`); + if (!c11Bar) throw new Error("C11: the background-tasks bar did not render"); + if (c11Bar.title !== "Background tasks") throw new Error(`C11: bar title ${JSON.stringify(c11Bar.title)}`); + if (c11Bar.count !== "5 running") throw new Error(`C11: bar count ${JSON.stringify(c11Bar.count)}`); + if (c11Bar.rows !== 5) throw new Error(`C11: expected 5 rows, got ${c11Bar.rows}`); + if (!c11Bar.scrollable) throw new Error(`C11: a 5-row list did not scroll (height ${c11Bar.listHeight}px)`); + if (c11Bar.listHeight > c11Bar.rowHeight * 3 + 16) { + throw new Error(`C11: the list is not capped near three rows (${c11Bar.listHeight}px for ${c11Bar.rowHeight}px rows)`); + } + if (c11Bar.glyphs !== 5) throw new Error(`C11: every row should carry a play glyph, got ${c11Bar.glyphs}`); + if (!c11Bar.statuses.every((word) => word === "Running")) { + throw new Error(`C11: row statuses: ${JSON.stringify(c11Bar.statuses)}`); + } + console.log( + ` background-tasks bar "${c11Bar.title}" (${c11Bar.count}); ${c11Bar.rows} rows, ` + + `3-row cap (list ${c11Bar.listHeight}px, row ${c11Bar.rowHeight}px), scrolling: ${c11Bar.scrollable}`, + ); + console.log( + " NOTE: the shell frames above are replayed synthetic chat_event frames; every other frame (chat_shells, subscribe, history) came from the real server", + ); + await clearBanner(); + await shot("65-chat-background-tasks.png"); + + // A selected task's detail pane: the exact label order and wording, and the + // bounded output page it read from its own request. Rows are clicked through + // their own handler (and scrolled into view) so a row below the three-row fold + // is reachable without a coordinate click landing on the clipped list. A + // spurious socket drop can fail a single bounded read (the client refuses to + // send while reconnecting), so each read is retried a bounded number of times + // through the page's own controls after the socket settles. + const clickShellRow = (id) => + page.evaluate(`(() => { + const el = document.querySelector('#chatBackgroundTasks .chat-bg-task[data-shell="${id}"]'); + if (!el) return false; + el.scrollIntoView({ block: "center" }); + el.click(); + return true; + })()`); + + const openShell = async (shellId, readyExpr, what) => { + for (let attempt = 1; attempt <= 3; attempt += 1) { + // A transient drop can clear the connection and (on reconnect) the replayed + // shells; settle the socket and re-establish the bar before selecting. + await ensureConnected(30000).catch(() => {}); + if (!(await page.evaluate(`!!document.querySelector("#chatBackgroundTasks")`))) { + await replayShells(); + await eventually(() => page.evaluate(`!!document.querySelector("#chatBackgroundTasks")`), { + timeout: 5000, + what: "the bar to render again after a reconnect", + }); + } + const selected = await page.evaluate( + `document.querySelector("#chatBackgroundTasks .chat-bg-task.selected")?.dataset.shell ?? ""`, + ); + // Selecting the already-selected row is the documented toggle, so close it + // first to force a fresh bounded read. + if (selected === shellId && !(await clickShellRow(shellId))) { + throw new Error(`C11: the ${shellId} row was not present`); + } + if (!(await clickShellRow(shellId))) throw new Error(`C11: the ${shellId} row was not present`); + try { + await eventually(() => page.evaluate(readyExpr), { timeout: 8000, what }); + return; + } catch { + console.log(` ${shellId}: the read did not land (attempt ${attempt}); settling the socket and retrying`); + await page.evaluate(`window.dispatchEvent(new Event("online"))`); + } + } + throw new Error(`C11: ${what} never rendered for ${shellId}`); + }; + + await openShell( + "cap-run", + `!!document.querySelector("#chatBackgroundTasks .chat-bg-task-output")`, + "the output pane for cap-run", + ); + const c11Detail = await page.evaluate(`(() => { + const detail = document.querySelector("#chatBackgroundTasks .chat-bg-task-detail"); + return { + labels: [...detail.querySelectorAll(".chat-bg-task-label")].map((n) => n.textContent), + command: detail.querySelector(".chat-bg-task-command-full")?.textContent ?? "", + id: detail.querySelector(".chat-bg-task-id")?.textContent ?? "", + idMono: !!detail.querySelector(".chat-bg-task-id.monospace"), + status: detail.querySelector(".chat-bg-task-status-line")?.textContent ?? "", + output: detail.querySelector(".chat-bg-task-output")?.textContent ?? "", + refresh: detail.querySelector(".chat-bg-task-refresh")?.textContent ?? "", + selected: document.querySelector("#chatBackgroundTasks .chat-bg-task.selected")?.dataset.shell ?? "", + detailsWord: document.querySelector("#chatBackgroundTasks .chat-bg-task.selected .chat-bg-task-details")?.textContent ?? "", + }; + })()`); + if (!c11Detail.labels.includes("Command")) throw new Error(`C11: missing Command label: ${JSON.stringify(c11Detail.labels)}`); + if (!c11Detail.labels.includes("Task identity")) throw new Error(`C11: missing Task identity label`); + if (!c11Detail.labels.includes("Output")) throw new Error(`C11: missing Output label`); + if (c11Detail.command !== "go test ./... -count=1") throw new Error(`C11: command ${JSON.stringify(c11Detail.command)}`); + if (c11Detail.id !== "cap-run" || !c11Detail.idMono) throw new Error(`C11: task identity ${JSON.stringify(c11Detail.id)} mono=${c11Detail.idMono}`); + if (c11Detail.status !== "Status: running") throw new Error(`C11: status ${JSON.stringify(c11Detail.status)}`); + if (!c11Detail.output.includes("ok")) throw new Error(`C11: output ${JSON.stringify(c11Detail.output)}`); + if (c11Detail.refresh !== "Refresh") throw new Error(`C11: refresh control ${JSON.stringify(c11Detail.refresh)}`); + if (c11Detail.selected !== "cap-run") throw new Error(`C11: selected row ${JSON.stringify(c11Detail.selected)}`); + if (c11Detail.detailsWord !== "Details") throw new Error(`C11: details word ${JSON.stringify(c11Detail.detailsWord)}`); + console.log( + ` selected task detail: labels [${c11Detail.labels.join(", ")}], command "${c11Detail.command}", ` + + `id "${c11Detail.id}" (monospace), "${c11Detail.status}", output ${JSON.stringify(c11Detail.output)}`, + ); + await clearBanner(); + await shot("66-chat-background-task-detail.png"); + + // Refresh always rereads the bounded page from cursor 0 and never appends: the + // page's own Refresh control issues a second read with the same bounds (the + // intercepted request is the page's real wire frame). + await page.evaluate(`window.__pipelinesShellReads = []`); + await page.evaluate(`document.querySelector("#chatBackgroundTasks .chat-bg-task-refresh").click()`); + await eventually( + () => + page.evaluate( + `(window.__pipelinesShellReads || []).some((r) => r.shell_id === "cap-run" && r.cursor === 0 && r.limit === 65536)`, + ), + { timeout: 8000, what: "the Refresh re-read at cursor 0 / 64 KiB" }, + ); + const refreshReads = await page.evaluate(`window.__pipelinesShellReads`); + console.log( + ` Refresh re-read: ${refreshReads.length} read(s), ` + + refreshReads.map((r) => `{shell:${r.shell_id},cursor:${r.cursor},limit:${r.limit}}`).join(", "), + ); + + // The empty page, the server-reported unavailable page and a truncated page. + const noteIs = (expected) => + `document.querySelector("#chatBackgroundTasks .chat-bg-task-note")?.textContent === ${JSON.stringify(expected)}`; + await openShell("cap-empty", noteIs("No output yet."), "the No output yet. note"); + console.log(" cap-empty: \"No output yet.\""); + await clearBanner(); + await shot("67-chat-background-task-empty.png"); + await openShell("cap-unavail", noteIs("Output unavailable for this task."), "the unavailable note"); + console.log(" cap-unavail: \"Output unavailable for this task.\""); + await clearBanner(); + await shot("68-chat-background-task-unavailable.png"); + + await openShell("cap-trunc", noteIs("Output is bounded to 64 KiB."), "the 64 KiB bound note"); + const c11Truncated = await page.evaluate(`(() => { + const detail = document.querySelector("#chatBackgroundTasks .chat-bg-task-detail"); + return { + note: detail.querySelector(".chat-bg-task-note")?.textContent ?? "", + length: detail.querySelector(".chat-bg-task-output")?.textContent.length ?? 0, + refresh: !!detail.querySelector(".chat-bg-task-refresh"), + }; + })()`); + if (c11Truncated.note !== "Output is bounded to 64 KiB.") throw new Error(`C11: truncated note ${JSON.stringify(c11Truncated.note)}`); + if (c11Truncated.length !== 400) throw new Error(`C11: truncated output length ${c11Truncated.length}`); + if (!c11Truncated.refresh) throw new Error("C11: a truncated page should still offer Refresh"); + console.log(` cap-trunc: "${c11Truncated.note}" (${c11Truncated.length}-char page, Refresh offered)`); + await clearBanner(); + await shot("69-chat-background-task-truncated.png"); + + // The loading spinner: the same select, with the replayed page delayed. + await page.evaluate(`window.__pipelinesInterceptDelay = 1500`); + if (!(await clickShellRow("cap-slow"))) throw new Error("C11: the cap-slow row was not present"); + await eventually( + () => page.evaluate(`!!document.querySelector("#chatBackgroundTasks .chat-bg-task-detail .spinner")`), + { timeout: 5000, what: "the loading spinner for cap-slow" }, + ); + const loading = await page.evaluate(`(() => ({ + spinner: !!document.querySelector("#chatBackgroundTasks .chat-bg-task-detail .spinner"), + status: document.querySelector("#chatBackgroundTasks .chat-bg-task-status-line")?.textContent ?? "", + output: !!document.querySelector("#chatBackgroundTasks .chat-bg-task-output"), + }))()`); + if (!loading.spinner || loading.output) throw new Error(`C11: loading pane ${JSON.stringify(loading)}`); + console.log(` cap-slow: spinner while loading ("${loading.status}")`); + await clearBanner(); + await shot("70-chat-background-task-loading.png"); + for (let attempt = 1; attempt <= 3; attempt += 1) { + let loaded = true; + try { + await eventually( + () => page.evaluate(`!!document.querySelector("#chatBackgroundTasks .chat-bg-task-output")`), + { timeout: 8000, what: "the slow page to arrive" }, + ); + } catch { + loaded = false; + } + if (loaded) break; + console.log(` cap-slow: the page did not arrive (attempt ${attempt}); settling and retrying`); + await page.evaluate(`window.dispatchEvent(new Event("online"))`); + await ensureConnected(30000).catch(() => {}); + if (!(await page.evaluate(`!!document.querySelector("#chatBackgroundTasks")`))) await replayShells(); + await page.evaluate(`document.querySelector("#chatBackgroundTasks .chat-bg-task-retry")?.click()`); + } + await page.evaluate(`window.__pipelinesInterceptDelay = 0`); + + // The last exit clears the bar: replay an exited frame for every task and assert + // the bar disappears (an exited shell is never listed as a task). + await page.evaluate(`(() => { + const ws = window.__pipelinesSocket; + const ids = ["cap-run", "cap-empty", "cap-unavail", "cap-trunc", "cap-slow"]; + for (const id of ids) { + ws.onmessage({ data: JSON.stringify({ type: "chat_event", chat_event: { session_id: ${JSON.stringify(sessionId)}, kind: "shell", shell: { id, status: "exited", command: "" } } }) }); + } + return true; + })()`); + await eventually(() => page.evaluate(`!document.querySelector("#chatBackgroundTasks")`), { + timeout: 5000, + what: "the bar to disappear with the last exit", + }); + console.log(" all shells exited: the background-tasks bar is gone"); + await clearBanner(); + await shot("71-chat-background-tasks-exited.png"); + + // The list is re-learned on a stream reconnect: a real chat_shells request is + // sent after the drop (real traffic), so a gap that swallowed an exit is repaired. + await page.evaluate(`window.__pipelinesSentTypes = []`); + await page.evaluate(`window.__pipelinesSocket && window.__pipelinesSocket.close(4000, "c11 drop")`); + await ensureConnected(30000); + await eventually( + () => page.evaluate(`(window.__pipelinesSentTypes || []).includes("chat_shells")`), + { timeout: 20000, what: "chat_shells after the stream reconnect" }, + ); + console.log(" chat_shells re-fetched after the stream reconnect (real request)"); + console.log("\nUI SMOKE PASS"); for (const shot of shots) console.log(` ${shot}`); }