Merge branch 'main' into web-chat-approvals

Resolve C10 vs C11 in the shared shell:
- keep both send hooks in the smoke's WebSocket shim (recording +
  scripted replies + synthetic approval acknowledgement) instead of the
  second assignment overwriting the first;
- close the .chat-approval CSS rule so the C11 background-task rules are
  not swallowed by it (the list lost its 3-row cap and scrolling);
- assert the folding invariant directly (no adjacent agent bubbles)
  instead of 'agent bubbles <= user prompts', which the growing operator
  session now legitimately breaks;
- exercise the resource clamp by scroll overflow instead of a clone
  measurement that the clamped frame makes unreliable.
This commit is contained in:
2026-10-19 11:26:26 +01:00
8 changed files with 1326 additions and 46 deletions
+247 -6
View File
@@ -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
+179 -6
View File
@@ -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(),
+13
View File
@@ -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",
});
/**
+59
View File
@@ -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
+82
View File
@@ -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;
+183
View File
@@ -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);
});
+101 -1
View File
@@ -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.",
});
});
+462 -33
View File
@@ -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}`);
}