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:
+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
|
||||
|
||||
Reference in New Issue
Block a user