Merge branch 'main' into web-notify

This commit is contained in:
2026-10-19 14:11:46 +01:00
6 changed files with 1329 additions and 75 deletions
+191
View File
@@ -7,13 +7,23 @@ import assert from "node:assert/strict";
import {
BACKGROUND_TASKS_TITLE,
BACKGROUND_TASK_VISIBLE_ROWS,
CHAT_ACTIONS_LABEL,
CHAT_COMMANDS,
CHAT_COMMAND_DISMISS_LABEL,
CHAT_COMMAND_FAILED_LABEL,
CHAT_COMMAND_GLYPH,
CHAT_COMMAND_LABEL,
CHAT_FOLLOW_THRESHOLD_PX,
CHAT_HIDE_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_UNDO_ACTION,
COMPOSER_SEND,
COMPOSER_STOP,
ChatTurn,
@@ -53,6 +63,7 @@ import {
TURN_THINKING_WINDOW_MILLIS,
appendChatNotice,
applyChatEvent,
applyChatOverrides,
applyChatPermission,
approvalCard,
approvalResources,
@@ -72,6 +83,7 @@ import {
chatNoMatchMessage,
chatNoticeLabel,
chatOpensAtNewest,
chatSeenWatermark,
chatShowJumpToLatest,
chatStreamState,
closeChatConfirmation,
@@ -80,15 +92,24 @@ import {
composerSendEnabled,
composerSubmit,
decisionLabel,
decodeChatOverrides,
decodeChatSeen,
deltaPartId,
directoryLabel,
dismissChatNotice,
emptyChatOverrides,
emptyChatSeen,
encodeChatOverrides,
encodeChatSeen,
filterSessions,
formatToolDuration,
groupSessionsByDirectory,
hideChatOverride,
historyResync,
isChatSessionUnseen,
lineDiff,
makeChatNotice,
markChatUnseen,
mergeHistoryPage,
mergeShellFrame,
mergeToolPart,
@@ -98,12 +119,16 @@ import {
permissionRiskText,
prettyToolInput,
queuedAfterFrame,
readChatSeen,
reasoningLabel,
renameChatOverride,
restoreChatOverride,
resumedThread,
runningAfterFrame,
runningBackgroundShells,
runningToolElapsedMillis,
runningToolStamps,
seedChatSeen,
sessionActivity,
sessionActivityBadge,
sessionChipLabel,
@@ -1612,3 +1637,169 @@ test("a step that ends does not clear a background shell that outlives the turn"
assert.equal(resumed.selectedShellId, null);
assert.equal(resumed.shellOutput, null);
});
// ---------------------------------------------------------------------------
// C13: the local overrides and the seen state (ChatOverrides.kt / ChatSeen.kt)
// ---------------------------------------------------------------------------
const sess = (id, title, updated_at) => ({ id, title, updated_at });
test("local overrides: a local title wins on every refresh, trimmed, blanks ignored", () => {
const sessions = [sess("a", "Server A", 100), sess("b", "Server B", 200)];
// No overrides: the server's own list is returned untouched.
assert.equal(applyChatOverrides(sessions, emptyChatOverrides()), sessions);
let overrides = renameChatOverride(emptyChatOverrides(), "a", " My A ");
assert.deepEqual(overrides.titles, { a: "My A" });
const applied = applyChatOverrides(sessions, overrides);
assert.equal(applied[0].title, "My A");
assert.equal(applied[1].title, "Server B");
// A later refresh (the server's own title still "Server A") keeps the local name.
assert.equal(applyChatOverrides(sessions, overrides)[0].title, "My A");
// A blank id or a blank/whitespace title changes nothing (identity preserved).
assert.equal(renameChatOverride(overrides, "a", " "), overrides);
assert.equal(renameChatOverride(overrides, " ", "Nope"), overrides);
// A rename for another id is recorded without touching the first.
const both = renameChatOverride(overrides, "b", "Bee");
assert.deepEqual(both.titles, { a: "My A", b: "Bee" });
assert.equal(applyChatOverrides(sessions, both)[1].title, "Bee");
// Re-recording the same trimmed title is a no-op (same object).
assert.equal(renameChatOverride(both, "b", " Bee "), both);
});
test("hide + undo: one entry per id, blank ignored, restore returns the prior state", () => {
const overrides = emptyChatOverrides();
const hidden = hideChatOverride(overrides, "s1");
assert.deepEqual(hidden.hidden, ["s1"]);
// Already hidden: nothing changes, and no duplicate is appended.
assert.equal(hideChatOverride(hidden, "s1"), hidden);
assert.equal(hideChatOverride(hidden, " "), hidden);
const sessions = [sess("s1", "One", 1), sess("s2", "Two", 2)];
assert.deepEqual(applyChatOverrides(sessions, hidden).map((s) => s.id), ["s2"]);
const restored = restoreChatOverride(hidden, "s1");
assert.deepEqual(restored.hidden, []);
assert.deepEqual(applyChatOverrides(sessions, restored).map((s) => s.id), ["s1", "s2"]);
// Restoring something that was never hidden changes nothing.
assert.equal(restoreChatOverride(restored, "s9"), restored);
// Hide then undo returns the original model.
assert.deepEqual(restoreChatOverride(hideChatOverride(overrides, "s1"), "s1"), overrides);
});
test("overrides JSON round-trips, and unreadable/wrong-typed input decodes to empty", () => {
const overrides = renameChatOverride(hideChatOverride(emptyChatOverrides(), "gone"), "kept", "Name");
assert.deepEqual(decodeChatOverrides(encodeChatOverrides(overrides)), overrides);
for (const corrupt of [null, "", "not json", "{", "[]", '"x"', "42"]) {
assert.deepEqual(decodeChatOverrides(corrupt), emptyChatOverrides());
}
// Wrong-typed fields fall back to the empty model rather than throwing.
assert.deepEqual(decodeChatOverrides('{"titles":[],"hidden":"x"}'), emptyChatOverrides());
assert.deepEqual(decodeChatOverrides('{"titles":{"a":3},"hidden":[7,"ok","ok"]}').hidden, ["ok"]);
assert.deepEqual(decodeChatOverrides('{"titles":{"":"x","b":" B "}}'), { titles: { b: "B" }, hidden: [] });
});
test("seen JSON round-trips, de-duplicates unseen, and tolerates corrupt input", () => {
let seen = markChatUnseen(emptyChatSeen(), "s1");
seen = markChatUnseen(seen, "s1"); // duplicate
seen = readChatSeen(seen, "s2", 500);
const decoded = decodeChatSeen(encodeChatSeen(seen));
assert.deepEqual(decoded.seenAt, { s2: 500 });
assert.deepEqual(decoded.unseen, ["s1"]);
for (const corrupt of [null, "", "not json", "{", "[]", "true"]) {
assert.deepEqual(decodeChatSeen(corrupt), emptyChatSeen());
}
assert.deepEqual(decodeChatSeen('{"seenAt":[],"unseen":"x"}'), emptyChatSeen());
const tolerated = decodeChatSeen('{"seenAt":{"a":10,"b":"x","":5},"unseen":["u","u",""]}');
assert.deepEqual(tolerated.seenAt, { a: 10 });
assert.deepEqual(tolerated.unseen, ["u"]);
});
test("first sight seeding: a baseline is set once and never clears an explicit unseen", () => {
const sessions = [sess("a", "A", 100), sess("b", "B", 0)];
const seeded = seedChatSeen(emptyChatSeen(), sessions, null);
assert.deepEqual(seeded.seenAt, { a: 100 });
// An absent or zero recency is never recorded.
assert.equal(seeded.seenAt.b, undefined);
// A later, higher recency is not re-seeded over the existing baseline.
const later = seedChatSeen(seeded, [sess("a", "A", 300)], null);
assert.deepEqual(later.seenAt, { a: 100 });
// Seeding never clears an unseen mark.
const marked = markChatUnseen(seeded, "a");
const reseeded = seedChatSeen(marked, [sess("a", "A", 400)], null);
assert.deepEqual(reseeded.unseen, ["a"]);
// The active session is read (watermark advances, the mark clears).
const active = seedChatSeen(markChatUnseen(emptyChatSeen(), "a"), [sess("a", "A", 900)], "a");
assert.deepEqual(active.seenAt, { a: 900 });
assert.deepEqual(active.unseen, []);
});
test("reading advances the watermark monotonically and always clears the mark", () => {
const first = readChatSeen(emptyChatSeen(), "s", 100);
assert.equal(chatSeenWatermark(first, "s"), 100);
// A stale read cannot rewind it...
assert.equal(readChatSeen(first, "s", 50), first);
// ...an equal read is not "newer" either...
assert.equal(readChatSeen(first, "s", 100), first);
// ...but a strictly newer one advances.
assert.equal(chatSeenWatermark(readChatSeen(first, "s", 101), "s"), 101);
// A mark is cleared even when the recency does not advance.
const marked = markChatUnseen(first, "s");
const read = readChatSeen(marked, "s", 100);
assert.deepEqual(read.unseen, []);
assert.equal(read.seenAt.s, 100);
// A blank id is a no-op.
assert.equal(readChatSeen(first, " ", 500), first);
});
test("the unseen rule: not active, explicit mark or never-opened-and-strictly-newer", () => {
let seen = readChatSeen(emptyChatSeen(), "opened", 100);
seen = readChatSeen(seen, "equal", 100);
// A watermark ahead of the session's own recency: not newer, so not new.
seen = readChatSeen(seen, "old", 120);
const opened = sess("opened", "Opened", 200); // moved on after it was read
const fresh = sess("fresh", "Fresh", 150);
const equal = sess("equal", "Equal", 100);
const old = sess("old", "Old", 50);
// The active session is never new, even with an explicit mark.
assert.equal(
isChatSessionUnseen(opened, { activeId: "opened", seen: markChatUnseen(seen, "opened"), opened: true }),
false,
);
// A never-opened session is new only while strictly newer than the watermark.
assert.equal(isChatSessionUnseen(fresh, { seen, opened: false }), true);
assert.equal(isChatSessionUnseen(equal, { seen, opened: false }), false);
assert.equal(isChatSessionUnseen(old, { seen, opened: false }), false);
// A session already opened here is judged by the explicit mark alone.
assert.equal(isChatSessionUnseen(opened, { seen, opened: true }), false);
assert.equal(isChatSessionUnseen(opened, { seen: markChatUnseen(seen, "opened"), opened: true }), true);
});
test("the C13 wording matches the Android sources verbatim", () => {
assert.equal(CHAT_RENAME_ACTION, "Rename…");
assert.equal(CHAT_HIDE_ACTION, "Hide on this device");
assert.equal(CHAT_ACTIONS_LABEL, "Chat actions");
assert.equal(CHAT_REMOVED_MESSAGE, "Hidden on this device; the chat stays on the server.");
assert.equal(CHAT_UNDO_ACTION, "Undo");
assert.equal(CHAT_RENAME_TITLE, "Rename chat");
assert.equal(CHAT_RENAME_FIELD_LABEL, "Name");
assert.equal(
CHAT_RENAME_HELPER,
"The server has no rename for a chat, so this name is kept on this device.",
);
assert.equal(CHAT_RENAME_SAVE, "Save");
assert.equal(CHAT_RENAME_DISMISS, "Cancel");
// The badge precedence words, with Open only while the conversation is open.
assert.equal(sessionActivityBadge(sessionActivity(true, true), true), "Streaming");
assert.equal(sessionActivityBadge(sessionActivity(false, true), true), "New");
assert.equal(sessionActivityBadge(sessionActivity(false, false), true), "Open");
assert.equal(sessionActivityBadge(sessionActivity(false, false), false), null);
});
+356 -23
View File
@@ -2,7 +2,9 @@
// Chrome, connect to a running Pipelines server through the page's own proxy,
// and capture what actually rendered.
//
// node test/ui-smoke.mjs [--port 8091] [--pipelines 127.0.0.1:8080] [--out DIR] [--scratch]
// node test/ui-smoke.mjs [--port PORT] [--pipelines 127.0.0.1:8080] [--out DIR] [--scratch]
//
// Without --port the OS picks a free port, so concurrent checks do not collide.
//
// This is the UI evidence a review stage produces: real screenshots of the
// rendered client, not a claim. It needs a running Pipelines server (the live one
@@ -57,7 +59,12 @@ function flag(argv, name, fallback) {
return i !== -1 && argv[i + 1] ? argv[i + 1] : fallback;
}
const port = Number(flag(process.argv, "--port", process.env.WEB_UI_PORT ?? 8091));
// No fixed default port: an explicit --port/WEB_UI_PORT still wins, but otherwise
// each run asks the OS for a free one. Concurrent checks (parallel pipeline items)
// therefore never collide on 8091 — the earlier fixed default made a second
// simultaneous UI stage fail with EADDRINUSE.
const explicitPort = flag(process.argv, "--port", process.env.WEB_UI_PORT);
const port = explicitPort ? Number(explicitPort) : await freePort();
const pipelines = flag(process.argv, "--pipelines", process.env.PIPELINES_TARGET ?? "127.0.0.1:8080");
const out = resolve(
flag(process.argv, "--out", process.env.WEB_UI_OUT ?? join(tmpdir(), "pipelines-web-ui")),
@@ -166,6 +173,16 @@ async function openRunDetail(runId) {
}
}
// Open one chat row's Chat actions menu (the row's management items live behind
// it since C13: Rename… / Close chat… or Reopen / Hide on this device).
async function openChatRowMenu(sessionId) {
await page.click(`#chatRows .chat-row[data-session="${sessionId}"] .chat-menu-button`);
await page.waitForSelector(
`#chatRows .chat-row[data-session="${sessionId}"] .chat-menu-panel`,
{ timeout: 10000 },
);
}
// --- P5: create a pipeline from a template (scratch server only) -----------
// The scratch server has no real runs and no live chat, so this is the whole
// point of a `--scratch` run. It opens a template, opens the create action,
@@ -1703,6 +1720,9 @@ try {
await page.waitForSelector(".detail .detail-tabs", { timeout: 25000 });
await page.clickText(".detail .detail-tabs .detail-tab", "Graph");
await page.waitForSelector(".run-detail .graph-node", { timeout: 15000 });
// The run can stop (or be reported `running` with no stage in flight) between
// the list read and this graph, so treat the halo as the best effort its
// comment promises rather than failing the whole run on a race.
const live = await eventually(
async () =>
page.evaluate(`(() => {
@@ -1715,11 +1735,15 @@ try {
};
})()`),
{ timeout: 15000, what: "the live run's active stage" },
);
if (!live.badge) throw new Error(`the active stage showed no elapsed badge: ${JSON.stringify(live)}`);
console.log(` live run ${liveRunId}: active stage ${live.activeKey} (pulsing=${live.pulsing}), badge ${live.badge}`);
await page.rect(".run-detail .graph-viewport");
shots.push(await page.screenshot(`${out}/31-run-live-graph.png`));
).catch(() => null);
if (!live) {
console.log(` -- run ${liveRunId} shows no stage in flight; skipped the live graph halo capture`);
} else {
if (!live.badge) throw new Error(`the active stage showed no elapsed badge: ${JSON.stringify(live)}`);
console.log(` live run ${liveRunId}: active stage ${live.activeKey} (pulsing=${live.pulsing}), badge ${live.badge}`);
await page.rect(".run-detail .graph-viewport");
shots.push(await page.screenshot(`${out}/31-run-live-graph.png`));
}
}
// The Output empty state, on the running run that has not produced output yet.
@@ -2622,7 +2646,8 @@ try {
title: row.querySelector(".chat-row-title")?.textContent ?? "",
chips: [...row.querySelectorAll(".chip")].map((chip) => chip.textContent),
meta: row.querySelector(".chat-row-meta")?.textContent ?? "",
close: !!row.querySelector(".chat-close"),
menu: !!row.querySelector(".chat-menu-button"),
menuLabel: row.querySelector(".chat-menu-button")?.getAttribute("aria-label") ?? "",
})),
}))()`);
if (chatList.label !== "Search chats") throw new Error(`chat search label: ${chatList.label}`);
@@ -2632,7 +2657,9 @@ try {
if (!chatList.rows[0].chips.includes("Operator")) {
throw new Error(`chat kind chip: ${chatList.rows[0].chips.join(", ")}`);
}
if (!chatList.rows[0].close) throw new Error("the open chat row offers no Close chat action");
if (!chatList.rows[0].menu || chatList.rows[0].menuLabel !== "Chat actions") {
throw new Error(`the open chat row's Chat actions menu: ${JSON.stringify(chatList.rows[0])}`);
}
console.log(
` chat list: ${chatList.rows.length} session(s); "${chatList.rows[0].title}" ` +
`[${chatList.rows[0].chips.join(", ")}] — ${chatList.rows[0].meta}`,
@@ -2640,9 +2667,11 @@ try {
await shot("44-chat-sessions.png");
// The row's own Close chat… action with NO conversation open: the list offers
// it on every open row, so the confirm must still appear. Shown and dismissed
// with Cancel; no chat_close is ever sent for the operator's live session.
await page.click(`#chatRows .chat-row[data-session="${chatList.rows[0].id}"] .chat-close`);
// it on every open row (behind the Chat actions menu), so the confirm must
// still appear. Shown and dismissed with Cancel; no chat_close is ever sent for
// the operator's live session.
await openChatRowMenu(chatList.rows[0].id);
await page.click(`#chatRows .chat-row[data-session="${chatList.rows[0].id}"] .chat-menu-close`);
await page.waitForSelector(".confirm-chat-close", { timeout: 15000 });
const listClose = await page.evaluate(
`document.querySelector(".confirm-chat-close .confirm-message")?.textContent ?? ""`,
@@ -2682,6 +2711,12 @@ try {
const candidates = [
...new Set([...(preferred ? [preferred.id] : []), ...openRows, ...chatList.rows.map((r) => r.id)]),
];
// Record the frames the page sends from before the first genuine open. With
// more than one row the test switches away and re-opens, so the assertion below
// sees that fresh open; with a server that lists only one session the first
// click is itself the fresh open (clicking it again would early-return), and
// clearing here would throw that real request away.
await page.evaluate(`(() => { window.__pipelinesSentTypes = []; return true; })()`);
let openedId = null;
for (const candidate of candidates) {
await page.click(`#chatRows .chat-row[data-session="${candidate}"]`);
@@ -2702,15 +2737,17 @@ try {
}
// Leave the discovered session first: the loop above already opened it, and
// openChatSession keeps a loaded thread, so clicking it again would early-return
// and send nothing. Opening a different row restores a genuine fresh open.
// and send nothing. Opening a different row restores a genuine fresh open. With
// only one listed session there is no other row, so the loop's own open above is
// the fresh-open proof.
const otherRow = candidates.find((id) => id !== openedId);
if (otherRow) {
await page.click(`#chatRows .chat-row[data-session="${otherRow}"]`);
await new Promise((resolve) => setTimeout(resolve, 600));
await page.evaluate(`(() => { window.__pipelinesSentTypes = []; return true; })()`);
} else {
console.log(" -- the server lists one session, so the first open above is the fresh-open proof");
}
// Record the frames the page sends, so the C11 chat_shells fetch on open is
// asserted rather than assumed.
await page.evaluate(`(() => { window.__pipelinesSentTypes = []; return true; })()`);
await page.click(`#chatRows .chat-row[data-session="${openedId}"]`);
await page.waitForSelector("#chatTranscript", { timeout: 25000 });
await eventually(
@@ -3184,7 +3221,8 @@ try {
if (!beforeDialog || beforeDialog.top == null || beforeDialog.top === 0) {
throw new Error(`the transcript was not mid-scroll before the dialog: ${JSON.stringify(beforeDialog)}`);
}
await page.click(`#chatRows .chat-row[data-session="${openedId}"] .chat-close`);
await openChatRowMenu(openedId);
await page.click(`#chatRows .chat-row[data-session="${openedId}"] .chat-menu-close`);
await page.waitForSelector(".confirm-chat-close", { timeout: 15000 });
const closeDialog = await page.evaluate(`(() => ({
title: document.querySelector(".confirm-chat-close .confirm-title")?.textContent ?? "",
@@ -3603,10 +3641,11 @@ try {
// (e) `/new` creates a fresh throwaway session (C2's chat_create, sent directly
// until C2 lands) and opens it. The operator's session is left untouched. The
// throwaway is created EPHEMERAL: this check drives the real page, so without it
// every run would leave a permanent "New chat" in the operator's chat list (the
// server writes no operator-registry row for an ephemeral create).
await page.evaluate(`window.__pipelinesEphemeralChat = true`);
// throwaway must stay a listed server session: C12's notice check switches away
// to another row and back to it, and C13 reads its row for the device-local
// rename; an ephemeral create (2fe6301's `__pipelinesEphemeralChat`) is hidden
// from `chat_sessions`, so it is deliberately NOT used here. The session is
// closed again in cleanup, like the New-marker throwaway C13 creates itself.
await page.fill("#chatInput", "/new");
await page.evaluate(
`document.querySelector("#chatInput").dispatchEvent(new KeyboardEvent("keydown", { key: "Enter", bubbles: true, cancelable: true }))`,
@@ -3823,15 +3862,31 @@ try {
),
{ timeout: 15000, what: "the throwaway session to show as closed" },
);
await openChatRowMenu(throwawayId);
const closedRow = await page.evaluate(`(() => {
const row = document.querySelector('.chat-row[data-session="${throwawayId}"]');
row?.scrollIntoView({ block: "center" });
return {
closed: !!row?.querySelector(".chat-closed-chip"),
hasClose: !!row?.querySelector(".chat-close"),
hasReopen: !!row?.querySelector(".chat-reopen"),
items: [...row.querySelectorAll(".chat-menu-panel .chat-menu-item")].map((b) => b.textContent),
hasClose: !!row?.querySelector(".chat-menu-close"),
hasReopen: !!row?.querySelector(".chat-menu-reopen"),
};
})()`);
if (!closedRow.closed || !closedRow.hasReopen || closedRow.hasClose) {
throw new Error(`the closed row's Chat actions menu: ${JSON.stringify(closedRow)}`);
}
if (closedRow.items.join("|") !== "Rename…|Reopen|Hide on this device") {
throw new Error(`the closed row's menu items and order: ${JSON.stringify(closedRow.items)}`);
}
// Close the menu again (a second press on its own button toggles it shut).
await page.evaluate(
`document.querySelector('.chat-row[data-session="${throwawayId}"] .chat-menu-button')?.click()`,
);
await eventually(
() => page.evaluate(`!document.querySelector('.chat-row[data-session="${throwawayId}"] .chat-menu-panel')`),
{ timeout: 5000, what: "the closed row's menu to close" },
);
// Closing finishes the session: the conversation leaves the pane (back to the
// list with the select hint) and no row stays selected, as Android's
// finishSession does.
@@ -5221,6 +5276,284 @@ try {
);
console.log(" chat_shells re-fetched after the stream reconnect (real request)");
// C13: this device's own chat changes — a local rename that wins over the
// server's title, the hide + Undo report, and the seen/New marker. Every
// action here is device-local (localStorage): nothing is sent to the server for
// a rename or a hide, and the closed throwaway session from C8 is the row used
// for the rename/hide captures so the operator's live session is never hidden
// in a way the run leaves behind (Hide is undone before the marker step).
step("C13: local rename/hide, the hide snackbar and the seen/New marker");
await ensureConnected();
await page.evaluate(`(() => {
const tab = [...document.querySelectorAll("nav.tabs button.tab")].find((b) => b.textContent.trim() === "Chat");
if (tab) tab.click();
return !!tab;
})()`);
await page.waitForSelector("#chatRows .chat-row", { timeout: 25000 });
// (a) Rename… opens the dialog: its exact title, the field label, the pre-fill
// and the helper, and Save disabled while the trimmed value is blank.
await openChatRowMenu(throwawayId);
await page.click(`#chatRows .chat-row[data-session="${throwawayId}"] .chat-menu-rename`);
await page.waitForSelector(".confirm-chat-rename", { timeout: 10000 });
await page.waitForSelector("#chatRenameInput", { timeout: 5000 });
const renameDialog = await page.evaluate(`(() => ({
title: document.querySelector(".confirm-chat-rename .confirm-title")?.textContent ?? "",
label: document.querySelector(".confirm-chat-rename .chat-rename-label")?.textContent ?? "",
value: document.querySelector("#chatRenameInput")?.value ?? null,
helper: document.querySelector(".confirm-chat-rename .chat-rename-helper")?.textContent ?? "",
save: document.querySelector(".chat-rename-save")?.textContent ?? "",
cancel: document.querySelector(".chat-rename-cancel")?.textContent ?? "",
}))()`);
if (renameDialog.title !== "Rename chat") throw new Error(`rename title: ${renameDialog.title}`);
if (renameDialog.label !== "Name") throw new Error(`rename field label: ${renameDialog.label}`);
if (renameDialog.value !== "New chat") throw new Error(`rename pre-fill: ${JSON.stringify(renameDialog.value)}`);
if (
renameDialog.helper !==
"The server has no rename for a chat, so this name is kept on this device."
) {
throw new Error(`rename helper: ${renameDialog.helper}`);
}
if (renameDialog.save !== "Save" || renameDialog.cancel !== "Cancel") {
throw new Error(`rename buttons: ${JSON.stringify(renameDialog)}`);
}
// Typing toggles Save in place: blank (whitespace) disables it, a real value
// enables it, with no re-render of the transcript underneath.
await page.fill("#chatRenameInput", " ");
await eventually(
() => page.evaluate(`document.querySelector(".chat-rename-save")?.disabled === true`),
{ timeout: 5000, what: "Save to disable while the name is blank" },
);
console.log(` rename dialog: "${renameDialog.title}" / "${renameDialog.label}" pre-filled "${renameDialog.value}"; Save disabled while blank`);
await shot("72-chat-rename-dialog.png");
// (b) Save a locally-titled name; the row shows it now and after a server list
// refresh, and the overrides JSON is in localStorage under its own key.
await page.fill("#chatRenameInput", "Local capture chat");
await eventually(
() => page.evaluate(`document.querySelector(".chat-rename-save")?.disabled === false`),
{ timeout: 5000, what: "Save to enable for a non-blank name" },
);
await page.click(".chat-rename-save");
await eventually(() => page.evaluate(`!document.querySelector(".confirm-chat-rename")`), {
timeout: 5000,
what: "the rename dialog to close on Save",
});
const renamedTitle = await eventually(
async () => {
const value = await page.evaluate(
`document.querySelector('.chat-row[data-session="${throwawayId}"] .chat-row-title')?.textContent ?? ""`,
);
return value === "Local capture chat" ? value : false;
},
{ timeout: 8000, what: "the renamed row to show its local title" },
);
console.log(` row ${throwawayId} shows the local title "${renamedTitle}"`);
// Refresh the list from the server (the same header Refresh the page offers);
// the local title must still win over the server's own.
await page.clickText("nav.tabs button.ghost", "Refresh");
await eventually(
() =>
page.evaluate(
`document.querySelector('.chat-row[data-session="${throwawayId}"] .chat-row-title')?.textContent === "Local capture chat"`,
),
{ timeout: 15000, what: "the local title to survive a server list refresh" },
);
const storedOverrides = await page.evaluate(`localStorage.getItem("pipelines.web.chatOverrides.v1")`);
const overridesJson = JSON.parse(storedOverrides ?? "{}");
if (overridesJson.titles?.[throwawayId] !== "Local capture chat") {
throw new Error(`the local title was not persisted: ${storedOverrides}`);
}
console.log(` after a server list refresh the row still reads "${renamedTitle}"; localStorage ${storedOverrides}`);
await shot("73-chat-renamed-row.png");
// The final row's menu must not be clipped by the list's rounded-corner
// overflow: assert the Hide item's own centre is the element a real click
// would hit (the review measured the panel cut off at the list's bottom edge
// on the last rows). The menu is closed again without acting on it.
const lastRowId = await page.evaluate(
`(() => { const rows = [...document.querySelectorAll("#chatRows .chat-row")]; return rows.at(-1)?.dataset.session ?? ""; })()`,
);
if (!lastRowId) throw new Error("C13: no last row to test the menu against");
await page.evaluate(`document.querySelector('.chat-row[data-session="${lastRowId}"]')?.scrollIntoView({ block: "center" })`);
await openChatRowMenu(lastRowId);
const lastMenuHit = await page.evaluate(`(() => {
const button = document.querySelector('.chat-row[data-session="${lastRowId}"] .chat-menu-hide');
if (!button) return { found: false };
const rect = button.getBoundingClientRect();
const x = rect.left + rect.width / 2;
const y = rect.top + rect.height / 2;
const hit = document.elementFromPoint(x, y);
return {
found: true,
label: button.textContent,
hit: hit === button || button.contains(hit),
rect: { top: rect.top, bottom: rect.bottom },
viewport: window.innerHeight,
listBottom: document.querySelector(".chat-list")?.getBoundingClientRect().bottom ?? null,
};
})()`);
if (!lastMenuHit.found || !lastMenuHit.hit) {
throw new Error(`C13: the last row's menu item is not clickable: ${JSON.stringify(lastMenuHit)}`);
}
console.log(
` last row ${lastRowId}: "${lastMenuHit.label}" is hit-testable at its centre (menu bottom ${Math.round(lastMenuHit.rect.bottom)}, viewport ${lastMenuHit.viewport})`,
);
await page.click(`#chatRows .chat-row[data-session="${lastRowId}"] .chat-menu-button`);
await eventually(
() => page.evaluate(`!document.querySelector('.chat-row[data-session="${lastRowId}"] .chat-menu-panel')`),
{ timeout: 5000, what: "the last row's menu to close again" },
);
// (c) Hide the row the conversation is open on: it disappears, its conversation
// closes, and one snackbar carries the exact message and Undo. Undo puts the
// row back and leaves the server untouched.
const activeBeforeHide = await page.evaluate(
`document.querySelector(".chat-row.selected")?.dataset.session ?? ""`,
);
if (!activeBeforeHide) throw new Error("C13: no conversation was open before the hide");
await openChatRowMenu(activeBeforeHide);
await page.click(`#chatRows .chat-row[data-session="${activeBeforeHide}"] .chat-menu-hide`);
await page.waitForSelector(".chat-snackbar", { timeout: 10000 });
const hiddenState = await page.evaluate(`(() => ({
row: !!document.querySelector('.chat-row[data-session="${activeBeforeHide}"]'),
snackbars: document.querySelectorAll(".chat-snackbar").length,
message: document.querySelector(".chat-snackbar-message")?.textContent ?? "",
undo: document.querySelector(".chat-snackbar-undo")?.textContent ?? "",
hint: document.querySelector(".chat-detail .empty .muted")?.textContent ?? "",
composer: !!document.querySelector("#chatComposer"),
hidden: JSON.parse(localStorage.getItem("pipelines.web.chatOverrides.v1") ?? "{}").hidden ?? [],
}))()`);
if (hiddenState.row) throw new Error(`C13: the hidden row is still listed: ${JSON.stringify(hiddenState)}`);
if (hiddenState.snackbars !== 1) throw new Error(`C13: expected one snackbar, got ${hiddenState.snackbars}`);
if (hiddenState.message !== "Hidden on this device; the chat stays on the server.") {
throw new Error(`C13: snackbar message ${JSON.stringify(hiddenState.message)}`);
}
if (hiddenState.undo !== "Undo") throw new Error(`C13: snackbar action ${JSON.stringify(hiddenState.undo)}`);
if (hiddenState.composer || hiddenState.hint !== "Select a chat to open it.") {
throw new Error(`C13: hiding the open conversation did not close it: ${JSON.stringify(hiddenState)}`);
}
if (!hiddenState.hidden.includes(activeBeforeHide)) {
throw new Error(`C13: the hidden id was not persisted: ${JSON.stringify(hiddenState.hidden)}`);
}
console.log(
` hid ${activeBeforeHide}: row gone, conversation closed, one snackbar "${hiddenState.message}" with "${hiddenState.undo}"`,
);
await shot("74-chat-hide-snackbar.png");
// Undo restores the row (and only here: the conversation stays closed, exactly
// as Android's undoRemove does) and clears the hidden list.
await page.click(".chat-snackbar-undo");
await eventually(
() =>
page.evaluate(
`!!document.querySelector('.chat-row[data-session="${activeBeforeHide}"]') && !document.querySelector(".chat-snackbar")`,
),
{ timeout: 8000, what: "Undo to restore the hidden row and clear the snackbar" },
);
const afterUndo = await page.evaluate(
`JSON.parse(localStorage.getItem("pipelines.web.chatOverrides.v1") ?? "{}").hidden ?? []`,
);
if (afterUndo.includes(activeBeforeHide)) {
throw new Error(`C13: Undo left the id hidden: ${JSON.stringify(afterUndo)}`);
}
console.log(` Undo restored ${activeBeforeHide}; hidden ids now ${JSON.stringify(afterUndo)}`);
// (d) The "New" marker, honestly: the restart rule. A fresh throwaway is
// prompted and stopped, and the page is then reloaded — its threads are empty
// while the persisted watermark predates the turn, so the non-active row reads
// New after the reconnect. First reopen the operator conversation so `/new`
// has a directory.
await page.evaluate(`document.querySelector('.chat-row[data-session="${sessionId}"]')?.click()`);
await page.waitForSelector("#chatTranscript", { timeout: 20000 });
await page.fill("#chatInput", "/new");
await page.evaluate(
`document.querySelector("#chatInput").dispatchEvent(new KeyboardEvent("keydown", { key: "Enter", bubbles: true, cancelable: true }))`,
);
const newMarkerId = await eventually(
async () => {
const id = await page.evaluate(`document.querySelector(".chat-row.selected")?.dataset.session ?? ""`);
return id && id !== sessionId && id !== throwawayId ? id : false;
},
{ timeout: 25000, what: "the fresh throwaway session to open for the New-marker step" },
);
await page.waitForSelector("#chatInput", { timeout: 10000 });
// The watermark for this session is seeded at its creation recency; a real
// prompt then advances the server's updated_at past it.
await page.fill("#chatInput", "Reply with exactly one word: hi");
await page.evaluate(
`document.querySelector("#chatInput").dispatchEvent(new KeyboardEvent("keydown", { key: "Enter", bubbles: true, cancelable: true }))`,
);
await page.waitForSelector("#chatStop", { timeout: 20000 });
await page.click("#chatStop");
await eventually(
() =>
page.evaluate(
`[...document.querySelectorAll(".chat-command-notice-text")].some((n) => n.textContent === "Stopping the running turn…")`,
),
{ timeout: 15000, what: "the New-marker throwaway turn to be interrupted" },
);
const watermarkBefore = await page.evaluate(
`JSON.parse(localStorage.getItem("pipelines.web.chatSeen.v1") ?? "{}").seenAt?.[${JSON.stringify(newMarkerId)}] ?? 0`,
);
// A reload empties the page's threads and re-reads the server list: the row is
// no longer active, and its server recency has moved past the stored watermark.
await page.evaluate(`location.reload()`);
await page.waitForSelector("#url", { timeout: 15000 });
// A reload starts idle: open the configured endpoint through the header's own
// control (the same connect-only path the Settings destination uses).
await page.evaluate(`(() => {
const control = document.querySelector("#reconnectBtn") || document.querySelector("#connectBtn");
if (control) control.click();
return !!control;
})()`);
await ensureConnected(30000);
await page.clickText("nav.tabs button.tab", "Chat");
await page.waitForSelector("#chatRows .chat-row", { timeout: 25000 });
const newMarker = await eventually(
async () => {
const value = await page.evaluate(`(() => {
const row = document.querySelector('.chat-row[data-session="${newMarkerId}"]');
const word = row?.querySelector(".chat-activity-new .chat-activity-word")?.textContent ?? "";
return { word, selected: !!row?.classList.contains("selected") };
})()`);
return value.word === "New" ? value : false;
},
{ timeout: 15000, what: "the non-active row to carry the New marker after the reload" },
);
const watermarkAfter = await page.evaluate(
`JSON.parse(localStorage.getItem("pipelines.web.chatSeen.v1") ?? "{}").seenAt?.[${JSON.stringify(newMarkerId)}] ?? 0`,
);
console.log(
` after the reload, non-active ${newMarkerId} carries the New marker ` +
`(watermark before the turn ${watermarkBefore}, after the reload ${watermarkAfter})`,
);
await shot("75-chat-new-marker.png");
// Cleanup: open the New-marker throwaway and /close it, so the run leaves no
// open session of its own (the rename override on the earlier throwaway is
// device-local and the browser profile is temporary).
await page.evaluate(`document.querySelector('.chat-row[data-session="${newMarkerId}"]')?.click()`);
await page.waitForSelector("#chatInput", { timeout: 20000 });
await page.fill("#chatInput", "/close");
await page.evaluate(
`document.querySelector("#chatInput").dispatchEvent(new KeyboardEvent("keydown", { key: "Enter", bubbles: true, cancelable: true }))`,
);
await page.waitForSelector(".confirm-chat-close", { timeout: 15000 });
await page.click(".confirm-chat-close .confirm-accept");
await eventually(() => page.evaluate(`!document.querySelector(".confirm-chat-close")`), {
timeout: 15000,
what: "the New-marker throwaway to close",
});
await eventually(
() =>
page.evaluate(
`!!document.querySelector('.chat-row[data-session="${newMarkerId}"] .chat-closed-chip')`,
),
{ timeout: 15000, what: "the New-marker throwaway to show as closed" },
);
console.log(` cleanup: /close closed the New-marker throwaway ${newMarkerId}`);
console.log("\nUI SMOKE PASS");
for (const shot of shots) console.log(` ${shot}`);
}