Merge branch 'main' into web-notify
This commit is contained in:
+448
-45
@@ -237,20 +237,30 @@ import {
|
||||
} from "./actions.js";
|
||||
import {
|
||||
BACKGROUND_TASKS_TITLE,
|
||||
CHAT_ACTIONS_LABEL,
|
||||
CHAT_ATTACH_LABEL,
|
||||
CHAT_COMMAND_DISMISS_LABEL,
|
||||
CHAT_COMMAND_GLYPH,
|
||||
CHAT_COMPOSER_PLACEHOLDER,
|
||||
CHAT_EMPTY,
|
||||
CHAT_FOLLOW_THRESHOLD_PX,
|
||||
CHAT_HIDE_ACTION,
|
||||
CHAT_LOADING,
|
||||
CHAT_NEW_ACTION,
|
||||
CHAT_NO_MATCH_ACTION,
|
||||
CHAT_QUEUED_NOTICE,
|
||||
CHAT_REMOVED_MESSAGE,
|
||||
CHAT_RENAME_ACTION,
|
||||
CHAT_RENAME_DISMISS,
|
||||
CHAT_RENAME_FIELD_LABEL,
|
||||
CHAT_RENAME_HELPER,
|
||||
CHAT_RENAME_SAVE,
|
||||
CHAT_RENAME_TITLE,
|
||||
CHAT_SEARCH_LABEL,
|
||||
CHAT_SEND_LABEL,
|
||||
CHAT_STOP_LABEL,
|
||||
CHAT_TAB_TITLE,
|
||||
CHAT_UNDO_ACTION,
|
||||
CLOSED_CHIP_LABEL,
|
||||
CLOSED_SECTION_LABEL,
|
||||
CLOSE_CHAT_ACTION,
|
||||
@@ -281,6 +291,7 @@ import {
|
||||
SHELL_OUTPUT_UNAVAILABLE,
|
||||
SHELL_ROW_LABEL,
|
||||
applyChatEvent,
|
||||
applyChatOverrides,
|
||||
applyChatPermission,
|
||||
appendChatNotice,
|
||||
approvalCard,
|
||||
@@ -305,22 +316,35 @@ import {
|
||||
composerCanSend,
|
||||
composerSendEnabled,
|
||||
composerSubmit,
|
||||
decodeChatOverrides,
|
||||
decodeChatSeen,
|
||||
directoryLabel,
|
||||
dismissChatNotice as dismissChatNoticeModel,
|
||||
emptyChatOverrides,
|
||||
emptyChatSeen,
|
||||
encodeChatOverrides,
|
||||
encodeChatSeen,
|
||||
filterSessions,
|
||||
groupSessionsByDirectory,
|
||||
hideChatOverride,
|
||||
historyResync,
|
||||
isChatSessionUnseen,
|
||||
makeChatNotice,
|
||||
markChatUnseen,
|
||||
mergeHistoryPage,
|
||||
mergeShellFrame,
|
||||
newChatThread,
|
||||
parseChatInput,
|
||||
queuedAfterFrame,
|
||||
readChatSeen,
|
||||
reasoningLabel,
|
||||
renameChatOverride,
|
||||
restoreChatOverride,
|
||||
resumedThread,
|
||||
runningAfterFrame,
|
||||
runningBackgroundShells,
|
||||
runningToolElapsedMillis,
|
||||
seedChatSeen,
|
||||
sessionActivity,
|
||||
sessionActivityBadge,
|
||||
sessionChipLabel,
|
||||
@@ -372,6 +396,22 @@ const CHAT_SCROLL_STORAGE_KEY = "pipelines.web.chatScroll.v1";
|
||||
*/
|
||||
const CHAT_DRAFT_STORAGE_KEY = "pipelines.web.chatDraft.v1";
|
||||
|
||||
/**
|
||||
* The operator's own chat changes (C13): local renames and hidden session ids,
|
||||
* the web analogue of Android's `chat_overrides` preference. One JSON value:
|
||||
* `{titles:{"<id>":"<title>"},hidden:["<id>"]}`. A local title wins over the
|
||||
* server's on every later list refresh; a hidden id only disappears here.
|
||||
*/
|
||||
const CHAT_OVERRIDES_STORAGE_KEY = "pipelines.web.chatOverrides.v1";
|
||||
|
||||
/**
|
||||
* What the operator has already seen of the session list (C13), the web analogue
|
||||
* of Android's `chat_seen` preference. One JSON value:
|
||||
* `{seenAt:{"<id>":<updated_at ms>},unseen:["<id>"]}`. The watermark is advanced
|
||||
* only by opening a chat (or first-sight seeding), never by a stale list.
|
||||
*/
|
||||
const CHAT_SEEN_STORAGE_KEY = "pipelines.web.chatSeen.v1";
|
||||
|
||||
/** Shown where tiles exist but the configured server URL cannot resolve them. */
|
||||
const ARTIFACT_SERVER_HINT =
|
||||
"Set the server URL in Settings to open or copy artifact links.";
|
||||
@@ -545,6 +585,18 @@ const state = {
|
||||
// report for a refused close/reopen.
|
||||
chatClose: null,
|
||||
chatBusy: false,
|
||||
// C13: this device's local titles/hidden ids and the seen watermarks, both
|
||||
// persisted as one JSON value each. `chatMenu` is the row whose Chat actions
|
||||
// menu is open, `chatRename` the session whose Rename chat dialog is open, and
|
||||
// `chatSnackbar` the one in-flight hide report (`{id, sessionId}`) with the
|
||||
// timer that auto-dismisses it. A new hide replaces the previous report.
|
||||
chatOverrides: readChatOverridesStore(),
|
||||
chatSeen: readChatSeenStore(),
|
||||
chatMenu: null,
|
||||
chatRename: null,
|
||||
chatSnackbar: null,
|
||||
chatSnackbarSeq: 0,
|
||||
chatSnackbarTimer: null,
|
||||
// C5: the session ids this connection currently has subscribed to their shared
|
||||
// live stream. The server detaches a subscription when the connection closes
|
||||
// (there is no chat_unsubscribe), so this is cleared on every socket drop and
|
||||
@@ -4080,6 +4132,47 @@ function readChatDraft(sessionId) {
|
||||
return typeof value === "string" ? value : "";
|
||||
}
|
||||
|
||||
/** The persisted local chat overrides; unreadable storage means no overrides. */
|
||||
function readChatOverridesStore() {
|
||||
try {
|
||||
return decodeChatOverrides(localStorage.getItem(CHAT_OVERRIDES_STORAGE_KEY));
|
||||
} catch {
|
||||
return emptyChatOverrides();
|
||||
}
|
||||
}
|
||||
|
||||
/** Persist the current local overrides; storage failure leaves memory authoritative. */
|
||||
function saveChatOverrides() {
|
||||
try {
|
||||
localStorage.setItem(CHAT_OVERRIDES_STORAGE_KEY, encodeChatOverrides(state.chatOverrides));
|
||||
} catch {
|
||||
// storage may be full or disabled; the in-memory overrides still hold
|
||||
}
|
||||
}
|
||||
|
||||
/** The persisted seen state; unreadable storage means nothing seen. */
|
||||
function readChatSeenStore() {
|
||||
try {
|
||||
return decodeChatSeen(localStorage.getItem(CHAT_SEEN_STORAGE_KEY));
|
||||
} catch {
|
||||
return emptyChatSeen();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Persist the seen state only when it actually changed. Every frame and refresh
|
||||
* would otherwise rewrite localStorage for no reason.
|
||||
*/
|
||||
function saveChatSeen(next) {
|
||||
if (next === state.chatSeen) return;
|
||||
state.chatSeen = next;
|
||||
try {
|
||||
localStorage.setItem(CHAT_SEEN_STORAGE_KEY, encodeChatSeen(state.chatSeen));
|
||||
} catch {
|
||||
// storage may be full or disabled; the in-memory state still holds
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* The pixels the transcript still sits above its end (0 when at the bottom), via
|
||||
* the same pure decision the unit tests cover. `chatBottomDistancePx` measures
|
||||
@@ -4147,6 +4240,10 @@ async function loadChatSessions(force = false) {
|
||||
try {
|
||||
state.chatSessions = await repo.chatSessions();
|
||||
state.chatLoaded = true;
|
||||
// Fold this device's seen state in: the active chat has been read, and every
|
||||
// session seen for the first time gets a baseline so pre-existing chats are
|
||||
// not all reported as new.
|
||||
saveChatSeen(seedChatSeen(state.chatSeen, state.chatSessions, state.chatActiveId));
|
||||
} catch (error) {
|
||||
state.chatError = describeError(error);
|
||||
}
|
||||
@@ -4161,11 +4258,16 @@ async function openChatSession(id) {
|
||||
const leaving = document.getElementById("chatTranscript");
|
||||
if (leaving && state.chatActiveId) saveChatScroll(state.chatActiveId, currentChatPosition(leaving));
|
||||
state.chatActiveId = id;
|
||||
state.chatMenu = null;
|
||||
state.chatPlaced = null;
|
||||
state.chatFollowing = true;
|
||||
state.chatReasoning = new Set();
|
||||
state.chatToolPanels = new Set();
|
||||
state.chatToolRows = new Set();
|
||||
// Opening reads the conversation: advance the watermark to its current recency
|
||||
// and clear the explicit unseen mark (a row that is absent has no recency).
|
||||
const session = state.chatSessions.find((candidate) => candidate.id === id) ?? null;
|
||||
saveChatSeen(readChatSeen(state.chatSeen, id, session?.updated_at ?? 0));
|
||||
const existing = state.chatThreads.get(id);
|
||||
state.chatThreads.set(id, {
|
||||
...newChatThread(id),
|
||||
@@ -4245,11 +4347,23 @@ function settleChatThreads() {
|
||||
function onChatEvent(frame) {
|
||||
const sessionId = String(frame?.session_id ?? "").trim();
|
||||
if (!sessionId || !state.chatThreads.has(sessionId)) return;
|
||||
markBackgroundChatUnseen(sessionId);
|
||||
const thread = state.chatThreads.get(sessionId);
|
||||
state.chatThreads.set(sessionId, applyChatEvent(thread, frame, Date.now()));
|
||||
renderContent();
|
||||
}
|
||||
|
||||
/**
|
||||
* A frame for a conversation that is not on screen marks it explicitly unseen,
|
||||
* so its live activity is visible in the list even though a pushed stream carries
|
||||
* no wall-clock recency to compare. The active chat is read as it arrives and is
|
||||
* never marked.
|
||||
*/
|
||||
function markBackgroundChatUnseen(sessionId) {
|
||||
if (!sessionId || sessionId === state.chatActiveId) return;
|
||||
saveChatSeen(markChatUnseen(state.chatSeen, sessionId));
|
||||
}
|
||||
|
||||
/**
|
||||
* Fold one pushed `chat_permission` frame into its conversation (C10). Only a
|
||||
* conversation this client has open is folded — the server only pushes a
|
||||
@@ -4461,6 +4575,7 @@ async function loadOlderChatHistory(id) {
|
||||
|
||||
/** Open the Close chat? confirm for [session] (the mutation only on confirm). */
|
||||
function openChatClose(session) {
|
||||
state.chatMenu = null;
|
||||
state.chatClose = session;
|
||||
renderContent();
|
||||
}
|
||||
@@ -4508,6 +4623,7 @@ async function acceptChatClose(session) {
|
||||
async function reopenChatSession(id) {
|
||||
if (state.chatBusy) return;
|
||||
state.chatBusy = true;
|
||||
state.chatMenu = null;
|
||||
renderContent();
|
||||
try {
|
||||
const { session: updated } = await repo.reopenChat(id);
|
||||
@@ -4526,6 +4642,136 @@ function applyChatSessionUpdate(id, updated, closed) {
|
||||
);
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// This device's chat changes (C13): local rename, hide + undo, row menu
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/** The server row with this device's local title applied (for the open pane). */
|
||||
function effectiveChatSession(session) {
|
||||
if (!session) return null;
|
||||
return applyChatOverrides([session], state.chatOverrides)[0] ?? session;
|
||||
}
|
||||
|
||||
/** Open one row's Chat actions menu, closing any other. */
|
||||
function openChatMenu(sessionId) {
|
||||
state.chatMenu = state.chatMenu === sessionId ? null : sessionId;
|
||||
renderContent();
|
||||
// The re-render replaced the focused button; move focus into the panel so a
|
||||
// keyboard operator can walk the items without hunting for the next Tab stop.
|
||||
if (state.chatMenu) {
|
||||
const first = document.querySelector(`#chatRows .chat-row[data-session="${CSS.escape(sessionId)}"] .chat-menu-item`);
|
||||
first?.focus();
|
||||
}
|
||||
}
|
||||
|
||||
/** Open the Rename chat dialog for [session] (its current effective title). */
|
||||
function openChatRename(session) {
|
||||
state.chatMenu = null;
|
||||
state.chatRename = session;
|
||||
renderContent();
|
||||
// Same re-render note as the menu: put the cursor in the Name field.
|
||||
document.getElementById("chatRenameInput")?.focus();
|
||||
}
|
||||
|
||||
function dismissChatRename() {
|
||||
state.chatRename = null;
|
||||
renderContent();
|
||||
}
|
||||
|
||||
/**
|
||||
* Record a local rename, persist it and reflect it at once: the row shows the
|
||||
* local title on the next render (and every later refresh), and an open
|
||||
* conversation's own title follows. Nothing is sent to the server — the
|
||||
* brokered protocol has no chat rename.
|
||||
*/
|
||||
function applyLocalChatRename(sessionId, title) {
|
||||
const next = renameChatOverride(state.chatOverrides, sessionId, title);
|
||||
if (next === state.chatOverrides) return false;
|
||||
state.chatOverrides = next;
|
||||
saveChatOverrides();
|
||||
const local = next.titles[String(sessionId)];
|
||||
if (local != null) setThread(sessionId, { title: local });
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* The dialog's Save: trim, record the override, close the dialog and re-render.
|
||||
* A blank title is ignored (Save is already disabled while trimmed-blank).
|
||||
*/
|
||||
function acceptChatRename(session, title) {
|
||||
const trimmed = String(title ?? "").trim();
|
||||
if (trimmed === "") return;
|
||||
applyLocalChatRename(session.id, trimmed);
|
||||
state.chatRename = null;
|
||||
renderContent();
|
||||
}
|
||||
|
||||
/**
|
||||
* Hide a session on this device only. The server is not asked to delete
|
||||
* anything: the row disappears from this list, its conversation closes, and the
|
||||
* one snackbar says exactly that with an Undo. A new hide replaces the previous
|
||||
* report (one snackbar slot), never queues behind it.
|
||||
*/
|
||||
function hideChatLocally(sessionId) {
|
||||
const id = String(sessionId ?? "");
|
||||
if (!id) return;
|
||||
const next = hideChatOverride(state.chatOverrides, id);
|
||||
if (next === state.chatOverrides) return;
|
||||
state.chatOverrides = next;
|
||||
saveChatOverrides();
|
||||
state.chatMenu = null;
|
||||
state.chatRename = null;
|
||||
// Hiding closes the conversation, exactly as Android's remove does: the thread
|
||||
// is dropped, the active id cleared and the subscription forgotten.
|
||||
state.chatThreads.delete(id);
|
||||
if (state.chatActiveId === id) {
|
||||
state.chatActiveId = null;
|
||||
state.chatPlaced = null;
|
||||
}
|
||||
if (state.chatSubscriptions.has(id)) {
|
||||
state.chatSubscriptions = new Set(state.chatSubscriptions);
|
||||
state.chatSubscriptions.delete(id);
|
||||
}
|
||||
installChatSnackbar(id);
|
||||
renderContent();
|
||||
}
|
||||
|
||||
/** Replace the one in-flight hide report and (re)start its auto-dismiss timer. */
|
||||
function installChatSnackbar(sessionId) {
|
||||
if (state.chatSnackbarTimer != null) clearTimeout(state.chatSnackbarTimer);
|
||||
state.chatSnackbarSeq += 1;
|
||||
const id = state.chatSnackbarSeq;
|
||||
state.chatSnackbar = { id, sessionId };
|
||||
state.chatSnackbarTimer = setTimeout(() => {
|
||||
state.chatSnackbarTimer = null;
|
||||
if (state.chatSnackbar?.id !== id) return;
|
||||
state.chatSnackbar = null;
|
||||
renderContent();
|
||||
}, 6000);
|
||||
}
|
||||
|
||||
/** Undo the last hide: restore its row and clear the report (nothing server-side). */
|
||||
function undoHideChat() {
|
||||
const sessionId = state.chatSnackbar?.sessionId;
|
||||
if (!sessionId) return;
|
||||
const next = restoreChatOverride(state.chatOverrides, sessionId);
|
||||
if (next !== state.chatOverrides) {
|
||||
state.chatOverrides = next;
|
||||
saveChatOverrides();
|
||||
}
|
||||
clearChatSnackbar();
|
||||
renderContent();
|
||||
}
|
||||
|
||||
/** Drop the hide report and its timer (Undo, expiry, or leaving the list). */
|
||||
function clearChatSnackbar() {
|
||||
if (state.chatSnackbarTimer != null) {
|
||||
clearTimeout(state.chatSnackbarTimer);
|
||||
state.chatSnackbarTimer = null;
|
||||
}
|
||||
state.chatSnackbar = null;
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// The composer and its slash commands (C8 · C9)
|
||||
// ---------------------------------------------------------------------------
|
||||
@@ -4712,8 +4958,9 @@ function runChatCommand(sessionId, session, text) {
|
||||
/**
|
||||
* Perform one command effect. `/new` creates a session in the current directory
|
||||
* and opens it (the create request is C2's; until C2 lands the browser sends
|
||||
* `chat_create` directly); `/close` reuses the C3 confirm; `/rename` is the local
|
||||
* rename pending C13; `/stop` interrupts; `/help` shows the command list.
|
||||
* `chat_create` directly); `/close` reuses the C3 confirm; `/rename` writes to
|
||||
* C13's durable device-local store; `/stop` interrupts; `/help` shows the
|
||||
* command list.
|
||||
*/
|
||||
function applyChatCommandEffect(sessionId, session, effect) {
|
||||
switch (effect.kind) {
|
||||
@@ -4778,16 +5025,15 @@ async function startChatSession(directory) {
|
||||
}
|
||||
|
||||
/**
|
||||
* `/rename`: rename the session on this device only. C13 owns the durable local
|
||||
* rename/hide store; until it lands this renames the held row and the open
|
||||
* conversation in memory and says so.
|
||||
* `/rename`: rename the session on this device only, through the same durable
|
||||
* store the row's Rename chat dialog uses (C13). The local title wins over the
|
||||
* server's on every later refresh; nothing is sent to the server.
|
||||
*/
|
||||
function renameChatSessionLocally(sessionId, title) {
|
||||
state.chatSessions = state.chatSessions.map((session) =>
|
||||
session.id === sessionId ? { ...session, title } : session,
|
||||
);
|
||||
setThread(sessionId, { title });
|
||||
addChatNotice(sessionId, `Renamed this session to “${title}” on this device only; the server's title is unchanged.`);
|
||||
const trimmed = String(title ?? "").trim();
|
||||
if (trimmed === "") return;
|
||||
applyLocalChatRename(sessionId, trimmed);
|
||||
addChatNotice(sessionId, `Renamed this session to “${trimmed}” on this device only; the server's title is unchanged.`);
|
||||
}
|
||||
|
||||
/** The composer's Stop control: interrupt the session's running turn. */
|
||||
@@ -4921,7 +5167,9 @@ function removeChatAttachment(sessionId, attachmentId) {
|
||||
}
|
||||
|
||||
function renderChatList() {
|
||||
const list = h("div", { class: "list chat-list" });
|
||||
// The open menu must not be clipped by the list's rounded-corner overflow; the
|
||||
// class is present only while a menu is open, so the normal list stays clipped.
|
||||
const list = h("div", { class: `list chat-list${state.chatMenu ? " menu-open" : ""}` });
|
||||
const toolbar = h("div", { class: "list-toolbar chat-toolbar" });
|
||||
toolbar.append(
|
||||
h("input", {
|
||||
@@ -4961,7 +5209,8 @@ function fillChatRows(rows) {
|
||||
rows.append(empty);
|
||||
return;
|
||||
}
|
||||
const filtered = filterSessions(state.chatSessions, state.chatQuery);
|
||||
const visible = applyChatOverrides(state.chatSessions, state.chatOverrides);
|
||||
const filtered = filterSessions(visible, state.chatQuery);
|
||||
if (filtered.length === 0 && state.chatQuery.trim() !== "") {
|
||||
const empty = chatEmpty(chatNoMatchMessage(state.chatQuery));
|
||||
empty.append(
|
||||
@@ -5027,7 +5276,14 @@ function chatEmpty(message) {
|
||||
function renderChatRow(session) {
|
||||
const open = state.chatActiveId === session.id;
|
||||
const thread = state.chatThreads.get(session.id) ?? null;
|
||||
const activity = sessionActivity(thread?.running === true, false);
|
||||
const unseen =
|
||||
!session.closed &&
|
||||
isChatSessionUnseen(session, {
|
||||
activeId: state.chatActiveId,
|
||||
seen: state.chatSeen,
|
||||
opened: state.chatThreads.has(session.id),
|
||||
});
|
||||
const activity = sessionActivity(thread?.running === true, unseen);
|
||||
const badge = sessionActivityBadge(activity, open);
|
||||
const row = h("div", {
|
||||
class: `row chat-row${open ? " selected" : ""}`,
|
||||
@@ -5036,8 +5292,8 @@ function renderChatRow(session) {
|
||||
"data-session": session.id,
|
||||
onclick: () => openChatSession(session.id),
|
||||
onkeydown: (event) => {
|
||||
// Only the row itself opens on Enter/Space; a nested Close chat…/Reopen
|
||||
// button handles its own keyboard activation (and must not double-fire).
|
||||
// Only the row itself opens on Enter/Space; the Chat actions menu handles
|
||||
// its own keyboard activation (and must not double-fire).
|
||||
if (event.target !== event.currentTarget) return;
|
||||
if (event.key === "Enter" || event.key === " ") {
|
||||
event.preventDefault();
|
||||
@@ -5065,38 +5321,82 @@ function renderChatRow(session) {
|
||||
text: sessionMeta(session, sessionWorkLabel(session.busy === true, thread)),
|
||||
}),
|
||||
);
|
||||
const actions = h("div", { class: "chat-row-actions" });
|
||||
if (session.closed) {
|
||||
actions.append(
|
||||
h("button", {
|
||||
class: "ghost chat-reopen",
|
||||
type: "button",
|
||||
text: REOPEN_ACTION,
|
||||
disabled: state.chatBusy,
|
||||
onclick: (event) => {
|
||||
event.stopPropagation();
|
||||
reopenChatSession(session.id);
|
||||
},
|
||||
}),
|
||||
);
|
||||
} else {
|
||||
actions.append(
|
||||
h("button", {
|
||||
class: "ghost chat-close",
|
||||
type: "button",
|
||||
text: CLOSE_CHAT_ACTION,
|
||||
disabled: state.chatBusy,
|
||||
onclick: (event) => {
|
||||
event.stopPropagation();
|
||||
openChatClose(session);
|
||||
},
|
||||
}),
|
||||
);
|
||||
}
|
||||
row.append(actions);
|
||||
row.append(renderChatActionsMenu(session));
|
||||
return row;
|
||||
}
|
||||
|
||||
/**
|
||||
* One row's Chat actions menu, with Android's items in its order: Rename…, then
|
||||
* Close chat… (open) or Reopen (closed), then Hide on this device. Closing is the
|
||||
* shared, server-side finish; hiding only affects this device and says so.
|
||||
*/
|
||||
function renderChatActionsMenu(session) {
|
||||
const wrap = h("div", { class: "chat-row-actions chat-menu-wrap" });
|
||||
const expanded = state.chatMenu === session.id;
|
||||
wrap.append(
|
||||
h("button", {
|
||||
class: "ghost chat-menu-button",
|
||||
type: "button",
|
||||
text: "⋯",
|
||||
"aria-label": CHAT_ACTIONS_LABEL,
|
||||
"aria-haspopup": "menu",
|
||||
"aria-expanded": expanded ? "true" : "false",
|
||||
title: CHAT_ACTIONS_LABEL,
|
||||
onclick: (event) => {
|
||||
event.stopPropagation();
|
||||
openChatMenu(session.id);
|
||||
},
|
||||
}),
|
||||
);
|
||||
if (expanded) {
|
||||
const menu = h("div", { class: "chat-menu-panel", role: "menu", "aria-label": CHAT_ACTIONS_LABEL });
|
||||
menu.addEventListener("click", (event) => event.stopPropagation());
|
||||
menu.append(
|
||||
h("button", {
|
||||
class: "ghost chat-menu-item chat-menu-rename",
|
||||
type: "button",
|
||||
role: "menuitem",
|
||||
text: CHAT_RENAME_ACTION,
|
||||
onclick: () => openChatRename(session),
|
||||
}),
|
||||
);
|
||||
if (session.closed) {
|
||||
menu.append(
|
||||
h("button", {
|
||||
class: "ghost chat-menu-item chat-menu-reopen",
|
||||
type: "button",
|
||||
role: "menuitem",
|
||||
text: REOPEN_ACTION,
|
||||
disabled: state.chatBusy,
|
||||
onclick: () => reopenChatSession(session.id),
|
||||
}),
|
||||
);
|
||||
} else {
|
||||
menu.append(
|
||||
h("button", {
|
||||
class: "ghost chat-menu-item chat-menu-close",
|
||||
type: "button",
|
||||
role: "menuitem",
|
||||
text: CLOSE_CHAT_ACTION,
|
||||
disabled: state.chatBusy,
|
||||
onclick: () => openChatClose(session),
|
||||
}),
|
||||
);
|
||||
}
|
||||
menu.append(
|
||||
h("button", {
|
||||
class: "ghost chat-menu-item chat-menu-hide",
|
||||
type: "button",
|
||||
role: "menuitem",
|
||||
text: CHAT_HIDE_ACTION,
|
||||
onclick: () => hideChatLocally(session.id),
|
||||
}),
|
||||
);
|
||||
wrap.append(menu);
|
||||
}
|
||||
return wrap;
|
||||
}
|
||||
|
||||
/** The active conversation: identity, context, transcript and its controls. */
|
||||
function renderChatConversation() {
|
||||
const pane = h("div", { class: "detail chat-detail" });
|
||||
@@ -5106,8 +5406,9 @@ function renderChatConversation() {
|
||||
return pane;
|
||||
}
|
||||
const session = state.chatSessions.find((candidate) => candidate.id === state.chatActiveId) ?? null;
|
||||
const effective = effectiveChatSession(session);
|
||||
const thread = state.chatThreads.get(state.chatActiveId) ?? null;
|
||||
const title = session ? sessionTitle(session) : state.chatActiveId.slice(0, 18);
|
||||
const title = effective ? sessionTitle(effective) : state.chatActiveId.slice(0, 18);
|
||||
// The pending approval card (C10), derived from the stored frame plus the local
|
||||
// answer. While it is actionable the top bar offers a jump control and the
|
||||
// running indicator stands down (a turn blocked on a decision is not generating).
|
||||
@@ -5219,9 +5520,89 @@ function renderChatConversation() {
|
||||
*/
|
||||
function appendChatDialogs(pane) {
|
||||
if (state.chatClose) pane.append(renderChatCloseDialog(state.chatClose));
|
||||
if (state.chatRename) pane.append(renderChatRenameDialog(state.chatRename));
|
||||
if (state.chatSnackbar) pane.append(renderChatSnackbar());
|
||||
if (state.actionError) pane.append(renderActionFailedDialog());
|
||||
}
|
||||
|
||||
/**
|
||||
* The one hide report (C13): the exact Android message and an `Undo` action. It
|
||||
* is a fixed overlay (so a re-render or the transcript's height never moves it)
|
||||
* and it is replaced, never queued, by a newer hide.
|
||||
*/
|
||||
function renderChatSnackbar() {
|
||||
const bar = h("div", { class: "chat-snackbar", role: "status" });
|
||||
bar.append(h("span", { class: "chat-snackbar-message", text: CHAT_REMOVED_MESSAGE }));
|
||||
bar.append(
|
||||
h("button", {
|
||||
class: "ghost chat-snackbar-undo",
|
||||
type: "button",
|
||||
text: CHAT_UNDO_ACTION,
|
||||
onclick: () => undoHideChat(),
|
||||
}),
|
||||
);
|
||||
return bar;
|
||||
}
|
||||
|
||||
/**
|
||||
* The Rename chat dialog (C13): a locally-kept name, with the helper that says so
|
||||
* plainly. Save is disabled while the trimmed value is blank; typing toggles that
|
||||
* state directly, so the transcript's scroll is never disturbed by a re-render.
|
||||
* Nothing is sent to the server — there is no chat rename on the wire.
|
||||
*/
|
||||
function renderChatRenameDialog(session) {
|
||||
const effective = effectiveChatSession(session) ?? session;
|
||||
const overlay = h("div", {
|
||||
class: "confirm-dialog confirm-chat-rename",
|
||||
role: "dialog",
|
||||
"aria-modal": "true",
|
||||
"aria-label": CHAT_RENAME_TITLE,
|
||||
});
|
||||
overlay.addEventListener("click", (event) => {
|
||||
if (event.target === overlay) dismissChatRename();
|
||||
});
|
||||
const panel = h("div", { class: "confirm-panel" });
|
||||
panel.append(h("h2", { class: "confirm-title", text: CHAT_RENAME_TITLE }));
|
||||
const field = h("div", { class: "chat-rename-field" });
|
||||
field.append(h("label", { class: "chat-rename-label", for: "chatRenameInput", text: CHAT_RENAME_FIELD_LABEL }));
|
||||
const input = h("input", {
|
||||
id: "chatRenameInput",
|
||||
class: "rename-input chat-rename-input",
|
||||
type: "text",
|
||||
value: sessionTitle(effective),
|
||||
spellcheck: "false",
|
||||
autocomplete: "off",
|
||||
});
|
||||
field.append(input);
|
||||
panel.append(field);
|
||||
panel.append(h("p", { class: "chat-rename-helper", text: CHAT_RENAME_HELPER }));
|
||||
const actions = h("div", { class: "confirm-actions" });
|
||||
actions.append(
|
||||
h("button", {
|
||||
class: "ghost confirm-dismiss chat-rename-cancel",
|
||||
type: "button",
|
||||
text: CHAT_RENAME_DISMISS,
|
||||
onclick: dismissChatRename,
|
||||
}),
|
||||
);
|
||||
const save = h("button", {
|
||||
class: "confirm-accept chat-rename-save",
|
||||
type: "button",
|
||||
text: CHAT_RENAME_SAVE,
|
||||
disabled: input.value.trim() === "",
|
||||
onclick: () => acceptChatRename(session, input.value),
|
||||
});
|
||||
// Toggle Save in place on input: no renderContent, so the transcript's scroll
|
||||
// position (C14) is untouched while the operator types.
|
||||
input.addEventListener("input", () => {
|
||||
save.disabled = input.value.trim() === "";
|
||||
});
|
||||
actions.append(save);
|
||||
panel.append(actions);
|
||||
overlay.append(panel);
|
||||
return overlay;
|
||||
}
|
||||
|
||||
/**
|
||||
* The background-tasks bar (C11): the running shells this conversation still
|
||||
* owns. It returns null (renders nothing) unless at least one shell is running,
|
||||
@@ -7162,6 +7543,11 @@ document.addEventListener("keydown", (event) => {
|
||||
dismissActionError();
|
||||
return;
|
||||
}
|
||||
if (state.chatRename) {
|
||||
event.preventDefault();
|
||||
dismissChatRename();
|
||||
return;
|
||||
}
|
||||
if (state.chatClose) {
|
||||
event.preventDefault();
|
||||
dismissChatClose();
|
||||
@@ -7182,12 +7568,29 @@ document.addEventListener("keydown", (event) => {
|
||||
closeStagePane();
|
||||
return;
|
||||
}
|
||||
if (state.chatMenu) {
|
||||
event.preventDefault();
|
||||
state.chatMenu = null;
|
||||
renderContent();
|
||||
return;
|
||||
}
|
||||
if (state.searchOpen) {
|
||||
event.preventDefault();
|
||||
closeSearch();
|
||||
}
|
||||
});
|
||||
|
||||
// A click anywhere outside an open Chat actions menu closes it, so a menu never
|
||||
// lingers behind another row's selection. The wrap element (button + panel)
|
||||
// keeps its own clicks from closing it.
|
||||
document.addEventListener("click", (event) => {
|
||||
if (!state.chatMenu) return;
|
||||
const target = event.target;
|
||||
if (target instanceof Element && target.closest(".chat-menu-wrap")) return;
|
||||
state.chatMenu = null;
|
||||
renderContent();
|
||||
});
|
||||
|
||||
// Return-to-foreground recovery (T4): the page becomes visible again, or the
|
||||
// browser reports it is back online, and the client drives its socket back
|
||||
// without waiting out the backoff. DOM-only, and idempotent.
|
||||
|
||||
Reference in New Issue
Block a user