web: background-tasks bar — running shells, capped list, bounded output (C11)
Add the background-tasks bar to an open conversation: heading
"Background tasks" plus "{n} running", shown only while at least one
shell is running. Rows are capped at 3 (BACKGROUND_TASK_VISIBLE_ROWS)
and the list scrolls beyond; each row is a play glyph, "Running", a
one-line shellCommandSummary and "Details" while selected. Tapping a
row toggles its detail pane ("Command"/"Task identity"/"Status:
running" plus the bounded output: spinner, error + "Retry",
"Output unavailable for this task.", "No output yet.", or the
monospace output and "Output is bounded to 64 KiB." with "Refresh").
Fold shell frames without ever marking the turn running, merge a blank
command from the previous frame, list only running shells (an exited
shell is never a task) and drop/relearn shells on reconnect via
chat_shells. Refresh always rereads the bounded 64 KiB page from cursor
0. Update PARITY.md C11 with its captures and the replayed-vs-real note.
Checks: node --check on every touched file; cd web && node --test test/
(456 pass).
This commit is contained in:
+1
-1
@@ -98,7 +98,7 @@ the pipeline list already carries — rather than a pluralised verb.
|
||||
| C8 | Composer: send, stop, attachments, draft | `chat_prompt`, `chat_interrupt` | done — the composer at the foot of an open conversation: a growing 1–6-row `<textarea>` (placeholder `Message the agent… or / for commands`) where Enter submits and Shift+Enter inserts a newline (the submit routing is the pure `composerSubmit`), an `Attach file` control opening a multi-file picker, a removable chip per attachment (an image thumbnail else a file glyph, the display name, then the error text or `humanBytes(size)`, and a remove control named `Remove {name}`), and one primary control: Stop (`aria-label`/title `Stop`, error tint) while a turn runs, else Send (`aria-label` `Send`, disabled unless a non-blank draft with no failed attachment — or a slash draft). The 25 MiB guard reads `"{display}" is too large (25.0 MiB limit).` and an unreadable file `"{display}" could not be read.`; the web file picker cannot produce an unreadable file, so only the limit branch is captured and both are unit-tested (`test/chat.test.mjs`). Send trims the draft, clears the draft and the attachments at once, calls `chatPrompt` with `{session_id,text,operation_id,native_message_id}` (+ `files` only when present) and reads the reply's `chat_queued` into the notice `Queued — it will send when the current turn finishes.`; a rejected prompt restores the draft and the attachments (each flagged with the server's own message) and shows the shared `Action failed` dialog. The queued flag clears on any incoming frame (the client fans unsolicited envelopes out as a `frame` event; the composer folds it). The draft is kept per chat in memory **and** mirrored into `localStorage` (`pipelines.web.chatDraft.v1`) — the web analogue of per-device persistence — while attachments stay memory-only. Captured 2026-10-19 against a **freshly created** session (never the operator's own): `captures/56-chat-composer-draft.png`, `captures/60-chat-attachment-chips.png`, `captures/61-chat-attachment-removed.png`, `captures/63-chat-composer-stop.png` (a real prompt to the throwaway session turned Send into Stop), `captures/63b-chat-stop-interrupt.png` (the Stop control was **clicked**: it sent `chat_interrupt` and the page showed `Stopping the running turn…`, with no `Action failed` — the control is wired to `chat_interrupt`, never to the inert submit path) and `captures/64-chat-throwaway-closed.png` (after `/close`, the closed row plus the conversation pane left for the list). The throwaway session was created with `chat_create`, really prompted, really interrupted and closed with `chat_close`; the operator's session `ses_eae413f50ffeLQDExlg8cYnscN` was never prompted |
|
||||
| C9 | Slash commands | client-side | done — the palette appears above the composer only while the trimmed draft starts with `/` and has no whitespace, filtered case-insensitively by name prefix, each row showing `/name` and the summary and the highlighted row marked `aria-selected`; Up/Down move the highlight and Enter runs it, a tap runs a row directly, and running a command always consumes the draft and never reaches the prompt path. The five commands and their summaries are `CHAT_COMMANDS` (`/new`, `/close`, `/rename <title>`, `/stop`, `/help`), unit-tested verbatim, with `chatCommandHelp()` the `usage — summary` lines. Effects: `/new` sends `chat_create` directly (C2's item) and opens the created session, `/close` reuses the C3 `Close chat?` confirm, `/rename` is the local rename pending C13, `/stop` interrupts (`chat_interrupt`) and `/help` shows the command list. Error wording is the Android source verbatim: the unknown command reads `“{token}” is not a command, so nothing was sent to the agent. Send it as a message, or cancel.` with the draft offered back and `Send as message` / `Cancel`; an extra argument on an argument-less command reads `{usage} does not take an argument.`; `/rename` with no title reads `Usage: /rename <title> — renames this session on this device.`; `/stop` with nothing running reads `No turn is running in this chat.`. A notice renders as a full-width line after the turns (not a bubble) with the label `Command` / `Command failed` and a terminal glyph, error-coloured when failed. Captured 2026-10-19: `captures/57-chat-command-palette.png`, `captures/58-chat-command-palette-selected.png` (ArrowDown moved the highlight), `captures/59-chat-command-unknown.png` (the failed notice and its offer, dismissed with Cancel), `captures/62-chat-new-session.png` (`/new`'s created session and its `Command` notice) |
|
||||
| C10 | Permission/approval cards (allow once/always/reject) | `chat_permission`, `chat_reply` | todo |
|
||||
| C11 | Background tasks bar: running shells only, capped + scrollable, bounded output page | `chat_shells`, `chat_shell_output` | todo |
|
||||
| C11 | Background tasks bar: running shells only, capped + scrollable, bounded output page | `chat_shells`, `chat_shell_output` | done — captured 2026-10-19 into a live session: `captures/65-chat-background-tasks.png` (the bar with five running tasks — heading `Background tasks`, count `5 running`, three visible rows and a scrolling list), `captures/66-chat-background-task-detail.png` (a selected task's detail: `Command` + the command, `Task identity` + the id in monospace, `Status: running`, then `Output` + the monospace text and `Refresh`), `captures/67-chat-background-task-empty.png` (`No output yet.`), `captures/68-chat-background-task-unavailable.png` (`Output unavailable for this task.`), `captures/69-chat-background-task-truncated.png` (`Output is bounded to 64 KiB.` plus `Refresh`), `captures/70-chat-background-task-loading.png` (the spinner while the page loads) and `captures/71-chat-background-tasks-exited.png` (the bar gone after the last exit). The bar is shown only while at least one shell is running and disappears with the last exit; only running shells are listed (an exited shell is never a task). Its visible rows are capped at 3 (`BACKGROUND_TASK_VISIBLE_ROWS`) and the list scrolls beyond that instead of growing; each row is a play glyph + `Running` + `shellCommandSummary(command)` (trimmed, whitespace-collapsed, elided past 72; blank → `background process`) + `Details` only while selected, and tapping a row toggles its detail pane. Refresh always rereads the page from cursor 0 with `limit` 65536 (`SHELL_OUTPUT_LIMIT`, the server's 64 KiB bound) and never appends, so the client's output cannot grow unbounded — the smoke's own Refresh click issues exactly such a second read and the smoke asserts its `{cursor:0,limit:65536}` bounds. `chat_shells` is fetched when the conversation opens (`chat_query` body `{session_id}`) and again on every stream reconnect, and `chat_shell_output` sends `chat_shell_output_query` (`{session_id,shell_id,cursor,limit}`); both the request shapes and the pure model (`runningBackgroundShells`, `shellCommandSummary`, `mergeShellFrame`, `shellsLoaded`, `shellOutputState`, every wording constant) are unit-tested (`test/chat.test.mjs`, `test/repository.test.mjs`). A `shell` frame folds its shell into the retained set, merges a blank command from the previous frame, and never marks the thread running — a background process outlives the turn (a step ending does not clear it; only the reconnect drops and re-learns it). Every server string is set with `textContent`; shell output is never parsed as markup. **Replayed vs real, stated plainly**: only the `shell` frames (injected synthetic `chat_event` frames) and the `chat_shell_output` pages (answered by a socket reply hook) are synthetic, because the live server had no running shell to read safely; the `chat_shells` list, the `chat_subscribe` ack and every `chat_history` reply came from the real server, and the smoke asserts the real `chat_shells` fetch on open and after a reconnect. The one drop that hit a bounded read mid-section was recovered by the smoke's own bounded retry through the page's controls |
|
||||
| C12 | Human-decision notices inside chat + dismiss | `chat_event` | todo |
|
||||
| C13 | Local rename/hide, seen state, persistence to `localStorage` | client-side | todo |
|
||||
| C14 | Scroll behaviour: follow newest, "jump to newest", restored position | client-side | done — captured 2026-10-19: `captures/45-chat-transcript-newest.png` (the conversation opens at its newest content instantly — the only live session has no saved position, so it lands at the end rather than at the top of a turn taller than the viewport) and `captures/46-chat-transcript-top.png` (after a **real wheel gesture** on the transcript — the app's own listener, not a programmatic scroll, which by the implementation's own rule cannot change intent — `Jump to latest` is offered; the smoke asserts the control and performs the gesture, `ui-smoke` log line "after a real wheel gesture (scrollTop 0) 'Jump to latest' is offered at the top"). A thread with a saved position is restored to it (a saved top, index 0, is a real position and is never treated as "new"); while within the 32 px bottom threshold the view follows, and only the operator's own wheel/drag changes that intent (a programmatic placement or follow cannot); `Jump to latest` is offered only when not following and something is below the fold; the position is saved per session in `localStorage` (`pipelines.web.chatScroll.v1`). A re-render (opening/dismissing a dialog, a refresh, or the loading frame of a paging fetch) captures the live position first and puts the operator back exactly where they were — the smoke asserts the transcript stays put across the `Close chat?` dialog (`ui-smoke` log line "the transcript stayed put across the dialog (top 7141 -> 7141)"); the paging anchor is held until the frame that actually carries the older page, so a real prepend stays on the previously visible message. No auto-load on scroll. The pure decisions are unit-tested (`chatBottomDistancePx`, `chatFollowsAt`, `chatShowJumpToLatest`, `chatOpensAtNewest`, `chatFirstScroll`) in `test/chat.test.mjs`, and the live measurement uses `chatBottomDistancePx` itself |
|
||||
|
||||
+247
-10
@@ -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,
|
||||
@@ -233,10 +234,19 @@ import {
|
||||
LOAD_OLDER_ACTION,
|
||||
REOPEN_ACTION,
|
||||
SELECT_CHAT_HINT,
|
||||
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,
|
||||
attachmentDisplayName,
|
||||
attachmentError,
|
||||
attachmentFiles,
|
||||
backgroundTasksRunningLabel,
|
||||
chatBottomDistancePx,
|
||||
chatCommandEffect,
|
||||
chatCommandHelp,
|
||||
@@ -258,11 +268,14 @@ import {
|
||||
groupSessionsByDirectory,
|
||||
historyResync,
|
||||
mergeHistoryPage,
|
||||
mergeShellFrame,
|
||||
newChatThread,
|
||||
parseChatInput,
|
||||
queuedAfterFrame,
|
||||
reasoningLabel,
|
||||
resumedThread,
|
||||
runningAfterFrame,
|
||||
runningBackgroundShells,
|
||||
runningToolElapsedMillis,
|
||||
sessionActivity,
|
||||
sessionActivityBadge,
|
||||
@@ -272,6 +285,9 @@ import {
|
||||
sessionTitle,
|
||||
sessionWorkLabel,
|
||||
settledThread,
|
||||
shellCommandSummary,
|
||||
shellOutputState,
|
||||
shellsLoaded,
|
||||
formatToolDuration,
|
||||
threadElapsedMillis,
|
||||
threadPhase,
|
||||
@@ -3601,6 +3617,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);
|
||||
}
|
||||
|
||||
@@ -3635,13 +3654,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));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -3660,23 +3684,110 @@ function onChatEvent(frame) {
|
||||
}
|
||||
|
||||
/**
|
||||
* The reconnect repair (C5): re-attach the open chat's stream and replace its
|
||||
* 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();
|
||||
}
|
||||
|
||||
@@ -4411,6 +4522,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 }));
|
||||
@@ -4456,6 +4573,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
@@ -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
|
||||
@@ -815,6 +965,11 @@ export function newChatThread(sessionId = "") {
|
||||
toolStartedAt: {},
|
||||
lastDeltaAt: 0,
|
||||
queued: false,
|
||||
// The background shells this session has observed (C11), in observation
|
||||
// order, the selected task and its bounded output pane.
|
||||
shells: [],
|
||||
selectedShellId: null,
|
||||
shellOutput: null,
|
||||
};
|
||||
}
|
||||
|
||||
@@ -841,6 +996,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.
|
||||
@@ -966,8 +1134,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()) {
|
||||
@@ -984,9 +1152,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;
|
||||
@@ -1085,10 +1256,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(),
|
||||
|
||||
@@ -64,6 +64,12 @@ export const Protocol = Object.freeze({
|
||||
CHAT_PROMPT: "chat_prompt",
|
||||
CHAT_INTERRUPT: "chat_interrupt",
|
||||
CHAT_CREATE: "chat_create",
|
||||
// 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",
|
||||
@@ -92,6 +98,13 @@ export const ChatKeys = Object.freeze({
|
||||
PROMPT: "chat_prompt",
|
||||
CREATE: "chat_create",
|
||||
QUEUED: "chat_queued",
|
||||
// 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",
|
||||
});
|
||||
|
||||
/**
|
||||
|
||||
@@ -7,6 +7,14 @@ import { ProtocolError } from "./client.js";
|
||||
/** The server default history page the app asks for (CHAT_HISTORY_LIMIT, 200). */
|
||||
export const CHAT_HISTORY_LIMIT = 200;
|
||||
|
||||
/**
|
||||
* 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;
|
||||
|
||||
@@ -240,6 +248,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
|
||||
|
||||
@@ -1557,6 +1557,89 @@ code { background: var(--surface-2); padding: 1px 6px; border-radius: 6px; font-
|
||||
.chat-running-tool-elapsed { font-size: 11px; }
|
||||
.chat-running-tool-long { color: var(--bad); }
|
||||
|
||||
/* 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-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;
|
||||
z-index: 40;
|
||||
|
||||
@@ -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,
|
||||
@@ -14,6 +16,17 @@ import {
|
||||
ChatTurn,
|
||||
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,
|
||||
@@ -24,6 +37,7 @@ import {
|
||||
attachmentDisplayName,
|
||||
attachmentError,
|
||||
attachmentFiles,
|
||||
backgroundTasksRunningLabel,
|
||||
chatBottomDistancePx,
|
||||
chatCommandEffect,
|
||||
chatCommandForEnter,
|
||||
@@ -49,6 +63,7 @@ import {
|
||||
historyResync,
|
||||
lineDiff,
|
||||
mergeHistoryPage,
|
||||
mergeShellFrame,
|
||||
mergeToolPart,
|
||||
newChatThread,
|
||||
parseChatInput,
|
||||
@@ -56,7 +71,9 @@ import {
|
||||
prettyToolInput,
|
||||
queuedAfterFrame,
|
||||
reasoningLabel,
|
||||
resumedThread,
|
||||
runningAfterFrame,
|
||||
runningBackgroundShells,
|
||||
runningToolElapsedMillis,
|
||||
runningToolStamps,
|
||||
sessionActivity,
|
||||
@@ -68,6 +85,9 @@ import {
|
||||
sessionTitle,
|
||||
sessionWorkLabel,
|
||||
settledThread,
|
||||
shellCommandSummary,
|
||||
shellOutputState,
|
||||
shellsLoaded,
|
||||
threadElapsedMillis,
|
||||
threadPhase,
|
||||
threadRunningTools,
|
||||
@@ -1168,3 +1188,166 @@ test("the running indicator's elapsed and per-tool timing use the thread's own s
|
||||
assert.deepEqual(runningToolStamps({ t1: 42 }, thread.messages, 9999), { t1: 42 });
|
||||
assert.deepEqual(runningToolStamps({ t1: 42 }, [], 9999), {});
|
||||
});
|
||||
|
||||
// --- 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);
|
||||
});
|
||||
|
||||
@@ -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");
|
||||
@@ -396,3 +396,104 @@ test("subscribeChat surfaces a server refusal as a ProtocolError", async () => {
|
||||
message: "unknown command: chat_subscribe",
|
||||
});
|
||||
});
|
||||
|
||||
// --- 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.",
|
||||
});
|
||||
});
|
||||
|
||||
@@ -387,6 +387,33 @@ try {
|
||||
const ws = protocols === undefined ? new Native(url) : new Native(url, protocols);
|
||||
window.__pipelinesSockets.push(ws);
|
||||
window.__pipelinesSocket = ws;
|
||||
// A controlled reply hook (C11): when set, a matching request is answered
|
||||
// with the synthetic reply on the page's own socket instead of reaching the
|
||||
// server. Every other frame is sent natively, so real chat traffic is
|
||||
// untouched; a run that never sets the hook behaves exactly as before.
|
||||
const nativeSend = ws.send.bind(ws);
|
||||
ws.send = function (data) {
|
||||
let frame = null;
|
||||
try {
|
||||
frame = JSON.parse(data);
|
||||
} catch (_) {
|
||||
frame = null;
|
||||
}
|
||||
if (frame) {
|
||||
(window.__pipelinesSentTypes = window.__pipelinesSentTypes || []).push(frame.type);
|
||||
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);
|
||||
};
|
||||
return ws;
|
||||
}
|
||||
Shim.prototype = Native.prototype;
|
||||
@@ -2357,8 +2384,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");
|
||||
@@ -3368,6 +3403,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}`);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user