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.
|
||||
|
||||
+262
@@ -33,6 +33,10 @@
|
||||
// ui/chat/ChatFormat.kt attachmentError, attachmentFiles,
|
||||
// MAX_ATTACHMENT_BYTES, attachmentDisplayName
|
||||
// ui/chat/ChatAttachments.kt the attachment display name/error rules
|
||||
// ui/chat/ChatOverrides.kt ChatSessionOverrides: local titles + hidden ids,
|
||||
// applied over every server list refresh
|
||||
// ui/chat/ChatSeen.kt ChatSeenState: the seen watermark and explicit
|
||||
// unseen marks behind the row's "New" badge
|
||||
//
|
||||
// Nothing here touches the DOM or imports the app: every wording and decision is
|
||||
// unit-tested without a browser. The caller sets each server string with
|
||||
@@ -561,6 +565,264 @@ export function closeChatConfirmation(title) {
|
||||
);
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Local overrides and seen state (ChatOverrides.kt / ChatSeen.kt)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/** The row menu and the rename dialog, verbatim from ChatListPane.kt. */
|
||||
export const CHAT_RENAME_ACTION = "Rename…";
|
||||
export const CHAT_HIDE_ACTION = "Hide on this device";
|
||||
export const CHAT_ACTIONS_LABEL = "Chat actions";
|
||||
export const CHAT_REMOVED_MESSAGE = "Hidden on this device; the chat stays on the server.";
|
||||
export const CHAT_UNDO_ACTION = "Undo";
|
||||
export const CHAT_RENAME_TITLE = "Rename chat";
|
||||
export const CHAT_RENAME_FIELD_LABEL = "Name";
|
||||
export const CHAT_RENAME_HELPER =
|
||||
"The server has no rename for a chat, so this name is kept on this device.";
|
||||
export const CHAT_RENAME_SAVE = "Save";
|
||||
export const CHAT_RENAME_DISMISS = "Cancel";
|
||||
|
||||
/** The empty override model: no local titles, nothing hidden. */
|
||||
export function emptyChatOverrides() {
|
||||
return { titles: {}, hidden: [] };
|
||||
}
|
||||
|
||||
/** The empty seen model: no watermarks, no explicit unseen marks. */
|
||||
export function emptyChatSeen() {
|
||||
return { seenAt: {}, unseen: [] };
|
||||
}
|
||||
|
||||
/** A positive finite epoch-millisecond value, else 0 (never NaN). */
|
||||
function millis(value) {
|
||||
const number = Number(value);
|
||||
return Number.isFinite(number) && number > 0 ? number : 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Decode a stored overrides value. Blank text, `null`, corrupt JSON, an array and
|
||||
* wrong-typed fields all fall back to the empty model; nothing here throws, so a
|
||||
* bad preference can never break the list.
|
||||
*/
|
||||
export function decodeChatOverrides(stored) {
|
||||
const empty = emptyChatOverrides();
|
||||
if (stored == null || stored === "") return empty;
|
||||
let parsed = stored;
|
||||
if (typeof stored === "string") {
|
||||
if (stored.trim() === "") return empty;
|
||||
try {
|
||||
parsed = JSON.parse(stored);
|
||||
} catch {
|
||||
return empty;
|
||||
}
|
||||
}
|
||||
if (parsed == null || typeof parsed !== "object" || Array.isArray(parsed)) return empty;
|
||||
|
||||
const titles = {};
|
||||
const rawTitles = parsed.titles;
|
||||
if (rawTitles != null) {
|
||||
if (typeof rawTitles !== "object" || Array.isArray(rawTitles)) return empty;
|
||||
for (const [id, title] of Object.entries(rawTitles)) {
|
||||
if (isBlank(id) || typeof title !== "string" || isBlank(title)) continue;
|
||||
titles[id] = title.trim();
|
||||
}
|
||||
}
|
||||
|
||||
const hidden = [];
|
||||
const rawHidden = parsed.hidden;
|
||||
if (rawHidden != null) {
|
||||
if (!Array.isArray(rawHidden)) return empty;
|
||||
for (const id of rawHidden) {
|
||||
if (typeof id !== "string" || isBlank(id) || hidden.includes(id)) continue;
|
||||
hidden.push(id);
|
||||
}
|
||||
}
|
||||
return { titles, hidden };
|
||||
}
|
||||
|
||||
/** The one-line JSON an overrides value is stored as. */
|
||||
export function encodeChatOverrides(overrides) {
|
||||
return JSON.stringify({
|
||||
titles: { ...(overrides?.titles ?? {}) },
|
||||
hidden: [...(overrides?.hidden ?? [])],
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Decode a stored seen value with the same tolerance as the overrides: blank,
|
||||
* corrupt or wrong-typed input is nothing seen, never an exception. Unseen ids
|
||||
* are de-duplicated.
|
||||
*/
|
||||
export function decodeChatSeen(stored) {
|
||||
const empty = emptyChatSeen();
|
||||
if (stored == null || stored === "") return empty;
|
||||
let parsed = stored;
|
||||
if (typeof stored === "string") {
|
||||
if (stored.trim() === "") return empty;
|
||||
try {
|
||||
parsed = JSON.parse(stored);
|
||||
} catch {
|
||||
return empty;
|
||||
}
|
||||
}
|
||||
if (parsed == null || typeof parsed !== "object" || Array.isArray(parsed)) return empty;
|
||||
|
||||
const seenAt = {};
|
||||
const rawSeenAt = parsed.seenAt;
|
||||
if (rawSeenAt != null) {
|
||||
if (typeof rawSeenAt !== "object" || Array.isArray(rawSeenAt)) return empty;
|
||||
for (const [id, value] of Object.entries(rawSeenAt)) {
|
||||
const at = millis(value);
|
||||
if (isBlank(id) || at <= 0) continue;
|
||||
seenAt[id] = at;
|
||||
}
|
||||
}
|
||||
|
||||
const unseen = [];
|
||||
const rawUnseen = parsed.unseen;
|
||||
if (rawUnseen != null) {
|
||||
if (!Array.isArray(rawUnseen)) return empty;
|
||||
for (const id of rawUnseen) {
|
||||
if (typeof id !== "string" || isBlank(id) || unseen.includes(id)) continue;
|
||||
unseen.push(id);
|
||||
}
|
||||
}
|
||||
return { seenAt, unseen };
|
||||
}
|
||||
|
||||
/** The one-line JSON a seen value is stored as. */
|
||||
export function encodeChatSeen(seen) {
|
||||
return JSON.stringify({
|
||||
seenAt: { ...(seen?.seenAt ?? {}) },
|
||||
unseen: [...(seen?.unseen ?? [])],
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Record a local rename. A blank id or a title that is blank after trimming
|
||||
* changes nothing; a recorded title is trimmed, and it wins over the server's
|
||||
* own on every later refresh.
|
||||
*/
|
||||
export function renameChatOverride(overrides, id, title) {
|
||||
const current = overrides ?? emptyChatOverrides();
|
||||
const trimmed = str(title).trim();
|
||||
const key = str(id);
|
||||
if (isBlank(key) || trimmed === "") return current;
|
||||
if (current.titles?.[key] === trimmed) return current;
|
||||
return { ...current, titles: { ...(current.titles ?? {}), [key]: trimmed } };
|
||||
}
|
||||
|
||||
/**
|
||||
* Hide a session on this device. A blank id or an already-hidden id changes
|
||||
* nothing, and an id is never appended twice.
|
||||
*/
|
||||
export function hideChatOverride(overrides, id) {
|
||||
const current = overrides ?? emptyChatOverrides();
|
||||
const key = str(id);
|
||||
const hidden = current.hidden ?? [];
|
||||
if (isBlank(key) || hidden.includes(key)) return current;
|
||||
return { ...current, hidden: [...hidden, key] };
|
||||
}
|
||||
|
||||
/** Restore a hidden session, undoing [hideChatOverride]. */
|
||||
export function restoreChatOverride(overrides, id) {
|
||||
const current = overrides ?? emptyChatOverrides();
|
||||
const key = str(id);
|
||||
const hidden = current.hidden ?? [];
|
||||
if (!hidden.includes(key)) return current;
|
||||
return { ...current, hidden: hidden.filter((entry) => entry !== key) };
|
||||
}
|
||||
|
||||
/**
|
||||
* The server's sessions with this device's overrides applied: hidden ids are
|
||||
* removed (the set is built once, so each row is O(1)) and a local title replaces
|
||||
* the server's. A blank/absent server title still falls through to
|
||||
* `sessionTitle` at render time.
|
||||
*/
|
||||
export function applyChatOverrides(sessions, overrides) {
|
||||
const list = Array.isArray(sessions) ? sessions : [];
|
||||
const titles = overrides?.titles ?? {};
|
||||
const hiddenIds = new Set(overrides?.hidden ?? []);
|
||||
if (hiddenIds.size === 0 && Object.keys(titles).length === 0) return list;
|
||||
return list
|
||||
.filter((session) => !hiddenIds.has(str(session?.id)))
|
||||
.map((session) => {
|
||||
const local = titles[str(session?.id)];
|
||||
return typeof local === "string" && local.trim() !== ""
|
||||
? { ...session, title: local.trim() }
|
||||
: session;
|
||||
});
|
||||
}
|
||||
|
||||
/** The newest recency the operator has seen for [id], or 0 when never seen. */
|
||||
export function chatSeenWatermark(seen, id) {
|
||||
const value = seen?.seenAt?.[str(id)];
|
||||
return millis(value);
|
||||
}
|
||||
|
||||
/**
|
||||
* Record the first sight of every listed session, so a pre-existing chat is not
|
||||
* reported as new activity. The active session is read (it is on screen); every
|
||||
* other session is seeded only when it has no watermark yet and its recency is a
|
||||
* real timestamp. An explicit unseen mark is never cleared by seeding.
|
||||
*/
|
||||
export function seedChatSeen(seen, sessions, activeId) {
|
||||
let next = seen ?? emptyChatSeen();
|
||||
for (const session of Array.isArray(sessions) ? sessions : []) {
|
||||
const id = str(session?.id);
|
||||
const updatedAt = millis(session?.updated_at);
|
||||
if (isBlank(id) || updatedAt <= 0) continue;
|
||||
if (id === str(activeId)) {
|
||||
next = readChatSeen(next, id, updatedAt);
|
||||
} else if (chatSeenWatermark(next, id) === 0) {
|
||||
next = { ...next, seenAt: { ...(next.seenAt ?? {}), [id]: updatedAt } };
|
||||
}
|
||||
}
|
||||
return next;
|
||||
}
|
||||
|
||||
/**
|
||||
* Read [id] up to [updatedAt]: the watermark advances only when the value is
|
||||
* strictly newer (a stale read can never rewind it) and any explicit unseen mark
|
||||
* is cleared. A blank id changes nothing.
|
||||
*/
|
||||
export function readChatSeen(seen, id, updatedAt) {
|
||||
const current = seen ?? emptyChatSeen();
|
||||
const key = str(id);
|
||||
if (isBlank(key)) return current;
|
||||
const at = millis(updatedAt);
|
||||
const advanced = at > chatSeenWatermark(current, key);
|
||||
const unseen = current.unseen ?? [];
|
||||
const marked = unseen.includes(key);
|
||||
if (!advanced && !marked) return current;
|
||||
return {
|
||||
seenAt: advanced ? { ...(current.seenAt ?? {}), [key]: at } : { ...(current.seenAt ?? {}) },
|
||||
unseen: marked ? unseen.filter((entry) => entry !== key) : [...unseen],
|
||||
};
|
||||
}
|
||||
|
||||
/** Mark [id] as moved on while it was not on screen; blank ids and duplicates no-op. */
|
||||
export function markChatUnseen(seen, id) {
|
||||
const current = seen ?? emptyChatSeen();
|
||||
const key = str(id);
|
||||
const unseen = current.unseen ?? [];
|
||||
if (isBlank(key) || unseen.includes(key)) return current;
|
||||
return { ...current, seenAt: { ...(current.seenAt ?? {}) }, unseen: [...unseen, key] };
|
||||
}
|
||||
|
||||
/**
|
||||
* The exact `ChatState.isUnseen` rule: a session is new only when it is not the
|
||||
* active one and either an explicit unseen mark exists or it has never been
|
||||
* opened here and its `updated_at` is strictly newer than the stored watermark.
|
||||
*/
|
||||
export function isChatSessionUnseen(session, { activeId = null, seen = null, opened = false } = {}) {
|
||||
const id = str(session?.id);
|
||||
if (isBlank(id) || id === str(activeId)) return false;
|
||||
if ((seen?.unseen ?? []).includes(id)) return true;
|
||||
if (opened) return false;
|
||||
return millis(session?.updated_at) > chatSeenWatermark(seen, id);
|
||||
}
|
||||
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Session narrowing and grouping (ChatListFilter.kt)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
Reference in New Issue
Block a user