Merge branch 'main' into web-chat-approvals
Resolve C10 vs C11 in the shared shell: - keep both send hooks in the smoke's WebSocket shim (recording + scripted replies + synthetic approval acknowledgement) instead of the second assignment overwriting the first; - close the .chat-approval CSS rule so the C11 background-task rules are not swallowed by it (the list lost its 3-row cap and scrolling); - assert the folding invariant directly (no adjacent agent bubbles) instead of 'agent bubbles <= user prompts', which the growing operator session now legitimately breaks; - exercise the resource clamp by scroll overflow instead of a clone measurement that the clamped frame makes unreliable.
This commit is contained in:
+247
-6
@@ -2,7 +2,7 @@
|
||||
// Deliberately small and DOM-only (no framework, no build step). Every value
|
||||
// that came from the server is set with textContent, never innerHTML.
|
||||
import { PipelinesClient } from "./client.js";
|
||||
import { PipelinesRepository } from "./repository.js";
|
||||
import { PipelinesRepository, SHELL_OUTPUT_LIMIT } from "./repository.js";
|
||||
import { PROTOCOL_VERSION, Protocol, ChatKeys } from "./protocol.js";
|
||||
import { validateServerUrl, resolveArtifactUrl } from "./serverUrl.js";
|
||||
import {
|
||||
@@ -207,6 +207,7 @@ import {
|
||||
retryRequestKey,
|
||||
} from "./actions.js";
|
||||
import {
|
||||
BACKGROUND_TASKS_TITLE,
|
||||
CHAT_ATTACH_LABEL,
|
||||
CHAT_COMMAND_GLYPH,
|
||||
CHAT_COMPOSER_PLACEHOLDER,
|
||||
@@ -241,12 +242,21 @@ import {
|
||||
DECISION_REJECT,
|
||||
RISK_REVIEW_LABEL,
|
||||
WAITING_FOR_APPROVAL_LABEL,
|
||||
SHELL_DETAILS_LABEL,
|
||||
SHELL_OUTPUT_EMPTY,
|
||||
SHELL_OUTPUT_ERROR,
|
||||
SHELL_OUTPUT_LABELS,
|
||||
SHELL_OUTPUT_LOADING,
|
||||
SHELL_OUTPUT_READY,
|
||||
SHELL_OUTPUT_UNAVAILABLE,
|
||||
SHELL_ROW_LABEL,
|
||||
applyChatEvent,
|
||||
applyChatPermission,
|
||||
approvalCard,
|
||||
attachmentDisplayName,
|
||||
attachmentError,
|
||||
attachmentFiles,
|
||||
backgroundTasksRunningLabel,
|
||||
chatBottomDistancePx,
|
||||
chatCommandEffect,
|
||||
chatCommandHelp,
|
||||
@@ -268,11 +278,14 @@ import {
|
||||
groupSessionsByDirectory,
|
||||
historyResync,
|
||||
mergeHistoryPage,
|
||||
mergeShellFrame,
|
||||
newChatThread,
|
||||
parseChatInput,
|
||||
queuedAfterFrame,
|
||||
reasoningLabel,
|
||||
resumedThread,
|
||||
runningAfterFrame,
|
||||
runningBackgroundShells,
|
||||
runningToolElapsedMillis,
|
||||
sessionActivity,
|
||||
sessionActivityBadge,
|
||||
@@ -282,6 +295,9 @@ import {
|
||||
sessionTitle,
|
||||
sessionWorkLabel,
|
||||
settledThread,
|
||||
shellCommandSummary,
|
||||
shellOutputState,
|
||||
shellsLoaded,
|
||||
formatToolDuration,
|
||||
threadElapsedMillis,
|
||||
threadPhase,
|
||||
@@ -3611,6 +3627,9 @@ async function openChatSession(id) {
|
||||
// Attach the shared live stream once per session per connection; its failure is
|
||||
// non-fatal — history stays usable and the badge reads "not live".
|
||||
subscribeChatSession(id);
|
||||
// Load the session's background shells (C11) so the bar appears on open, not
|
||||
// only after the next pushed shell frame.
|
||||
loadChatShells(id);
|
||||
await loadChatHistory(id);
|
||||
}
|
||||
|
||||
@@ -3645,13 +3664,18 @@ function clearChatSubscriptions() {
|
||||
}
|
||||
|
||||
/**
|
||||
* Settle every conversation that was running. A socket drop (or a close) removes
|
||||
* the frames feeding the turn, so no thread keeps claiming to run until a fresh
|
||||
* frame proves otherwise.
|
||||
* Settle every conversation that was running, and drop its observed shells. A
|
||||
* socket drop (or a close) removes the frames feeding the turn, so no thread
|
||||
* keeps claiming to run until a fresh frame proves otherwise; a shell's exit may
|
||||
* have been swallowed by the same gap, so the retained shells are forgotten and
|
||||
* re-learned from `chat_shells` on reconnect (mirrors ChatStore.streamResumed).
|
||||
*/
|
||||
function settleChatThreads() {
|
||||
for (const [id, thread] of state.chatThreads) {
|
||||
if (thread?.running || thread?.queued) state.chatThreads.set(id, settledThread(thread));
|
||||
const hasShells = (thread?.shells ?? []).length > 0;
|
||||
if (thread?.running || thread?.queued || hasShells) {
|
||||
state.chatThreads.set(id, resumedThread(thread));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -3732,19 +3756,110 @@ async function answerPermission(sessionId, requestId, decision) {
|
||||
* conversation with the newest history page wholesale. Everything the gap could
|
||||
* have missed is repaired; a turn that was in flight is settled. Only the open
|
||||
* conversation is repaired — the others are not on screen.
|
||||
* Fetch a session's currently verified shells (C11) and retain only the exits
|
||||
* this client itself observed, so an exited task never reappears as running and a
|
||||
* shell the server no longer lists drops out. Called when the conversation opens
|
||||
* and on every stream reconnect (a gap may have swallowed an exit). A failure is
|
||||
* non-fatal: the transcript stays usable and the bar keeps its last known state.
|
||||
*/
|
||||
async function loadChatShells(id) {
|
||||
if (!id || state.connection.kind !== "connected") return;
|
||||
try {
|
||||
const running = await repo.chatShells(id);
|
||||
const thread = state.chatThreads.get(id);
|
||||
if (!thread) return;
|
||||
state.chatThreads.set(id, { ...thread, shells: shellsLoaded(thread.shells, running) });
|
||||
renderContent();
|
||||
} catch {
|
||||
// The shell list is a background convenience; leave the thread untouched.
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Toggle a running task's detail pane (C11). Selecting a shell fetches its
|
||||
* bounded output page; selecting the selected one again closes it. Mirrors
|
||||
* ChatStore.selectShell: an id that is not a known shell is ignored.
|
||||
*/
|
||||
function selectChatShell(shellId) {
|
||||
const sessionId = state.chatActiveId;
|
||||
const thread = sessionId ? state.chatThreads.get(sessionId) : null;
|
||||
if (!thread) return;
|
||||
const closing = thread.selectedShellId === shellId;
|
||||
if (!closing && !(thread.shells ?? []).some((shell) => shell.id === shellId)) return;
|
||||
const next = closing ? null : shellId;
|
||||
state.chatThreads.set(sessionId, { ...thread, selectedShellId: next, shellOutput: null });
|
||||
renderContent();
|
||||
if (next) refreshChatShellOutput(next);
|
||||
}
|
||||
|
||||
/**
|
||||
* Reread a selected task's bounded output page (C11) from the page's start. The
|
||||
* cursor is always 0 and the limit is the server's 64 KiB bound, so the client
|
||||
* never grows output unbounded and a Refresh never appends. A reply for a shell
|
||||
* that is no longer selected is ignored, exactly like ChatStore.shellOutput*.
|
||||
*/
|
||||
async function refreshChatShellOutput(shellId) {
|
||||
const sessionId = state.chatActiveId;
|
||||
if (!sessionId || !shellId) return;
|
||||
shellOutputLoading(sessionId, shellId);
|
||||
renderContent();
|
||||
try {
|
||||
const page = await repo.chatShellOutput(sessionId, shellId, { cursor: 0, limit: SHELL_OUTPUT_LIMIT });
|
||||
shellOutputLoaded(sessionId, shellId, page);
|
||||
} catch (error) {
|
||||
shellOutputFailed(sessionId, shellId, describeError(error));
|
||||
}
|
||||
renderContent();
|
||||
}
|
||||
|
||||
/** Mark a selected task's output pane loading (ignored for a stale selection). */
|
||||
function shellOutputLoading(sessionId, shellId) {
|
||||
const thread = state.chatThreads.get(sessionId);
|
||||
if (!thread || thread.selectedShellId !== shellId) return;
|
||||
state.chatThreads.set(sessionId, { ...thread, shellOutput: { loading: true, error: "", page: null } });
|
||||
}
|
||||
|
||||
/**
|
||||
* Apply a loaded output page, merging a shell the page reports back into the
|
||||
* retained list (keeping the command already learned when the page omits it).
|
||||
*/
|
||||
function shellOutputLoaded(sessionId, shellId, page) {
|
||||
const thread = state.chatThreads.get(sessionId);
|
||||
if (!thread || thread.selectedShellId !== shellId) return;
|
||||
const reported = page?.shell;
|
||||
const shells = reported && String(reported.id ?? "").trim() !== ""
|
||||
? mergeShellFrame(thread.shells, reported)
|
||||
: thread.shells ?? [];
|
||||
state.chatThreads.set(sessionId, { ...thread, shells, shellOutput: { loading: false, error: "", page } });
|
||||
}
|
||||
|
||||
/** Report a failed output read against the still-selected task (Retry is offered). */
|
||||
function shellOutputFailed(sessionId, shellId, message) {
|
||||
const thread = state.chatThreads.get(sessionId);
|
||||
if (!thread || thread.selectedShellId !== shellId) return;
|
||||
state.chatThreads.set(sessionId, { ...thread, shellOutput: { loading: false, error: message, page: null } });
|
||||
}
|
||||
|
||||
/**
|
||||
* The reconnect repair (C5/C11): re-attach the open chat's stream, replace its
|
||||
* conversation with the newest history page wholesale and re-learn its shells.
|
||||
* Everything the gap could have missed is repaired; a turn that was in flight is
|
||||
* settled and the retained shells are dropped before the fresh snapshot arrives.
|
||||
* Only the open conversation is repaired — the others are not on screen.
|
||||
*/
|
||||
async function resyncOpenChat() {
|
||||
const id = state.chatActiveId;
|
||||
if (!id || state.connection.kind !== "connected") return;
|
||||
await subscribeChatSession(id);
|
||||
const previous = state.chatThreads.get(id) ?? newChatThread(id);
|
||||
state.chatThreads.set(id, settledThread(previous));
|
||||
state.chatThreads.set(id, resumedThread(previous));
|
||||
try {
|
||||
const page = await repo.chatHistory(id);
|
||||
state.chatThreads.set(id, historyResync(previous, page));
|
||||
} catch {
|
||||
// The history refresh failed; the settled thread stands and the badge is honest.
|
||||
}
|
||||
await loadChatShells(id);
|
||||
renderContent();
|
||||
}
|
||||
|
||||
@@ -4488,6 +4603,12 @@ function renderChatConversation() {
|
||||
if (contextMeta !== "") context.append(h("span", { class: "chat-context-meta muted", text: contextMeta }));
|
||||
pane.append(context);
|
||||
|
||||
// The background-tasks bar (C11) sits above the transcript, outside the
|
||||
// scroller so the C14 scroll positions are untouched. It is present only while
|
||||
// a shell is still running and disappears with the last exit.
|
||||
const backgroundTasks = renderBackgroundTasks(thread);
|
||||
if (backgroundTasks) pane.append(backgroundTasks);
|
||||
|
||||
const notices = thread?.notices ?? [];
|
||||
if (thread?.loading && !thread?.loaded) {
|
||||
pane.append(h("div", { class: "chat-transcript-empty muted", text: CONVERSATION_LOADING }));
|
||||
@@ -4538,6 +4659,126 @@ function appendChatDialogs(pane) {
|
||||
if (state.actionError) pane.append(renderActionFailedDialog());
|
||||
}
|
||||
|
||||
/**
|
||||
* The background-tasks bar (C11): the running shells this conversation still
|
||||
* owns. It returns null (renders nothing) unless at least one shell is running,
|
||||
* so it disappears the moment the last task exits. Heading `Background tasks` +
|
||||
* `{n} running`; the list shows at most BACKGROUND_TASK_VISIBLE_ROWS rows and
|
||||
* scrolls beyond; a selected row reveals its bounded, read-only output pane.
|
||||
* Every server string is set with textContent (never innerHTML).
|
||||
*/
|
||||
function renderBackgroundTasks(thread) {
|
||||
const running = runningBackgroundShells(thread?.shells ?? []);
|
||||
if (running.length === 0) return null;
|
||||
const wrap = h("section", { class: "chat-bg-tasks", id: "chatBackgroundTasks" });
|
||||
const head = h("div", { class: "chat-bg-tasks-head" });
|
||||
head.append(h("span", { class: "chat-bg-tasks-title", text: BACKGROUND_TASKS_TITLE }));
|
||||
head.append(
|
||||
h("span", { class: "chat-bg-tasks-count muted", text: backgroundTasksRunningLabel(running.length) }),
|
||||
);
|
||||
wrap.append(head);
|
||||
const list = h("div", { class: "chat-bg-tasks-list" });
|
||||
const selectedId = thread?.selectedShellId ?? null;
|
||||
running.forEach((shell) => list.append(renderBackgroundTaskRow(shell, shell.id === selectedId)));
|
||||
wrap.append(list);
|
||||
const selected = running.find((shell) => shell.id === selectedId) ?? null;
|
||||
if (selected) wrap.append(renderBackgroundTaskDetail(thread, selected));
|
||||
return wrap;
|
||||
}
|
||||
|
||||
/** One running shell task; tapping it toggles its detail pane. */
|
||||
function renderBackgroundTaskRow(shell, selected) {
|
||||
const row = h("button", {
|
||||
class: `chat-bg-task${selected ? " selected" : ""}`,
|
||||
type: "button",
|
||||
"data-shell": shell.id,
|
||||
"aria-pressed": selected ? "true" : "false",
|
||||
onclick: () => selectChatShell(shell.id),
|
||||
});
|
||||
// A CSS play glyph, decorative only (the row's own text names the task).
|
||||
row.append(h("span", { class: "chat-bg-task-glyph", "aria-hidden": "true" }));
|
||||
row.append(h("span", { class: "chat-bg-task-status", text: SHELL_ROW_LABEL }));
|
||||
row.append(
|
||||
h("span", {
|
||||
class: "chat-bg-task-command",
|
||||
text: shellCommandSummary(shell.command),
|
||||
title: String(shell.command ?? ""),
|
||||
}),
|
||||
);
|
||||
if (selected) row.append(h("span", { class: "chat-bg-task-details muted", text: SHELL_DETAILS_LABEL }));
|
||||
return row;
|
||||
}
|
||||
|
||||
/**
|
||||
* The selected task's read-only detail: its command, its identity in monospace
|
||||
* and `Status: running`, then the output area — the exact label order and wording
|
||||
* of ChatTranscript.BackgroundProcessDetail. Reload is always a bounded reread
|
||||
* from the page's start (`Refresh`; `Retry` after a failure).
|
||||
*/
|
||||
function renderBackgroundTaskDetail(thread, shell) {
|
||||
const labels = SHELL_OUTPUT_LABELS;
|
||||
const pane = h("div", { class: "chat-bg-task-detail" });
|
||||
pane.append(h("div", { class: "chat-bg-task-label muted", text: labels.COMMAND }));
|
||||
const command = String(shell.command ?? "").trim();
|
||||
pane.append(
|
||||
h("div", {
|
||||
class: "chat-bg-task-command-full",
|
||||
text: command === "" ? labels.UNAVAILABLE : shell.command,
|
||||
}),
|
||||
);
|
||||
pane.append(h("div", { class: "chat-bg-task-label muted", text: labels.TASK_IDENTITY }));
|
||||
pane.append(h("div", { class: "chat-bg-task-id monospace", text: String(shell.id ?? "") }));
|
||||
pane.append(h("div", { class: "chat-bg-task-status-line", text: labels.STATUS_RUNNING }));
|
||||
|
||||
const output = thread?.shellOutput ?? null;
|
||||
switch (shellOutputState(output)) {
|
||||
case SHELL_OUTPUT_LOADING:
|
||||
pane.append(h("span", { class: "spinner chat-bg-task-spinner", "aria-hidden": "true" }));
|
||||
break;
|
||||
case SHELL_OUTPUT_ERROR: {
|
||||
const row = h("div", { class: "chat-bg-task-error-row" });
|
||||
row.append(h("span", { class: "chat-bg-task-error", text: output.error }));
|
||||
row.append(
|
||||
h("button", {
|
||||
class: "ghost chat-bg-task-retry",
|
||||
type: "button",
|
||||
text: labels.RETRY,
|
||||
onclick: () => refreshChatShellOutput(shell.id),
|
||||
}),
|
||||
);
|
||||
pane.append(row);
|
||||
break;
|
||||
}
|
||||
case SHELL_OUTPUT_UNAVAILABLE:
|
||||
pane.append(h("div", { class: "chat-bg-task-note muted", text: labels.OUTPUT_UNAVAILABLE }));
|
||||
break;
|
||||
case SHELL_OUTPUT_EMPTY:
|
||||
pane.append(h("div", { class: "chat-bg-task-note muted", text: labels.NO_OUTPUT }));
|
||||
break;
|
||||
case SHELL_OUTPUT_READY: {
|
||||
const page = output.page;
|
||||
pane.append(h("div", { class: "chat-bg-task-label muted", text: labels.OUTPUT }));
|
||||
// Untrusted shell text: set as textContent, never parsed as markup.
|
||||
pane.append(h("pre", { class: "chat-bg-task-output", text: String(page.output ?? "") }));
|
||||
if (page.truncated) {
|
||||
pane.append(h("div", { class: "chat-bg-task-note muted", text: labels.OUTPUT_BOUNDED }));
|
||||
}
|
||||
pane.append(
|
||||
h("button", {
|
||||
class: "ghost chat-bg-task-refresh",
|
||||
type: "button",
|
||||
text: labels.REFRESH,
|
||||
onclick: () => refreshChatShellOutput(shell.id),
|
||||
}),
|
||||
);
|
||||
break;
|
||||
}
|
||||
default:
|
||||
break;
|
||||
}
|
||||
return pane;
|
||||
}
|
||||
|
||||
/**
|
||||
* The transcript: one column of turns. An operator message is its own
|
||||
* right-aligned bubble (with the sending client's label when the server echoed
|
||||
|
||||
+179
-6
@@ -302,6 +302,21 @@ export function toolDetail(part) {
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* The one-line command a background process is running, collapsed to a single
|
||||
* line and elided past [TOOL_DETAIL_MAX_LENGTH] like a tool call's detail, so a
|
||||
* long command line cannot flood the bar. A shell that reported no command reads
|
||||
* as a generic `background process` rather than a blank line (ChatFormat.kt
|
||||
* shellCommandSummary, which shares the tool-detail regex and bound).
|
||||
*/
|
||||
export function shellCommandSummary(command) {
|
||||
const text = str(command).trim().replace(/\s+/g, " ");
|
||||
if (text === "") return "background process";
|
||||
return text.length <= TOOL_DETAIL_MAX_LENGTH
|
||||
? text
|
||||
: text.slice(0, TOOL_DETAIL_MAX_LENGTH - 1).trimEnd() + "…";
|
||||
}
|
||||
|
||||
/**
|
||||
* The INPUT section of a tool call: pretty-printed JSON once the arguments are an
|
||||
* object/array, the raw partial-JSON string while still streaming, or empty when
|
||||
@@ -795,6 +810,141 @@ export function chatStreamState(connectionKind, subscribed) {
|
||||
return { tone: "not-live", label: STREAM_OFFLINE };
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Background shells (C11: ChatTranscript.kt BackgroundProcessBar, ChatStore.kt
|
||||
// applyShell/shellsLoaded, ChatFormat.kt runningBackgroundShells/shellCommandSummary)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* ChatShell.Status values (internal/protocol/chat.go). A running shell is one
|
||||
* whose command has started and not yet exited; `exited` is final.
|
||||
*/
|
||||
export const SHELL_RUNNING = "running";
|
||||
export const SHELL_EXITED = "exited";
|
||||
|
||||
/**
|
||||
* Per-session in-memory observation bound (ChatStore.OBSERVED_SHELL_LIMIT): the
|
||||
* retained shell tail a selected task can settle against. This is not task
|
||||
* history, only what this client itself observed.
|
||||
*/
|
||||
export const OBSERVED_SHELL_LIMIT = 16;
|
||||
|
||||
/**
|
||||
* How many running-task rows the bar draws before the list scrolls instead of
|
||||
* growing (ChatTranscript.BACKGROUND_TASK_VISIBLE_ROWS).
|
||||
*/
|
||||
export const BACKGROUND_TASK_VISIBLE_ROWS = 3;
|
||||
|
||||
/** The bar's heading; its count line is `{n} running`. */
|
||||
export const BACKGROUND_TASKS_TITLE = "Background tasks";
|
||||
export function backgroundTasksRunningLabel(count) {
|
||||
return `${count} running`;
|
||||
}
|
||||
|
||||
/** A row's own words (ChatTranscript.BackgroundProcessLine). */
|
||||
export const SHELL_ROW_LABEL = "Running";
|
||||
export const SHELL_DETAILS_LABEL = "Details";
|
||||
|
||||
/**
|
||||
* The detail pane's exact wording, verbatim from
|
||||
* ChatTranscript.BackgroundProcessDetail. Kept as one frozen map so the pane and
|
||||
* its unit test share one string instead of the copy drifting.
|
||||
*/
|
||||
export const SHELL_OUTPUT_LABELS = Object.freeze({
|
||||
COMMAND: "Command",
|
||||
UNAVAILABLE: "Unavailable",
|
||||
TASK_IDENTITY: "Task identity",
|
||||
STATUS_RUNNING: "Status: running",
|
||||
OUTPUT_UNAVAILABLE: "Output unavailable for this task.",
|
||||
NO_OUTPUT: "No output yet.",
|
||||
OUTPUT: "Output",
|
||||
OUTPUT_BOUNDED: "Output is bounded to 64 KiB.",
|
||||
RETRY: "Retry",
|
||||
REFRESH: "Refresh",
|
||||
});
|
||||
|
||||
/**
|
||||
* The background processes still running for a session, in the order they
|
||||
* started, from the shells the server reported and the session retains. A shell
|
||||
* that has exited is never listed — that is what clears the bar — and the set is
|
||||
* independent of the turn, because a background process outlives the tool call
|
||||
* (and often the turn) that started it. Mirrors ChatFormat.runningBackgroundShells:
|
||||
* only a non-blank id with status `running` is a task, and the list is never
|
||||
* truncated here (the visible-row cap is a view concern).
|
||||
*/
|
||||
export function runningBackgroundShells(shells) {
|
||||
return (shells ?? []).filter(
|
||||
(shell) => !isBlank(shell?.id) && str(shell?.status) === SHELL_RUNNING,
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Folds one shell frame (or a snapshot entry) into the retained shells, keyed by
|
||||
* id and kept in observation order. A blank incoming command keeps the command
|
||||
* already learned, so a later frame that omits it never blanks the row, and the
|
||||
* list is trimmed to the last [OBSERVED_SHELL_LIMIT] entries (ChatStore.applyShell).
|
||||
*/
|
||||
export function mergeShellFrame(shells, shell) {
|
||||
const id = str(shell?.id);
|
||||
if (shell == null || isBlank(id)) return shells ?? [];
|
||||
const list = (shells ?? []).slice();
|
||||
const index = list.findIndex((candidate) => str(candidate?.id) === id);
|
||||
const prior = index >= 0 ? list[index] : null;
|
||||
const merged = {
|
||||
...shell,
|
||||
id,
|
||||
command: isBlank(shell?.command) ? str(prior?.command) : shell.command,
|
||||
};
|
||||
if (index >= 0) list[index] = merged;
|
||||
else list.push(merged);
|
||||
return list.slice(-OBSERVED_SHELL_LIMIT);
|
||||
}
|
||||
|
||||
/**
|
||||
* Replaces the retained shells with the authoritative running snapshot while
|
||||
* keeping only exits this client itself observed, capped like every other shell
|
||||
* list (ChatStore.shellsLoaded). A shell the server no longer lists and that this
|
||||
* client never saw exit simply drops out.
|
||||
*/
|
||||
export function shellsLoaded(shells, running) {
|
||||
const byId = new Map();
|
||||
for (const shell of shells ?? []) {
|
||||
if (!isBlank(shell?.id) && str(shell?.status) === SHELL_EXITED) byId.set(shell.id, shell);
|
||||
}
|
||||
for (const shell of running ?? []) {
|
||||
if (isBlank(shell?.id)) continue;
|
||||
// Map.set keeps the first-insertion position and replaces the value, exactly
|
||||
// like Kotlin's `observedExits + live` LinkedHashMap merge.
|
||||
byId.set(shell.id, shell);
|
||||
}
|
||||
return [...byId.values()].slice(-OBSERVED_SHELL_LIMIT);
|
||||
}
|
||||
|
||||
/** The five shapes a selected task's output area can take. */
|
||||
export const SHELL_OUTPUT_LOADING = "loading";
|
||||
export const SHELL_OUTPUT_ERROR = "error";
|
||||
export const SHELL_OUTPUT_UNAVAILABLE = "unavailable";
|
||||
export const SHELL_OUTPUT_EMPTY = "empty";
|
||||
export const SHELL_OUTPUT_READY = "output";
|
||||
|
||||
/**
|
||||
* Which branch the detail pane's output area shows for a selected task's
|
||||
* [output] state, or null when there is nothing to show yet — the same decision
|
||||
* order as ChatTranscript.BackgroundProcessDetail's `when` (loading, then error,
|
||||
* then the server's `unavailable`, then an empty page, then a readable page), so
|
||||
* the pane and its unit test share one derivation.
|
||||
*/
|
||||
export function shellOutputState(output) {
|
||||
if (output == null) return null;
|
||||
if (output.loading) return SHELL_OUTPUT_LOADING;
|
||||
if (str(output.error) !== "") return SHELL_OUTPUT_ERROR;
|
||||
const page = output.page ?? null;
|
||||
if (page == null) return null;
|
||||
if (page.unavailable === true) return SHELL_OUTPUT_UNAVAILABLE;
|
||||
if (str(page.output) === "") return SHELL_OUTPUT_EMPTY;
|
||||
return SHELL_OUTPUT_READY;
|
||||
}
|
||||
|
||||
/**
|
||||
* The shape an open conversation holds. The first six fields are the ones a
|
||||
* history page fills; the rest is the live stream (see `ChatThread` in
|
||||
@@ -824,6 +974,11 @@ export function newChatThread(sessionId = "") {
|
||||
// The reason a refused `chat_reply` left on the thread's error line, kept
|
||||
// apart from any other error so a later accepted answer clears only this one.
|
||||
permissionError: "",
|
||||
// The background shells this session has observed (C11), in observation
|
||||
// order, the selected task and its bounded output pane.
|
||||
shells: [],
|
||||
selectedShellId: null,
|
||||
shellOutput: null,
|
||||
};
|
||||
}
|
||||
|
||||
@@ -850,6 +1005,19 @@ export function setThreadRunning(thread, running, now) {
|
||||
return settledThread({ ...thread });
|
||||
}
|
||||
|
||||
/**
|
||||
* The reconnect repair for one thread (C5/C11): the settled form plus the shell
|
||||
* observations dropped — a shell's exit may have been swallowed by the gap, so
|
||||
* the retained shells are forgotten and re-learned from the re-subscribe's
|
||||
* `chat_shells` snapshot. This is deliberately separate from [settledThread],
|
||||
* which the step-ended frame also uses: a turn ending must never clear a
|
||||
* background process that outlives it (ChatStore.streamResumed drops shells;
|
||||
* ChatStore.setRunning does not).
|
||||
*/
|
||||
export function resumedThread(thread) {
|
||||
return { ...settledThread(thread), shells: [], selectedShellId: null, shellOutput: null };
|
||||
}
|
||||
|
||||
/**
|
||||
* Non-negative elapsed time of an in-flight turn at [nowMillis], or 0 once it has
|
||||
* settled. Pure, so the running indicator and its unit test share the derivation.
|
||||
@@ -975,8 +1143,8 @@ export function threadPhase(thread, nowMillis) {
|
||||
* thread. Any frame clears `queued` (the turn moved on); `user` echoes another
|
||||
* client's prompt once (never this client's own), `text`/`reasoning` append to the
|
||||
* part their kind started, `tool` merges field by field, `step` drives the running
|
||||
* flag, and `shell`/`usage` are recognised but not folded here (C11 owns shells
|
||||
* and the turn totals are not shown). The message that a delta or tool frame
|
||||
* flag, and `shell` folds one background process into the retained set without
|
||||
* ever marking the turn running (C11). The message that a delta or tool frame
|
||||
* targets is created on first sight, so a live turn never gains a second bubble.
|
||||
*/
|
||||
export function applyChatEvent(thread, frame, now = Date.now()) {
|
||||
@@ -993,9 +1161,12 @@ export function applyChatEvent(thread, frame, now = Date.now()) {
|
||||
return applyTool(current, frame, now);
|
||||
case EVENT_STEP:
|
||||
return setThreadRunning(current, str(frame?.step?.status) !== STEP_ENDED, now);
|
||||
// `shell` is C11's (it never marks the turn running) and `usage` is not
|
||||
// folded; both still clear `queued`, which happened above.
|
||||
// A shell frame only folds its shell into the retained set: it NEVER marks
|
||||
// the thread running, because a background process is not the turn — a shell
|
||||
// that outlives the turn keeps showing after the turn's own indicator is gone.
|
||||
case EVENT_SHELL:
|
||||
return { ...current, shells: mergeShellFrame(current.shells, frame?.shell) };
|
||||
// `usage` is recognised but not folded; it still cleared `queued` above.
|
||||
case EVENT_USAGE:
|
||||
default:
|
||||
return current;
|
||||
@@ -1094,10 +1265,12 @@ function upsertParts(thread, frame, now, deltaArrivedAt, upsert) {
|
||||
* The reconnect/resync replacement: the newest history page is authoritative, so
|
||||
* the whole turn is replaced (no stale held message survives), the cursor and
|
||||
* `hasMore` are replaced from the page, and any in-flight state is settled —
|
||||
* every frame that was feeding a running turn is gone.
|
||||
* every frame that was feeding a running turn is gone. The retained shells are
|
||||
* dropped too (the reconnect re-fetches `chat_shells`), exactly like the Android
|
||||
* `streamResumed` path.
|
||||
*/
|
||||
export function historyResync(thread, page) {
|
||||
const settled = settledThread(thread ?? newChatThread());
|
||||
const settled = resumedThread(thread ?? newChatThread());
|
||||
return {
|
||||
...settled,
|
||||
messages: (page?.messages ?? []).slice(),
|
||||
|
||||
@@ -69,6 +69,12 @@ export const Protocol = Object.freeze({
|
||||
// with `chat_reply` (internal/protocol/chat.go ChatPermission/ChatReply).
|
||||
CHAT_PERMISSION: "chat_permission",
|
||||
CHAT_REPLY: "chat_reply",
|
||||
// The background shells a chat session owns (C11). `chat_shells` lists the
|
||||
// session's currently verified shells (body: `chat_query`); `chat_shell_output`
|
||||
// reads a bounded, lazy output page from one of them (body:
|
||||
// `chat_shell_output_query`). Mirrors internal/protocol/chat.go and Message.kt.
|
||||
CHAT_SHELLS: "chat_shells",
|
||||
CHAT_SHELL_OUTPUT: "chat_shell_output",
|
||||
|
||||
SUCCESS_END: "#success",
|
||||
FAILURE_END: "#failure",
|
||||
@@ -101,6 +107,13 @@ export const ChatKeys = Object.freeze({
|
||||
// (`chat_reply`), both distinct Message fields in internal/protocol/message.go.
|
||||
PERMISSION: "chat_permission",
|
||||
REPLY: "chat_reply",
|
||||
// The shell commands (C11, internal/protocol/message.go). `chat_shells` carries
|
||||
// its body in `chat_query` (like the other session-scoped commands) and replies
|
||||
// in `chat_shells`; `chat_shell_output` carries `chat_shell_output_query`
|
||||
// ({session_id,shell_id,cursor,limit}) and replies in `chat_shell_output`.
|
||||
SHELLS: "chat_shells",
|
||||
SHELL_OUTPUT: "chat_shell_output",
|
||||
SHELL_OUTPUT_QUERY: "chat_shell_output_query",
|
||||
});
|
||||
|
||||
/**
|
||||
|
||||
@@ -15,6 +15,14 @@ export const CHAT_HISTORY_LIMIT = 200;
|
||||
*/
|
||||
export const WEB_CHAT_CLIENT = "Web";
|
||||
|
||||
/**
|
||||
* The largest shell-output page the server accepts (ChatShellOutputLimit,
|
||||
* 64 KiB). The browser always reads from the page's start and never sends more
|
||||
* than this, so a background task's output can never grow unbounded on the
|
||||
* client.
|
||||
*/
|
||||
export const SHELL_OUTPUT_LIMIT = 64 << 10;
|
||||
|
||||
export class PipelinesRepository {
|
||||
#client;
|
||||
|
||||
@@ -248,6 +256,57 @@ export class PipelinesRepository {
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Lists the currently verified shells this operator chat session owns (C11),
|
||||
* so the conversation can show a background-tasks bar while one is running.
|
||||
* The body is the session-scoped `chat_query` (like chat_messages); the reply
|
||||
* is `chat_shells`, and an older server that returns none answers with an empty
|
||||
* list. A blank session id is refused here, exactly like
|
||||
* PipelinesRepository.chatShells.
|
||||
*/
|
||||
async chatShells(sessionId) {
|
||||
if (!String(sessionId ?? "").trim()) {
|
||||
throw new ProtocolError("Select a chat session first.");
|
||||
}
|
||||
const response = await this.#client.call({
|
||||
type: Protocol.CHAT_SHELLS,
|
||||
[ChatKeys.QUERY]: { session_id: sessionId },
|
||||
});
|
||||
return response[ChatKeys.SHELLS] ?? [];
|
||||
}
|
||||
|
||||
/**
|
||||
* Reads one bounded output page from a verified shell (C11), mirroring
|
||||
* PipelinesRepository.chatShellOutput. The body is exactly
|
||||
* `chat_shell_output_query` — {session_id, shell_id, cursor, limit}, **not** the
|
||||
* `chat_query` the other session commands use — with the cursor always sent so
|
||||
* a refresh rereads from the page's start rather than appending. A blank
|
||||
* session/shell, an out-of-bounds cursor/limit or a reply with no page is
|
||||
* refused with the same reason the Android client uses.
|
||||
*/
|
||||
async chatShellOutput(sessionId, shellId, { cursor = 0, limit = SHELL_OUTPUT_LIMIT } = {}) {
|
||||
if (!String(sessionId ?? "").trim() || !String(shellId ?? "").trim()) {
|
||||
throw new ProtocolError("Select a shell first.");
|
||||
}
|
||||
if (!(cursor >= 0) || !(limit > 0) || limit > SHELL_OUTPUT_LIMIT) {
|
||||
throw new ProtocolError("Shell output bounds are invalid.");
|
||||
}
|
||||
const response = await this.#client.call({
|
||||
type: Protocol.CHAT_SHELL_OUTPUT,
|
||||
[ChatKeys.SHELL_OUTPUT_QUERY]: {
|
||||
session_id: sessionId,
|
||||
shell_id: shellId,
|
||||
cursor,
|
||||
limit,
|
||||
},
|
||||
});
|
||||
const page = response[ChatKeys.SHELL_OUTPUT];
|
||||
if (!page) {
|
||||
throw new ProtocolError("The server returned no shell output page.");
|
||||
}
|
||||
return page;
|
||||
}
|
||||
|
||||
/**
|
||||
* Finishes a session and records it closed on the server (nothing is
|
||||
* deleted). The reply echoes the updated session (`chat_session`) and the
|
||||
|
||||
Reference in New Issue
Block a user