Merge branch 'main' into web-chat-create
# Conflicts: # web/PARITY.md # web/src/app.js # web/test/chat.test.mjs # web/test/ui-smoke.mjs
This commit is contained in:
+9
-6
@@ -96,11 +96,11 @@ the pipeline list already carries — rather than a pluralised verb.
|
||||
| C6 | Reasoning block + tool calls with name/input for the whole lifecycle | `chat_event` | done — the assistant turn draws, in order, its one collapsible reasoning block and its one tool-call chip (then the answer). Reasoning labels match the app: `Thinking…` / `Reasoning` for a single step and `Thinking · {N} steps` / `Reasoning · {N} steps` for several, with ` · {duration}` appended when the parts' timing gives a settled span (earliest start → latest completed), through chevrons named `Show reasoning` / `Hide reasoning`. The chip reads `1 tool called` / `{N} tools called`, announces `… expand for details`, wears the shared spinner while a call is in flight and an error tint once one failed, and opens a fixed overlay panel under the chip (flipped above / clamped into the viewport when there is no room) with the same count, a `Close tool calls` control and an internally scrolling, independently-expandable row per call: the name (else `tool`), the first of `description`/`command`/`filePath`/`file_path`/`path`/`pattern`/`query`/`url` collapsed and elided to 72 characters, the `+N -M` edit stat when present, the `formatToolDuration` value (`340ms`/`1.2s`/`2m 3s`), and `Expand {name}`/`Collapse {name}`; a failed row is marked `Failed tool call`. An expanded row shows INPUT (pretty-printed JSON, or the raw partial string), the LCS edit diff (at most 200 rendered lines with the remaining `… {N} more changed line(s) not shown`), then ERROR (the server's `error.message`, else the output) or OUTPUT (`(no output)` when settled and empty, nothing while in flight). Lifecycle words `streaming`/`running` are in flight and `completed`/`error` settled; a settled call never spins or wears the ` · long` mark. Because the panel is a fixed overlay, opening or closing it never re-flows the transcript nor moves its scroll (C14). Captured 2026-10-19 against `ses_eae413f50ffeLQDExlg8cYnscN` (one folded turn, 80 reasoning steps, 122 tool calls): `captures/51-chat-reasoning-collapsed.png`, `captures/52-chat-reasoning-expanded.png`, `captures/53-chat-tool-chip.png`, `captures/54-chat-tool-panel.png` (an opened `read` row showing INPUT + OUTPUT) and `captures/55-chat-edit-diff-sample.png`. The live history carries no failed or edit-family call, so that capture renders a labelled page-rendered sample — a `shell` row marked `Failed tool call` with INPUT + ERROR and an `edit` row with a `+2 -1` diff — through the page's own row builder; the transcript stayed put across open/close (top 43065 → 43065). **Live arrival over `chat_event` is C5**: the renderer is built from the same part shapes (`ChatPart{type,name,state{status,input,content,error},time}`) and takes a `streaming` flag plus a live elapsed source so C5 can drive in-flight calls; the chip's in-flight spinner, the ` · long` 60s mark, the panel flip-above and an edit-family call are not reachable against the live server, so they are unit-tested (`test/chat.test.mjs`) rather than claimed as captured |
|
||||
| C7 | Markdown rendering + code blocks | — | done — captured 2026-10-19: `captures/45-chat-transcript-newest.png` (opened at the newest content: bold, bullet lists, a `|` table with its `---` delimiter row and inline code spans from the live assistant answer), `captures/47b-chat-markdown-code.png` (a rendered fenced code block — label `js`, the pre body `const answer = 42;` — drawn in the live browser by the page's own `renderMarkdown`, the same function that renders the answer) and `captures/47-chat-reasoning-code.png`. The subset is exactly `Markdown.kt`: paragraphs, `#`–`######` headings, fenced code (```/~~~, the language label else `code`), block quotes, bullet/ordered lists, `|` tables with a `---` delimiter row, thematic rules, inline code, bold, italic (underscore only at word boundaries, so `snake_case` stays plain), `[label](url)` links and bare http(s) autolinks; HTML entities are decoded first in one pass, and HTML, reference links, strikethrough and nested lists render as plain text and are never dropped. **Code-block caveat, stated plainly**: the live assistant answer carries **no** fenced block — its four fences live in the reasoning transcript, which the app draws as plain text, not as markdown (`captures/47-chat-reasoning-code.png` shows one such fence as muted plain text; that is C6 material, not the markdown path). So the rendered `<pre>` code block is captured from a labelled sample through the page's real renderer (`47b`), and the same path plus its `code`-else-language label is unit-tested in `test/markdown.test.mjs`. Only `http(s)` link targets become clickable — the transcript is untrusted model output, so a `javascript:`/`data:` target renders as its label, never as a live link |
|
||||
| C8 | Composer: send, stop, attachments, draft | `chat_prompt`, `chat_interrupt` | done — the composer at the foot of an open conversation: a growing 1–6-row `<textarea>` (placeholder `Message the agent… or / for commands`) where Enter submits and Shift+Enter inserts a newline (the submit routing is the pure `composerSubmit`), an `Attach file` control opening a multi-file picker, a removable chip per attachment (an image thumbnail else a file glyph, the display name, then the error text or `humanBytes(size)`, and a remove control named `Remove {name}`), and one primary control: Stop (`aria-label`/title `Stop`, error tint) while a turn runs, else Send (`aria-label` `Send`, disabled unless a non-blank draft with no failed attachment — or a slash draft). The 25 MiB guard reads `"{display}" is too large (25.0 MiB limit).` and an unreadable file `"{display}" could not be read.`; the web file picker cannot produce an unreadable file, so only the limit branch is captured and both are unit-tested (`test/chat.test.mjs`). Send trims the draft, clears the draft and the attachments at once, calls `chatPrompt` with `{session_id,text,operation_id,native_message_id}` (+ `files` only when present) and reads the reply's `chat_queued` into the notice `Queued — it will send when the current turn finishes.`; a rejected prompt restores the draft and the attachments (each flagged with the server's own message) and shows the shared `Action failed` dialog. The queued flag clears on any incoming frame (the client fans unsolicited envelopes out as a `frame` event; the composer folds it). The draft is kept per chat in memory **and** mirrored into `localStorage` (`pipelines.web.chatDraft.v1`) — the web analogue of per-device persistence — while attachments stay memory-only. Captured 2026-10-19 against a **freshly created** session (never the operator's own): `captures/56-chat-composer-draft.png`, `captures/60-chat-attachment-chips.png`, `captures/61-chat-attachment-removed.png`, `captures/63-chat-composer-stop.png` (a real prompt to the throwaway session turned Send into Stop), `captures/63b-chat-stop-interrupt.png` (the Stop control was **clicked**: it sent `chat_interrupt` and the page showed `Stopping the running turn…`, with no `Action failed` — the control is wired to `chat_interrupt`, never to the inert submit path) and `captures/64-chat-throwaway-closed.png` (after `/close`, the closed row plus the conversation pane left for the list). The throwaway session was created with `chat_create`, really prompted, really interrupted and closed with `chat_close`; the operator's session `ses_eae413f50ffeLQDExlg8cYnscN` was never prompted |
|
||||
| C9 | Slash commands | client-side | done — the palette appears above the composer only while the trimmed draft starts with `/` and has no whitespace, filtered case-insensitively by name prefix, each row showing `/name` and the summary and the highlighted row marked `aria-selected`; Up/Down move the highlight and Enter runs it, a tap runs a row directly, and running a command always consumes the draft and never reaches the prompt path. The five commands and their summaries are `CHAT_COMMANDS` (`/new`, `/close`, `/rename <title>`, `/stop`, `/help`), unit-tested verbatim, with `chatCommandHelp()` the `usage — summary` lines. Effects: `/new` sends `chat_create` directly (one step, separate from C2's picker) and opens the created session, `/close` reuses the C3 `Close chat?` confirm, `/rename` is the local rename pending C13, `/stop` interrupts (`chat_interrupt`) and `/help` shows the command list. Error wording is the Android source verbatim: the unknown command reads `“{token}” is not a command, so nothing was sent to the agent. Send it as a message, or cancel.` with the draft offered back and `Send as message` / `Cancel`; an extra argument on an argument-less command reads `{usage} does not take an argument.`; `/rename` with no title reads `Usage: /rename <title> — renames this session on this device.`; `/stop` with nothing running reads `No turn is running in this chat.`. A notice renders as a full-width line after the turns (not a bubble) with the label `Command` / `Command failed` and a terminal glyph, error-coloured when failed. Captured 2026-10-19: `captures/57-chat-command-palette.png`, `captures/58-chat-command-palette-selected.png` (ArrowDown moved the highlight), `captures/59-chat-command-unknown.png` (the failed notice and its offer, dismissed with Cancel), `captures/62-chat-new-session.png` (`/new`'s created session and its `Command` notice) |
|
||||
| C9 | Slash commands | client-side | done — the palette appears above the composer only while the trimmed draft starts with `/` and has no whitespace, filtered case-insensitively by name prefix, each row showing `/name` and the summary and the highlighted row marked `aria-selected`; Up/Down move the highlight and Enter runs it, a tap runs a row directly, and running a command always consumes the draft and never reaches the prompt path. The five commands and their summaries are `CHAT_COMMANDS` (`/new`, `/close`, `/rename <title>`, `/stop`, `/help`), unit-tested verbatim, with `chatCommandHelp()` the `usage — summary` lines. Effects: `/new` sends `chat_create` directly (one step, separate from C2's picker) and opens the created session, `/close` reuses the C3 `Close chat?` confirm, `/rename` writes through C13's durable device-local store (the same one the row's `Rename…` dialog uses), `/stop` interrupts (`chat_interrupt`) and `/help` shows the command list. Error wording is the Android source verbatim: the unknown command reads `“{token}” is not a command, so nothing was sent to the agent. Send it as a message, or cancel.` with the draft offered back and `Send as message` / `Cancel`; an extra argument on an argument-less command reads `{usage} does not take an argument.`; `/rename` with no title reads `Usage: /rename <title> — renames this session on this device.`; `/stop` with nothing running reads `No turn is running in this chat.`. A notice renders as a full-width line after the turns (not a bubble) with the label `Command` / `Command failed` and a terminal glyph, error-coloured when failed. Captured 2026-10-19: `captures/57-chat-command-palette.png`, `captures/58-chat-command-palette-selected.png` (ArrowDown moved the highlight), `captures/59-chat-command-unknown.png` (the failed notice and its offer, dismissed with Cancel), `captures/62-chat-new-session.png` (`/new`'s created session and its `Command` notice) |
|
||||
| C10 | Permission/approval cards (allow once/always/reject) | `chat_permission`, `chat_reply` | done — captured 2026-10-19: `captures/65-chat-approval-pending.png` (the pending card as the transcript's last item: the amber outlined shield + `Approve bash`, `Waiting for your response`, the request's six monospace resource lines, the amber `RISK REVIEW` panel, the `Allow once` / `Always allow` / `Reject` controls, and the top bar's `Waiting for your approval` control, with `#chatRunning` stood down), `captures/66-chat-approval-answered.png` (`Allowed once` / `Waiting for the agent to continue…`, controls and top-bar control gone), `captures/67-chat-approval-resolved.png` (a server resolution: `Always allowed` with its note `Another client already allowed this.`, no controls, no risk panel) and `captures/68-chat-approval-rejected.png` (a blank-action request answered `Reject`: `Rejected` / `Waiting for the agent to continue…`, the risk panel kept with the fallback sentence, no controls). The pure model is `src/chat.js` (`approvalCard`/`applyChatPermission`/`permissionRiskText`/`decisionLabel`): while pending `Approve {action}` (blank action → `Approve tool call`), after answering the decision label (`Allowed once` / `Always allowed` / `Rejected`, an unknown decision → `Resolved`) and `Waiting for the agent to continue…`, and once the server reports `resolved`/a decision that label (else `Already resolved`) with its `message` as the status (else `Another client already answered this request.`); the amber `RISK REVIEW` box shows only while pending or after a reject. Resources drop blanks and cap at six visible lines: `approvalResourceText` caps the joined text at six lines with an ellipsis on the last kept line, and the rendered text is a padding-free `-webkit-line-clamp: 6` block inside a padded frame, so a long resource that wraps is elided at the content edge and no seventh line paints into the frame's padding — matching Android's `maxLines = 6, Ellipsis` (the smoke asserts six clipped lines, a hidden overflow and the block ending at the frame's content edge, with seven lines unclamped). `Allow once` is rendered as the browser's filled primary control, matching the app's filled `Button` versus its two `TextButton`s; the head and risk-panel shields are inline SVG stroked with `currentColor` so the warn hue actually tints them (a colour emoji cannot be tinted). A server resolution always outranks a local answer, a new request replaces the settled card and clears the answer, and the same request keeps it. `PipelinesRepository.chatReply` sends exactly `{type:'chat_reply',chat_reply:{session_id,request_id,decision,client}}` (`message` only when non-blank) and refuses blank ids or a decision outside once/always/reject; answering settles the card optimistically, and a refused send reopens the same request and reports the server's reason on the thread's error line (ignored if a different request has replaced the card), so an unaccepted decision is never shown as accepted. The card is fed by `chat_permission` frames through `client.js`'s unsolicited-frame path, folded only for sessions this client has open. **Replayed, not real**: no live pending approval was available, so the captures were driven by synthetic `chat_permission` frames replayed through the page's own socket handler against the live session; the page's real `chat_reply` path was exercised but the smoke's shim suppressed every reply for the synthetic request ids (suppressed 3, one of them answered with a server error to prove the reopen path, forwarded 0), so **no approval decision was sent to the operator's server**. Unit-tested in `test/chat.test.mjs` and the reply shape in `test/repository.test.mjs`; the DOM assertions and log lines are produced by `test/ui-smoke.mjs` |
|
||||
| C11 | Background tasks bar: running shells only, capped + scrollable, bounded output page | `chat_shells`, `chat_shell_output` | done — captured 2026-10-19 into a live session: `captures/65-chat-background-tasks.png` (the bar with five running tasks — heading `Background tasks`, count `5 running`, three visible rows and a scrolling list), `captures/66-chat-background-task-detail.png` (a selected task's detail: `Command` + the command, `Task identity` + the id in monospace, `Status: running`, then `Output` + the monospace text and `Refresh`), `captures/67-chat-background-task-empty.png` (`No output yet.`), `captures/68-chat-background-task-unavailable.png` (`Output unavailable for this task.`), `captures/69-chat-background-task-truncated.png` (`Output is bounded to 64 KiB.` plus `Refresh`), `captures/70-chat-background-task-loading.png` (the spinner while the page loads) and `captures/71-chat-background-tasks-exited.png` (the bar gone after the last exit). The bar is shown only while at least one shell is running and disappears with the last exit; only running shells are listed (an exited shell is never a task). Its visible rows are capped at 3 (`BACKGROUND_TASK_VISIBLE_ROWS`) and the list scrolls beyond that instead of growing; each row is a play glyph + `Running` + `shellCommandSummary(command)` (trimmed, whitespace-collapsed, elided past 72; blank → `background process`) + `Details` only while selected, and tapping a row toggles its detail pane. Refresh always rereads the page from cursor 0 with `limit` 65536 (`SHELL_OUTPUT_LIMIT`, the server's 64 KiB bound) and never appends, so the client's output cannot grow unbounded — the smoke's own Refresh click issues exactly such a second read and the smoke asserts its `{cursor:0,limit:65536}` bounds. `chat_shells` is fetched when the conversation opens (`chat_query` body `{session_id}`) and again on every stream reconnect, and `chat_shell_output` sends `chat_shell_output_query` (`{session_id,shell_id,cursor,limit}`); both the request shapes and the pure model (`runningBackgroundShells`, `shellCommandSummary`, `mergeShellFrame`, `shellsLoaded`, `shellOutputState`, every wording constant) are unit-tested (`test/chat.test.mjs`, `test/repository.test.mjs`). A `shell` frame folds its shell into the retained set, merges a blank command from the previous frame, and never marks the thread running — a background process outlives the turn (a step ending does not clear it; only the reconnect drops and re-learns it). Every server string is set with `textContent`; shell output is never parsed as markup. **Replayed vs real, stated plainly**: only the `shell` frames (injected synthetic `chat_event` frames) and the `chat_shell_output` pages (answered by a socket reply hook) are synthetic, because the live server had no running shell to read safely; the `chat_shells` list, the `chat_subscribe` ack and every `chat_history` reply came from the real server, and the smoke asserts the real `chat_shells` fetch on open and after a reconnect. The one drop that hit a bounded read mid-section was recovered by the smoke's own bounded retry through the page's controls |
|
||||
| C12 | Human-decision notices inside chat + dismiss | `chat_event` | done — the local command-notice surface is captured and dismissible per notice. Captured 2026-10-19: `captures/72-chat-command-notice.png` (a full-width `Command` line after the turns, never a message bubble: the shared terminal glyph `>_`, the `/help` command list and its own `Dismiss`), `captures/73-chat-command-failed-offer.png` (an unknown command: `Command failed` in the error tint, the exact Android sentence and the `Send as message` / `Cancel` pair) and `captures/74-chat-command-dismissed.png` (the `/help` notice dismissed; the failed offer line and its controls remain — exactly one notice removed). A notice is a local `ChatCommandNotice`, never a `ChatMessage`: it lives in that conversation's `state.chatThreads` entry, survives switching away and back while the page is open, and never enters the prompt path — the smoke's recorded sends show **no** `chat_prompt` for `/help` or an unknown command. `Send as message` takes the offered draft through the ordinary `postChatPrompt` path, removing the notice **before** sending, so a stale second tap sends nothing (the smoke verifies both on a throwaway session). The pure model lives in `src/chat.js` (`makeChatNotice`, `appendChatNotice`, `dismissChatNotice`, `takeChatNoticeOffer`, `chatNoticeLabel`) and is unit-tested (`test/chat.test.mjs`): append, dismiss one, take the offer, a stale/offerless offer returning null and leaving the list untouched, per-conversation scoping, and the failed label/tint flag. **Wire finding, not an invented source**: `chat_event` kinds are exactly `user`, `text`, `reasoning`, `tool`, `shell`, `step` and `usage` (`internal/protocol/chat.go` `ChatEvent*`), and `chat_permission` is the only approval frame — there is **no** in-chat run-decision notice on the wire. Run-level human decisions live on R11's run-detail decision sheet (`decide_run`) and C10's approval cards (`chat_permission` / `chat_reply`), exactly as the app does it. **Stated browser divergence**: Android's `ChatCommandNoticeItem` shows actions only when `offer != null`, so it cannot dismiss a `/help` or `/new` line; the browser adds a `Dismiss` control (accessible name `Dismiss command notice`) on offerless notices to meet "each is individually dismissible", keeping the app's `Send as message` / `Cancel` pair verbatim on offer notices. |
|
||||
| C13 | Local rename/hide, seen state, persistence to `localStorage` | client-side | todo |
|
||||
| C13 | Local rename/hide, seen state, persistence to `localStorage` | client-side | done — the row's `.chat-menu-button` (`Chat actions`) opens, in Android's order, `Rename…`, `Close chat…` (open rows) or `Reopen` (closed rows) and `Hide on this device`; the list is unclipped only while the menu is open (`.chat-list.menu-open`, mirroring `.list.runs`) so the panel is never cut off at the list's bottom edge, and the smoke hit-tests the last row's `Hide on this device` at its own centre. **Rename (device-local)**: the dialog is titled `Rename chat`, has a field labelled `Name` pre-filled with the current effective title, the helper `The server has no rename for a chat, so this name is kept on this device.`, and `Save` (disabled while the trimmed value is blank) / `Cancel`; backdrop and Escape close it, typing toggles Save in place without re-rendering the transcript, and saving sends nothing. A local title is trimmed and wins over the server's on every later list refresh. **Hide (device-local, distinct from the server close)**: the row disappears here, the open conversation closes (its thread dropped, `chatActiveId` cleared, its subscription forgotten) and one snackbar reads `Hidden on this device; the chat stays on the server.` with `Undo`; a newer hide replaces the in-flight report rather than queueing, and `Undo` restores the row and clears the hidden list — nothing on the server is touched. **Seen markers**: the row's dot+word badge is `Streaming` / `New` / `Open`, precedence exactly Streaming > New > Open, with `Open` only while that conversation is open (never colour alone; word is always rendered). A session is new only when it is not the active one and either it is in the explicit unseen set (a pushed `chat_event` for a backgrounded chat) or it has never been opened here and its `updated_at` is strictly greater than the stored watermark; the first sight of a session is seeded as a baseline only when its watermark is 0 and `updated_at > 0`, so pre-existing chats are never all "new", and opening a conversation advances the watermark (monotonically — a stale read cannot rewind) and clears its mark. **Persistence** is the web analogue of the app's SharedPreferences, one JSON value per key, both decoding blank/corrupt/wrong-typed input to their empty model: `pipelines.web.chatOverrides.v1` = `{"titles":{"<id>":"<title>"},"hidden":["<id>"]}` and `pipelines.web.chatSeen.v1` = `{"seenAt":{"<id>":<updated_at ms>},"unseen":["<id>"]}` (Android field names `titles`/`hidden` and `seenAt`/`unseen`). The pure model lives in `src/chat.js` (`renameChatOverride`/`hideChatOverride`/`restoreChatOverride`/`applyChatOverrides`, `chatSeenWatermark`/`seedChatSeen`/`readChatSeen`/`markChatUnseen`/`isChatSessionUnseen`, the tolerant `decode`/`encode`) and is unit-tested in `test/chat.test.mjs`. C9's `/rename <title>` now writes through the same durable store. Captured 2026-10-19, all live (no synthesised frames): `captures/72-chat-rename-dialog.png` (the dialog, blank field, Save disabled), `captures/73-chat-renamed-row.png` (a closed row showing its local title `Local capture chat` after a server list refresh), `captures/74-chat-hide-snackbar.png` (the hidden open conversation closed, one snackbar with `Undo`) and `captures/75-chat-new-marker.png` (the non-active prompt-and-stopped throwaway, reloaded and reconnected, carrying the coloured dot + `New`). The New marker is **not** synthesised: the smoke `/new`s a throwaway, sends a real prompt, clicks `Stop`, reloads the page and reconnects, then asserts the row's `.chat-activity-new` word `New` while the persisted watermark predates the turn |
|
||||
| C14 | Scroll behaviour: follow newest, "jump to newest", restored position | client-side | done — captured 2026-10-19: `captures/45-chat-transcript-newest.png` (the conversation opens at its newest content instantly — the only live session has no saved position, so it lands at the end rather than at the top of a turn taller than the viewport) and `captures/46-chat-transcript-top.png` (after a **real wheel gesture** on the transcript — the app's own listener, not a programmatic scroll, which by the implementation's own rule cannot change intent — `Jump to latest` is offered; the smoke asserts the control and performs the gesture, `ui-smoke` log line "after a real wheel gesture (scrollTop 0) 'Jump to latest' is offered at the top"). A thread with a saved position is restored to it (a saved top, index 0, is a real position and is never treated as "new"); while within the 32 px bottom threshold the view follows, and only the operator's own wheel/drag changes that intent (a programmatic placement or follow cannot); `Jump to latest` is offered only when not following and something is below the fold; the position is saved per session in `localStorage` (`pipelines.web.chatScroll.v1`). A re-render (opening/dismissing a dialog, a refresh, or the loading frame of a paging fetch) captures the live position first and puts the operator back exactly where they were — the smoke asserts the transcript stays put across the `Close chat?` dialog (`ui-smoke` log line "the transcript stayed put across the dialog (top 7141 -> 7141)"); the paging anchor is held until the frame that actually carries the older page, so a real prepend stays on the previously visible message. No auto-load on scroll. The pure decisions are unit-tested (`chatBottomDistancePx`, `chatFollowsAt`, `chatShowJumpToLatest`, `chatOpensAtNewest`, `chatFirstScroll`) in `test/chat.test.mjs`, and the live measurement uses `chatBottomDistancePx` itself |
|
||||
|
||||
Three decisions in Chat, recorded here as the browser client's own choices where
|
||||
@@ -123,9 +123,12 @@ today, so the browser collects, validates and blocks on a failed attachment and
|
||||
then sends it best-effort as the file's own reference string, but the file is not
|
||||
yet forwarded to OpenCode. **`/new` sends `chat_create` directly** as a one-step
|
||||
create in the current directory (C2's pane is the directory chooser); it creates
|
||||
a session titled `New chat` and opens it. **`/rename` is a local, per-device rename** until
|
||||
C13 lands (the browser item mirrors C13's dependency rather than inventing a
|
||||
server rename). And the **draft is held per chat in memory and mirrored into
|
||||
a session titled `New chat` and opens it. **`/rename` writes through C13's durable,
|
||||
per-device store** (the browser item mirrors C13's dependency rather than
|
||||
inventing a server rename), so a `/rename`d chat keeps its local title across a
|
||||
refresh and shows the same `Renamed this session to “{title}” on this device
|
||||
only; the server's title is unchanged.` notice. And the **draft is held per chat
|
||||
in memory and mirrored into
|
||||
`localStorage`** (`pipelines.web.chatDraft.v1`), the web analogue of per-device
|
||||
persistence, while attachments are memory-only because a `File` handle cannot be
|
||||
serialised. The composer's Stop control appears the moment a prompt is accepted
|
||||
@@ -150,7 +153,7 @@ to it, but the server never lists it and a reload drops it.
|
||||
| L2 | Wide layout: left rail + two panes | client-side | todo |
|
||||
| L3 | Narrow layout: bottom section strip + bottom navigation | client-side | todo |
|
||||
| L4 | Responsive switch by viewport width (no hardcoded device) | `WindowSize.kt` analogue | todo |
|
||||
| L5 | Notifications for failed/waiting runs (browser Notification API; HTTPS/localhost only) | derived | todo |
|
||||
| L5 | Notifications for failed/waiting runs (browser Notification API; HTTPS/localhost only) | derived from `subscribe` / `run_event` | **partial** — the browser notification path is implemented and captured in Settings, but **no real OS notification was observed**, so the row is not `done`. The exact reason: headless Chrome cannot reliably show or capture an OS notification; the smoke stubs and records the `Notification` constructor, while the transition decisions run through the page's real socket `onmessage`/`frame` path. Pure logic lives in `src/notify.js` and mirrors `notify/RunAlerts.kt` + `ui/Attention.kt`: only a run becoming `failed` (headline `A run failed`) or `waiting` (headline `A run needs your decision`) notifies; `queued`, `running`, `succeeded`, `canceled`, `interrupted` and unknown statuses never do. Body is the attention label (trimmed title else pipeline) then ` · {pipeline}`, with no separator when the pipeline is blank or equal; identity/tag is the attention key `{runId}:{kind}` so one run+kind notifies once, duplicate frames repeat nothing, a key is forgotten when the run leaves that qualifying state, and a genuinely new transition may notify again. First-seen `failed`/`waiting` from the initial `list_runs` or the `subscribe` snapshot raises nothing (the snapshot is bracketed as a seed); a disconnect drops the baseline but keeps the page session's dedupe set and reseeds before resubscribing, so a gap never notifies. A key present in the attention surface's `dismissed` set (`state.attentionDismissed`) is suppressed. Settings now shows the Android rationale verbatim (`Pipelines can notify you when a run is waiting for your decision or has failed. Without it, those runs still appear in the in-app Needs you surface.`) and honest copy for unsupported, insecure context, default, granted and denied; only `default` on a supported secure page offers the explicit `Enable notifications` control, which is the only call to `Notification.requestPermission()` (never on load). Only `{asked:true|false}` is stored under `pipelines.web.notify.v1`; malformed storage decodes to never-asked and the wording never claims consent. Clicking a notification focuses the page and opens Runs with the run selected through the **existing** navigation; **L6's `/runs/:id` URL route is still `todo`**, so no URL route is invented. `subscribeRuns`/`unsubscribeRuns` send exactly `{type:'subscribe',workspace:''}` and `{type:'unsubscribe'}` (no `run_ids`, no polling timer) and are sent only after the page is connected. Unit-tested in `test/notify.test.mjs` (qualification, wording/body, per-run dedupe, seed/snapshot suppression, dismissed keys, permission copy, asked storage) and `test/repository.test.mjs` (both request shapes + the not-connected guard). Captured 2026-10-19: `captures/L5-notifications-settings.png` (default state, control offered, 0 requests on load), `captures/L5-notifications-granted.png` (after the one explicit grant) and `captures/L5-notifications-denied.png` (honest denied copy, no control). The same checks live in `test/ui-smoke.mjs` behind `--notify` (a focused mode that runs exactly this evidence); that run finished `UI SMOKE PASS` and logged: queued→failed and running→waiting each raised exactly one recorded notification, duplicates/terminal/unknown statuses/first-seen/dismissed raised none, and the click opened the run. **Not observed:** the OS notification itself. On 2026-10-19 the default full live suite reached and passed this block with the same logged assertions, then failed later in an unrelated C13 hit-test (`the last row's menu item is not clickable`, its centre at y=919.5 in a 900 px viewport after the list's re-render reset the scroll); the L5 captures and assertions above come from the focused `--notify` run, which finished `UI SMOKE PASS`. |
|
||||
| L6 | Deep links to a run (`pipelines://run/…` analogue → URL route) | — | todo |
|
||||
| L7 | Accessibility: focus order, labels, keyboard operation | — | todo |
|
||||
|
||||
|
||||
+629
-47
@@ -174,6 +174,15 @@ import {
|
||||
decodeAttentionDismissals,
|
||||
encodeAttentionDismissals,
|
||||
} from "./attention.js";
|
||||
import {
|
||||
NOTIFICATION_RATIONALE,
|
||||
NOTIFY_STORAGE_KEY,
|
||||
createAlertLedger,
|
||||
decodeNotificationSettings,
|
||||
encodeNotificationSettings,
|
||||
notificationEnvironment,
|
||||
notificationPermissionState,
|
||||
} from "./notify.js";
|
||||
import {
|
||||
DEFAULT_SEARCH_KIND,
|
||||
DEFAULT_SEARCH_SORT,
|
||||
@@ -228,6 +237,7 @@ import {
|
||||
} from "./actions.js";
|
||||
import {
|
||||
BACKGROUND_TASKS_TITLE,
|
||||
CHAT_ACTIONS_LABEL,
|
||||
CHAT_ATTACH_LABEL,
|
||||
CHAT_COMMAND_DISMISS_LABEL,
|
||||
CHAT_COMMAND_GLYPH,
|
||||
@@ -241,14 +251,23 @@ import {
|
||||
CHAT_CREATE_TITLE,
|
||||
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,
|
||||
@@ -279,6 +298,7 @@ import {
|
||||
SHELL_OUTPUT_UNAVAILABLE,
|
||||
SHELL_ROW_LABEL,
|
||||
applyChatEvent,
|
||||
applyChatOverrides,
|
||||
applyChatPermission,
|
||||
appendChatNotice,
|
||||
approvalCard,
|
||||
@@ -292,7 +312,6 @@ import {
|
||||
chatCommandSuggestions,
|
||||
chatCreateFailed,
|
||||
chatCreateSucceeded,
|
||||
chatStartInLabel,
|
||||
chatFirstScroll,
|
||||
chatFollowsAt,
|
||||
chatHeaderMeta,
|
||||
@@ -300,31 +319,45 @@ import {
|
||||
chatNoticeLabel,
|
||||
chatOpensAtNewest,
|
||||
chatShowJumpToLatest,
|
||||
chatStartInLabel,
|
||||
chatStreamState,
|
||||
closeChatConfirmation,
|
||||
composerAction,
|
||||
composerCanSend,
|
||||
composerSendEnabled,
|
||||
composerSubmit,
|
||||
decodeChatOverrides,
|
||||
decodeChatSeen,
|
||||
defaultDirectoryChoice,
|
||||
directoryChoices,
|
||||
directoryLabel,
|
||||
dismissChatNotice as dismissChatNoticeModel,
|
||||
emptyChatOverrides,
|
||||
emptyChatSeen,
|
||||
encodeChatOverrides,
|
||||
encodeChatSeen,
|
||||
filterSessions,
|
||||
groupSessionsByDirectory,
|
||||
hideChatOverride,
|
||||
historyResync,
|
||||
isChatSessionUnseen,
|
||||
makeChatNotice,
|
||||
markChatUnseen,
|
||||
mergeHistoryPage,
|
||||
mergeShellFrame,
|
||||
newChatCreateState,
|
||||
newChatThread,
|
||||
parseChatInput,
|
||||
queuedAfterFrame,
|
||||
readChatSeen,
|
||||
reasoningLabel,
|
||||
renameChatOverride,
|
||||
restoreChatOverride,
|
||||
resumedThread,
|
||||
runningAfterFrame,
|
||||
runningBackgroundShells,
|
||||
runningToolElapsedMillis,
|
||||
seedChatSeen,
|
||||
sessionActivity,
|
||||
sessionActivityBadge,
|
||||
sessionChipLabel,
|
||||
@@ -377,6 +410,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.";
|
||||
@@ -483,6 +532,10 @@ const state = {
|
||||
attentionDismissed: new Set(),
|
||||
attentionSheetOpen: false,
|
||||
attentionSnapshot: null,
|
||||
// Notifications (L5): whether the operator has already been asked, loaded once
|
||||
// at boot from localStorage. The browser owns the permission itself; this flag
|
||||
// only changes the honest wording in Settings and is never a claim of consent.
|
||||
notifyAsked: false,
|
||||
// Omni-search (S1/S2): the field/panel state, kept beside the view it never
|
||||
// changes, plus the pure debounce/stale-token sequencer. Opening or closing the
|
||||
// search leaves state.view, the selection and the loaded data untouched.
|
||||
@@ -551,6 +604,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
|
||||
@@ -567,6 +632,11 @@ const state = {
|
||||
chatCreate: null,
|
||||
};
|
||||
|
||||
// The run-notification ledger (L5). It is seeded from the authoritative run list
|
||||
// and from the subscribe snapshot, then observes pushed `run_event` frames; it
|
||||
// never feeds the runs list (that is R10's separate fold).
|
||||
const runAlerts = createAlertLedger();
|
||||
|
||||
let runPoll = null;
|
||||
|
||||
// One shared live clock for the runs list: it ticks only while a shown run is
|
||||
@@ -1033,6 +1103,76 @@ function loadAttentionDismissed() {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Fold one pushed `run_event` frame into the notification ledger (L5). It does
|
||||
* not touch the runs list (R10's fold is separate); it only decides whether this
|
||||
* transition raises exactly one notification. A run already failed/waiting when
|
||||
* seeded, a duplicate frame, a non-qualifying status and a key the operator
|
||||
* dismissed all produce nothing.
|
||||
*/
|
||||
function onRunAlertFrame(frame) {
|
||||
const alert = runAlerts.observe(frame, { dismissed: state.attentionDismissed });
|
||||
if (!alert || !notificationsAllowed()) return;
|
||||
try {
|
||||
const notification = new Notification(alert.title, { body: alert.body, tag: alert.key });
|
||||
notification.onclick = () => {
|
||||
window.focus();
|
||||
state.view = "runs";
|
||||
render();
|
||||
selectRun(alert.runId);
|
||||
};
|
||||
} catch {
|
||||
// Some browsers can throw even with permission granted; the in-page Needs
|
||||
// you surface remains the only honest channel and nothing is faked.
|
||||
}
|
||||
}
|
||||
|
||||
/** True only when a real browser notification can be constructed right now. */
|
||||
function notificationsAllowed() {
|
||||
return (
|
||||
typeof globalThis.Notification === "function" &&
|
||||
globalThis.isSecureContext === true &&
|
||||
globalThis.Notification.permission === "granted"
|
||||
);
|
||||
}
|
||||
|
||||
/** Persist only the asked flag; never a permission claim, endpoint or credential. */
|
||||
function persistNotifyAsked(asked) {
|
||||
state.notifyAsked = Boolean(asked);
|
||||
try {
|
||||
localStorage.setItem(NOTIFY_STORAGE_KEY, encodeNotificationSettings({ asked }));
|
||||
} catch {
|
||||
// Storage disabled or full: the in-memory flag still applies for this session.
|
||||
}
|
||||
}
|
||||
|
||||
/** The asked flag from storage at boot; anything unreadable means never asked. */
|
||||
function loadNotifyAsked() {
|
||||
try {
|
||||
return decodeNotificationSettings(localStorage.getItem(NOTIFY_STORAGE_KEY)).asked;
|
||||
} catch {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Start the run-event watch for this connected epoch: seed from the list that is
|
||||
* already in hand, treat the subscribe snapshot as seeds too (the server writes
|
||||
* it before the ack), then observe deltas. A refused subscribe only means no
|
||||
* pushes; the page keeps working and Settings stays honest.
|
||||
*/
|
||||
async function startRunAlertWatch() {
|
||||
runAlerts.seed(state.runs);
|
||||
runAlerts.beginSeed();
|
||||
try {
|
||||
await repo.subscribeRuns();
|
||||
} catch {
|
||||
// No live watch: notifications simply cannot raise on this connection.
|
||||
} finally {
|
||||
runAlerts.endSeed();
|
||||
}
|
||||
}
|
||||
|
||||
function render() {
|
||||
renderHeader();
|
||||
renderBanner();
|
||||
@@ -1140,7 +1280,12 @@ function tabButton(view, label) {
|
||||
*/
|
||||
function renderSettingsView() {
|
||||
const pane = h("div", { class: "settings" });
|
||||
pane.append(renderSettingsConnection(), renderSettingsWorkspace(), renderSettingsTemplates());
|
||||
pane.append(
|
||||
renderSettingsConnection(),
|
||||
renderSettingsWorkspace(),
|
||||
renderSettingsNotifications(),
|
||||
renderSettingsTemplates(),
|
||||
);
|
||||
return pane;
|
||||
}
|
||||
|
||||
@@ -1229,6 +1374,75 @@ function renderSettingsConnection() {
|
||||
return section;
|
||||
}
|
||||
|
||||
/**
|
||||
* The Notifications section (L5). The Android rationale is shown verbatim; the
|
||||
* status line is the pure permission view for this page's real browser facts.
|
||||
* Only the explicit control asks for permission, never page load. When the API
|
||||
* is unavailable, the page is insecure or permission is denied, the wording says
|
||||
* plainly that the in-app Needs you surface is the only channel — no fake
|
||||
* notification is ever drawn.
|
||||
*/
|
||||
function renderSettingsNotifications() {
|
||||
const view = notificationPermissionState({
|
||||
...notificationEnvironment(),
|
||||
asked: state.notifyAsked,
|
||||
});
|
||||
const section = h("section", { class: "settings-section", id: "settingsNotifications" });
|
||||
section.append(h("h2", { class: "settings-title", text: "Notifications" }));
|
||||
section.append(h("p", { class: "settings-helper", text: NOTIFICATION_RATIONALE }));
|
||||
section.append(
|
||||
h("p", {
|
||||
id: "settingsNotificationState",
|
||||
class: `settings-notify-state settings-notify-${view.state}`,
|
||||
role: "status",
|
||||
text: view.body,
|
||||
}),
|
||||
);
|
||||
if (view.canRequest) {
|
||||
section.append(
|
||||
h(
|
||||
"div",
|
||||
{ class: "settings-actions" },
|
||||
h("button", {
|
||||
id: "settingsEnableNotifications",
|
||||
class: "primary",
|
||||
type: "button",
|
||||
text: view.actionLabel,
|
||||
onclick: requestNotifications,
|
||||
}),
|
||||
),
|
||||
);
|
||||
}
|
||||
return section;
|
||||
}
|
||||
|
||||
/**
|
||||
* Ask for notification permission from the operator's explicit click. The asked
|
||||
* flag is persisted first and the page re-renders from the browser's real answer;
|
||||
* a refused/dismissed prompt leaves the honest default/denied wording in place.
|
||||
*/
|
||||
function requestNotifications() {
|
||||
persistNotifyAsked(true);
|
||||
const ctor = globalThis.Notification;
|
||||
if (typeof ctor !== "function" || !globalThis.isSecureContext) {
|
||||
renderContent();
|
||||
return;
|
||||
}
|
||||
try {
|
||||
const result = ctor.requestPermission();
|
||||
if (result && typeof result.then === "function") {
|
||||
result.then(
|
||||
() => renderContent(),
|
||||
() => renderContent(),
|
||||
);
|
||||
return;
|
||||
}
|
||||
} catch {
|
||||
// A browser that refuses the request keeps the honest fallback wording.
|
||||
}
|
||||
renderContent();
|
||||
}
|
||||
|
||||
/** The trusted-network warning card, SettingsScreen.kt's TrustWarning verbatim. */
|
||||
function renderTrustWarning() {
|
||||
return h(
|
||||
@@ -3947,6 +4161,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
|
||||
@@ -4022,6 +4277,10 @@ async function loadChatSessions(force = false) {
|
||||
);
|
||||
state.chatSessions = [...held, ...listed];
|
||||
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);
|
||||
}
|
||||
@@ -4115,11 +4374,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),
|
||||
@@ -4199,11 +4463,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
|
||||
@@ -4415,6 +4691,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();
|
||||
}
|
||||
@@ -4462,6 +4739,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);
|
||||
@@ -4480,6 +4758,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)
|
||||
// ---------------------------------------------------------------------------
|
||||
@@ -4666,8 +5074,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) {
|
||||
@@ -4732,16 +5141,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. */
|
||||
@@ -4875,7 +5283,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", {
|
||||
@@ -4923,7 +5333,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(
|
||||
@@ -4986,7 +5397,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" : ""}`,
|
||||
@@ -4995,8 +5413,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();
|
||||
@@ -5024,35 +5442,7 @@ 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;
|
||||
}
|
||||
|
||||
@@ -5169,6 +5559,78 @@ function renderChatCreate() {
|
||||
return pane;
|
||||
}
|
||||
|
||||
/**
|
||||
* 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" });
|
||||
@@ -5178,8 +5640,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).
|
||||
@@ -5291,9 +5754,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,
|
||||
@@ -6883,6 +7426,9 @@ async function onConnected() {
|
||||
// local, so that path is a single render and nothing is fetched twice).
|
||||
renderBanner();
|
||||
await loadCurrentView();
|
||||
// Seed from the authoritative list first, then watch: the subscribe snapshot
|
||||
// and its ack are treated as seeds, so a reconnect gap never notifies.
|
||||
await startRunAlertWatch();
|
||||
}
|
||||
|
||||
async function loadCurrentView(force = false) {
|
||||
@@ -6917,11 +7463,13 @@ async function loadCurrentView(force = false) {
|
||||
// history from one that has not arrived yet.
|
||||
const { runs, usage } = await repo.listRuns();
|
||||
state.runs = runs;
|
||||
runAlerts.seed(runs);
|
||||
if (usage) state.usage = usage;
|
||||
state.runsLoaded = true;
|
||||
} else {
|
||||
const { runs, usage } = await repo.listRuns();
|
||||
state.runs = runs;
|
||||
runAlerts.seed(runs);
|
||||
state.usage = usage;
|
||||
state.runsLoaded = true;
|
||||
}
|
||||
@@ -7165,6 +7713,10 @@ client.addEventListener("state", (event) => {
|
||||
// gone, so no thread keeps claiming to run until a fresh frame proves it.
|
||||
clearChatSubscriptions();
|
||||
settleChatThreads();
|
||||
// Drop the run-status baseline but keep this page session's notified keys:
|
||||
// the reconnect reseeds from the fresh list before it resubscribes, so a
|
||||
// transition hidden by the gap can never notify late.
|
||||
runAlerts.reset();
|
||||
}
|
||||
// A reconnect (not a first connect): re-attach the open chat's stream and
|
||||
// refresh its history wholesale, so a gap that swallowed the end of a turn is
|
||||
@@ -7183,6 +7735,13 @@ client.addEventListener("state", (event) => {
|
||||
client.addEventListener("frame", (event) => {
|
||||
const message = event.detail;
|
||||
if (!message) return;
|
||||
if (message.type === Protocol.RUN_EVENT) {
|
||||
// L5 only: observe the pushed transition for notifications. R10's runs-list
|
||||
// fold is deliberately not implemented here.
|
||||
const runFrame = message[Protocol.RUN_EVENT];
|
||||
if (runFrame) onRunAlertFrame(runFrame);
|
||||
return;
|
||||
}
|
||||
if (message.type === Protocol.CHAT_PERMISSION) {
|
||||
const permission = message[ChatKeys.PERMISSION];
|
||||
if (permission) onChatPermission(permission);
|
||||
@@ -7218,6 +7777,11 @@ document.addEventListener("keydown", (event) => {
|
||||
dismissActionError();
|
||||
return;
|
||||
}
|
||||
if (state.chatRename) {
|
||||
event.preventDefault();
|
||||
dismissChatRename();
|
||||
return;
|
||||
}
|
||||
if (state.chatClose) {
|
||||
event.preventDefault();
|
||||
dismissChatClose();
|
||||
@@ -7238,12 +7802,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.
|
||||
@@ -7256,4 +7837,5 @@ window.addEventListener("online", onForegroundActive);
|
||||
// The attention surface's dismissed identities are loaded once here, before the
|
||||
// first render, so the bell's badge is correct from the very first paint.
|
||||
state.attentionDismissed = loadAttentionDismissed();
|
||||
state.notifyAsked = loadNotifyAsked();
|
||||
render();
|
||||
|
||||
+262
@@ -37,6 +37,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
|
||||
@@ -584,6 +588,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)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
@@ -0,0 +1,315 @@
|
||||
// Pure, DOM-free notification model for failed/waiting runs (L5). It mirrors
|
||||
// android/.../notify/RunAlerts.kt: the same two qualifying kinds, the same
|
||||
// headlines, the same run line and the same one-notification-per-run+kind rule.
|
||||
//
|
||||
// Everything here is pure: no DOM, no clock, no storage access. The page owns
|
||||
// the Notification constructor, the permission request gesture and localStorage;
|
||||
// the unit tests own the state machine. The attention model in `attention.js`
|
||||
// is the single authority for which runs qualify and for the dismissal identity,
|
||||
// so the in-page "Needs you" surface and the tray can never disagree.
|
||||
import { AttentionKind, attentionKey, attentionKindOf } from "./attention.js";
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Kinds, headlines and the run line
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/** The two run events that raise a notification (RunAlerts.kt RunAlertKind). */
|
||||
export const RunAlertKind = Object.freeze({
|
||||
Decision: AttentionKind.Decision,
|
||||
Failed: AttentionKind.Failed,
|
||||
});
|
||||
|
||||
/** `alertKindOf`: an attention kind is already exactly the notification kind. */
|
||||
export function alertKindOf(kind) {
|
||||
if (kind === AttentionKind.Decision || kind?.name === AttentionKind.Decision.name) {
|
||||
return AttentionKind.Decision;
|
||||
}
|
||||
if (kind === AttentionKind.Failed || kind?.name === AttentionKind.Failed.name) {
|
||||
return AttentionKind.Failed;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/** The short headline one kind shows (RunAlerts.alertTitle). */
|
||||
export function alertTitle(kind) {
|
||||
switch (alertKindOf(kind)?.name) {
|
||||
case "Decision":
|
||||
return "A run needs your decision";
|
||||
case "Failed":
|
||||
return "A run failed";
|
||||
default:
|
||||
return "";
|
||||
}
|
||||
}
|
||||
|
||||
/** The stable run+kind identity, the unit of dedupe (RunAlerts.alertKey). */
|
||||
export function alertKey(runId, kind) {
|
||||
const resolved = alertKindOf(kind);
|
||||
return resolved ? attentionKey(runId, resolved) : "";
|
||||
}
|
||||
|
||||
/**
|
||||
* The line naming the run (RunAlerts.alertText): the attention label, then the
|
||||
* pipeline it belongs to. The label is the run's trimmed title, falling back to
|
||||
* the pipeline name; a blank or equal pipeline is never repeated, so there is no
|
||||
* trailing separator.
|
||||
*/
|
||||
export function alertBody(run) {
|
||||
const pipeline = String(run?.pipeline ?? run?.name ?? "");
|
||||
const title = String(run?.label ?? run?.title ?? "").trim();
|
||||
const label = title !== "" ? title : pipeline;
|
||||
if (pipeline === "" || pipeline === label) return label;
|
||||
return `${label} \u00b7 ${pipeline}`;
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// The ledger: seed, observe, dedupe
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Tracks the last status seen for every run and the run+kind alerts already
|
||||
* raised in this page session.
|
||||
*
|
||||
* - `seed(runs)` records the authoritative list without raising anything, so a
|
||||
* run that was already failed/waiting when the page loaded (or when the socket
|
||||
* reconnected) never notifies.
|
||||
* - `beginSeed()`/`endSeed()` bracket the `subscribe` snapshot: the server writes
|
||||
* the current state of every watched run before its ack, and those frames are
|
||||
* seeds too, not transitions.
|
||||
* - `observe(frame)` raises only when a known run's status changes *into*
|
||||
* `failed` or `waiting`. A duplicate frame (same status), an unchanged
|
||||
* qualifying state, an unknown status and a first-seen run all return null.
|
||||
* - A run+kind key is forgotten when the run leaves that qualifying state, so a
|
||||
* genuinely new transition (for example failed -> running -> failed again) can
|
||||
* notify once more; the same transition can never repeat.
|
||||
* - A key present in the attention surface's dismissed set is suppressed. The
|
||||
* dismissal is the attention model's own `{runId}:{kind}` identity.
|
||||
* - `reset()` drops the status baseline on a socket drop but keeps the notified
|
||||
* keys, so a gap that swallows a transition cannot raise a notification after
|
||||
* the reconnect; the next seed establishes the new baseline.
|
||||
*/
|
||||
export function createAlertLedger() {
|
||||
const lastStatus = new Map();
|
||||
const notified = new Set();
|
||||
let seeding = false;
|
||||
|
||||
function seed(runs) {
|
||||
const next = new Map();
|
||||
for (const run of runs ?? []) {
|
||||
const runId = runIdOf(run?.id ?? run?.run_id);
|
||||
if (runId == null) continue;
|
||||
next.set(runId, normalizeStatus(run?.status));
|
||||
}
|
||||
lastStatus.clear();
|
||||
for (const [runId, status] of next) lastStatus.set(runId, status);
|
||||
pruneNotified(next);
|
||||
}
|
||||
|
||||
function observe(frame, { dismissed } = {}) {
|
||||
const runId = runIdOf(frame?.run_id ?? frame?.runId ?? frame?.id);
|
||||
const status = normalizeStatus(frame?.status);
|
||||
if (runId == null || status === "") return null;
|
||||
|
||||
const previous = lastStatus.get(runId);
|
||||
lastStatus.set(runId, status);
|
||||
|
||||
const kind = attentionKindOf(status);
|
||||
if (!kind) {
|
||||
forget(runId, AttentionKind.Decision);
|
||||
forget(runId, AttentionKind.Failed);
|
||||
return null;
|
||||
}
|
||||
// A run can only be in one qualifying state; forget the other kind's key so
|
||||
// a later transition back into it is a new event.
|
||||
forget(runId, kind === AttentionKind.Decision ? AttentionKind.Failed : AttentionKind.Decision);
|
||||
if (seeding) return null;
|
||||
if (previous === undefined || previous === status) return null;
|
||||
|
||||
const key = alertKey(runId, kind);
|
||||
if (notified.has(key)) return null;
|
||||
notified.add(key);
|
||||
const dismissedKeys =
|
||||
dismissed instanceof Set ? dismissed : new Set(Array.isArray(dismissed) ? dismissed : []);
|
||||
if (dismissedKeys.has(key)) return null;
|
||||
|
||||
return {
|
||||
runId,
|
||||
kind,
|
||||
key,
|
||||
title: alertTitle(kind),
|
||||
body: alertBody(frame),
|
||||
};
|
||||
}
|
||||
|
||||
function reset() {
|
||||
lastStatus.clear();
|
||||
seeding = false;
|
||||
}
|
||||
|
||||
function beginSeed() {
|
||||
seeding = true;
|
||||
}
|
||||
|
||||
function endSeed() {
|
||||
seeding = false;
|
||||
}
|
||||
|
||||
function forget(runId, kind) {
|
||||
const key = alertKey(runId, kind);
|
||||
if (key !== "") notified.delete(key);
|
||||
}
|
||||
|
||||
function pruneNotified(statuses) {
|
||||
for (const key of [...notified]) {
|
||||
const split = key.lastIndexOf(":");
|
||||
if (split < 0) continue;
|
||||
const runId = runIdOf(key.slice(0, split));
|
||||
const kindName = key.slice(split + 1);
|
||||
const status = runId == null ? undefined : statuses.get(runId);
|
||||
// A run that is absent from this read tells us nothing; keep its key.
|
||||
if (status === undefined) continue;
|
||||
const kind = attentionKindOf(status);
|
||||
if (!kind || kind.name !== kindName) notified.delete(key);
|
||||
}
|
||||
}
|
||||
|
||||
return {
|
||||
seed,
|
||||
observe,
|
||||
reset,
|
||||
beginSeed,
|
||||
endSeed,
|
||||
/** Test/introspection helper; returns a copy, never the live set. */
|
||||
notifiedKeys: () => [...notified],
|
||||
statusOf: (runId) => lastStatus.get(runIdOf(runId)),
|
||||
};
|
||||
}
|
||||
|
||||
/** Trim/lowercase the server's status word; an absent value is "". */
|
||||
function normalizeStatus(status) {
|
||||
return String(status ?? "").trim().toLowerCase();
|
||||
}
|
||||
|
||||
/** A positive run id as a number, or null for anything malformed. */
|
||||
function runIdOf(value) {
|
||||
const id = Number(value);
|
||||
return Number.isFinite(id) && id > 0 ? id : null;
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Permission wording and persistence
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/** Android's NOTIFICATION_RATIONALE, verbatim (RunAlerts.kt). */
|
||||
export const NOTIFICATION_RATIONALE =
|
||||
"Pipelines can notify you when a run is waiting for your decision or has failed. " +
|
||||
"Without it, those runs still appear in the in-app Needs you surface.";
|
||||
|
||||
/** The explicit-gesture control's label; shown only when a request is possible. */
|
||||
export const NOTIFICATION_REQUEST_LABEL = "Enable notifications";
|
||||
|
||||
export const NOTIFICATION_UNSUPPORTED =
|
||||
"This browser does not support notifications. The in-app Needs you surface is the only channel.";
|
||||
export const NOTIFICATION_INSECURE =
|
||||
"Notifications need a secure context (https or localhost). This page is not secure, so the " +
|
||||
"in-app Needs you surface is the only channel.";
|
||||
export const NOTIFICATION_GRANTED =
|
||||
"Notifications are on. Failed and waiting runs will raise a browser notification.";
|
||||
export const NOTIFICATION_DENIED =
|
||||
"Notifications are blocked for this site. Allow them in the browser's site settings to use them; " +
|
||||
"until then the in-app Needs you surface is the only channel.";
|
||||
export const NOTIFICATION_DEFAULT =
|
||||
"Notifications are off. Enable them to be told when a run fails or needs your decision.";
|
||||
export const NOTIFICATION_DEFAULT_ASKED =
|
||||
"Notifications are still off. Your browser did not grant permission when asked; you can ask " +
|
||||
"again, or the in-app Needs you surface remains the only channel.";
|
||||
|
||||
/**
|
||||
* The total permission view for Settings. `supported` and `secureContext` are
|
||||
* the browser's own facts; `permission` is the Notification API's own word
|
||||
* (`default` | `granted` | `denied`, anything else treated as default).
|
||||
*
|
||||
* Only a supported, secure page whose permission is still `default` offers the
|
||||
* request control. The request is always an explicit user gesture; nothing here
|
||||
* asks on its own, and the `asked` flag only changes the honest wording.
|
||||
*/
|
||||
export function notificationPermissionState({
|
||||
supported = true,
|
||||
secureContext = true,
|
||||
permission = "default",
|
||||
asked = false,
|
||||
} = {}) {
|
||||
const state = !supported
|
||||
? "unsupported"
|
||||
: !secureContext
|
||||
? "insecure"
|
||||
: permission === "granted"
|
||||
? "granted"
|
||||
: permission === "denied"
|
||||
? "denied"
|
||||
: "default";
|
||||
const canRequest = state === "default";
|
||||
let body = NOTIFICATION_DEFAULT;
|
||||
switch (state) {
|
||||
case "unsupported":
|
||||
body = NOTIFICATION_UNSUPPORTED;
|
||||
break;
|
||||
case "insecure":
|
||||
body = NOTIFICATION_INSECURE;
|
||||
break;
|
||||
case "granted":
|
||||
body = NOTIFICATION_GRANTED;
|
||||
break;
|
||||
case "denied":
|
||||
body = NOTIFICATION_DENIED;
|
||||
break;
|
||||
default:
|
||||
body = asked ? NOTIFICATION_DEFAULT_ASKED : NOTIFICATION_DEFAULT;
|
||||
}
|
||||
return {
|
||||
state,
|
||||
body,
|
||||
canRequest,
|
||||
actionLabel: canRequest ? NOTIFICATION_REQUEST_LABEL : null,
|
||||
asked: Boolean(asked),
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* The browser facts the permission view needs. Pure enough to unit-test with a
|
||||
* fake scope; the real page passes `globalThis`. An unrecognised permission
|
||||
* value is read as `default` rather than guessed.
|
||||
*/
|
||||
export function notificationEnvironment(scope = globalThis) {
|
||||
const ctor = scope?.Notification;
|
||||
const supported = typeof ctor === "function";
|
||||
const raw = supported ? ctor.permission : "default";
|
||||
const permission = raw === "granted" || raw === "denied" ? raw : "default";
|
||||
return { supported, secureContext: scope?.isSecureContext === true, permission };
|
||||
}
|
||||
|
||||
/** The one localStorage key for this page's notification preference. */
|
||||
export const NOTIFY_STORAGE_KEY = "pipelines.web.notify.v1";
|
||||
|
||||
/** Encode only the asked flag; no endpoint, credential or permission claim. */
|
||||
export function encodeNotificationSettings(settings) {
|
||||
return JSON.stringify({ asked: Boolean(settings?.asked) });
|
||||
}
|
||||
|
||||
/**
|
||||
* Decode the stored preference. Total: blank, unreadable JSON, a non-object, a
|
||||
* non-boolean or a throwing getter all mean "never asked", so a malformed value
|
||||
* can never throw into the page or claim the operator was asked.
|
||||
*/
|
||||
export function decodeNotificationSettings(stored) {
|
||||
const text = stored == null ? "" : String(stored).trim();
|
||||
if (text === "") return { asked: false };
|
||||
let parsed;
|
||||
try {
|
||||
parsed = JSON.parse(text);
|
||||
} catch {
|
||||
return { asked: false };
|
||||
}
|
||||
if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return { asked: false };
|
||||
return { asked: parsed.asked === true };
|
||||
}
|
||||
@@ -27,6 +27,14 @@ export const Protocol = Object.freeze({
|
||||
GET_RUN: "get_run",
|
||||
RUN: "run",
|
||||
|
||||
// Live run state (internal/protocol/runevents.go, L5/R10). `subscribe` sends
|
||||
// the current state of the watched runs as `run_event` frames and then a
|
||||
// compact delta on each transition; `unsubscribe` stops the watch. The page
|
||||
// uses the frames for run notifications without changing R10's runs-list fold.
|
||||
SUBSCRIBE: "subscribe",
|
||||
UNSUBSCRIBE: "unsubscribe",
|
||||
RUN_EVENT: "run_event",
|
||||
|
||||
// Omni-search (internal/protocol/search.go): the command and its reply type.
|
||||
// The per-kind payloads and the kind/limit vocabulary live in src/search.js.
|
||||
SEARCH: "search",
|
||||
|
||||
@@ -115,6 +115,24 @@ export class PipelinesRepository {
|
||||
return response.run_detail;
|
||||
}
|
||||
|
||||
/**
|
||||
* Watches run state (L5), mirroring `PipelinesRepository.subscribeRuns` for the
|
||||
* blank "any workspace" scope the runs list shows: exactly `{type:'subscribe',
|
||||
* workspace:''}` and no `run_ids` (an empty list would watch the whole scope,
|
||||
* but omitting the field is the shape the Android client sends). The server
|
||||
* replies with the current state of every matching run as unsolicited
|
||||
* `run_event` frames, then an id-matched ack, then deltas. Awaiting the ack is
|
||||
* how the page knows the snapshot has been delivered.
|
||||
*/
|
||||
async subscribeRuns() {
|
||||
return this.#client.call({ type: Protocol.SUBSCRIBE, workspace: "" });
|
||||
}
|
||||
|
||||
/** Stops this connection's run-state watch. Best effort; a disconnect drops it. */
|
||||
async unsubscribeRuns() {
|
||||
return this.#client.call({ type: Protocol.UNSUBSCRIBE });
|
||||
}
|
||||
|
||||
/**
|
||||
* Omni-search. Sends exactly `SearchRequest{query, kind, limit}` from
|
||||
* internal/protocol/search.go: `kind` is the empty string for every kind, and
|
||||
|
||||
+77
-2
@@ -1434,6 +1434,11 @@ code { background: var(--surface-2); padding: 1px 6px; border-radius: 6px; font-
|
||||
--------------------------------------------------------------------------- */
|
||||
|
||||
.chat-list { display: flex; flex-direction: column; }
|
||||
/* A row's Chat actions menu hangs below the button. `.list` clips its children
|
||||
for the rounded corners, which cut the panel off at the list's bottom edge and
|
||||
made the final rows' Hide/Rename items unclickable. Unclip only while a menu is
|
||||
open, mirroring `.list.runs`' filter-menu treatment. */
|
||||
.chat-list.menu-open { overflow: visible; }
|
||||
.chat-search { flex: 1 1 auto; min-width: 0; }
|
||||
.chat-toolbar .chat-new { white-space: nowrap; }
|
||||
|
||||
@@ -1521,10 +1526,67 @@ code { background: var(--surface-2); padding: 1px 6px; border-radius: 6px; font-
|
||||
.chat-row .row-meta { grid-column: 1; }
|
||||
.chat-row-actions { grid-column: 2; grid-row: 1 / span 2; align-self: center; }
|
||||
.chat-row-actions button { padding: 3px 10px; font-size: 12px; }
|
||||
.chat-close { border-color: var(--warn); color: var(--warn); }
|
||||
.chat-reopen { border-color: var(--accent); color: var(--accent); }
|
||||
.chat-menu-wrap { position: relative; }
|
||||
.chat-menu-button { min-width: 30px; font-size: 15px; line-height: 1; }
|
||||
.chat-menu-panel {
|
||||
position: absolute;
|
||||
top: calc(100% + 4px);
|
||||
right: 0;
|
||||
z-index: 25;
|
||||
display: grid;
|
||||
min-width: 190px;
|
||||
padding: 4px;
|
||||
background: var(--surface-2);
|
||||
border: 1px solid var(--border);
|
||||
border-radius: 10px;
|
||||
box-shadow: 0 16px 40px rgba(0, 0, 0, 0.5);
|
||||
}
|
||||
.chat-menu-item {
|
||||
justify-content: flex-start;
|
||||
padding: 7px 10px;
|
||||
text-align: left;
|
||||
font-size: 13px;
|
||||
border: none;
|
||||
white-space: nowrap;
|
||||
}
|
||||
.chat-menu-item:hover { background: var(--surface); }
|
||||
.chat-menu-close { color: var(--warn); }
|
||||
.chat-menu-reopen { color: var(--accent); }
|
||||
.chat-closed-chip { opacity: 0.8; }
|
||||
|
||||
/* The Rename chat dialog (C13): a name kept on this device only. */
|
||||
.chat-rename-field { display: grid; gap: 4px; }
|
||||
.chat-rename-label { font-size: 12px; color: var(--muted); }
|
||||
.chat-rename-helper { margin: 0; line-height: 1.5; font-size: 13px; color: var(--muted); }
|
||||
.chat-rename-save:disabled { opacity: 0.5; }
|
||||
|
||||
/* The one hide report (C13): fixed above the pane, replaced rather than queued. */
|
||||
.chat-snackbar {
|
||||
position: fixed;
|
||||
left: 50%;
|
||||
bottom: 20px;
|
||||
z-index: 35;
|
||||
transform: translateX(-50%);
|
||||
display: flex;
|
||||
gap: 16px;
|
||||
align-items: center;
|
||||
max-width: min(560px, calc(100vw - 32px));
|
||||
padding: 12px 16px;
|
||||
background: var(--surface-2);
|
||||
border: 1px solid var(--border);
|
||||
border-radius: 10px;
|
||||
box-shadow: 0 16px 40px rgba(0, 0, 0, 0.55);
|
||||
font-size: 13px;
|
||||
}
|
||||
.chat-snackbar-message { line-height: 1.4; }
|
||||
.chat-snackbar-undo {
|
||||
flex: none;
|
||||
border-color: var(--accent);
|
||||
color: var(--accent);
|
||||
font-weight: 600;
|
||||
font-size: 13px;
|
||||
}
|
||||
|
||||
.chat-activity { display: inline-flex; align-items: center; gap: 5px; font-size: 11px; color: var(--muted); }
|
||||
.chat-activity-dot { width: 7px; height: 7px; border-radius: 50%; background: currentColor; }
|
||||
.chat-activity-streaming { color: var(--accent); }
|
||||
@@ -2092,6 +2154,19 @@ code { background: var(--surface-2); padding: 1px 6px; border-radius: 6px; font-
|
||||
}
|
||||
.settings-warning-title { margin: 0; font-weight: 600; color: var(--bad); }
|
||||
.settings-warning-body { margin: 0; font-size: 12.5px; color: var(--muted); }
|
||||
.settings-notify-state {
|
||||
margin: 0;
|
||||
border: 1px solid var(--border);
|
||||
border-radius: 10px;
|
||||
background: var(--surface-2);
|
||||
padding: 12px 14px;
|
||||
font-size: 13px;
|
||||
color: var(--muted);
|
||||
}
|
||||
.settings-notify-granted { border-color: color-mix(in srgb, var(--ok) 45%, var(--border)); color: var(--ok); }
|
||||
.settings-notify-denied,
|
||||
.settings-notify-insecure,
|
||||
.settings-notify-unsupported { color: var(--warn); }
|
||||
.settings-saved { margin: 0; font-size: 12px; color: var(--muted); }
|
||||
.settings-save { justify-self: start; }
|
||||
.settings-card {
|
||||
|
||||
@@ -7,6 +7,7 @@ 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,
|
||||
@@ -20,7 +21,16 @@ import {
|
||||
CHAT_CREATE_PROMPT,
|
||||
CHAT_CREATE_TITLE,
|
||||
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,
|
||||
@@ -60,6 +70,7 @@ import {
|
||||
TURN_THINKING_WINDOW_MILLIS,
|
||||
appendChatNotice,
|
||||
applyChatEvent,
|
||||
applyChatOverrides,
|
||||
applyChatPermission,
|
||||
approvalCard,
|
||||
approvalResources,
|
||||
@@ -83,6 +94,7 @@ import {
|
||||
chatNoMatchMessage,
|
||||
chatNoticeLabel,
|
||||
chatOpensAtNewest,
|
||||
chatSeenWatermark,
|
||||
chatShowJumpToLatest,
|
||||
chatStartInLabel,
|
||||
chatStreamState,
|
||||
@@ -92,17 +104,26 @@ import {
|
||||
composerSendEnabled,
|
||||
composerSubmit,
|
||||
decisionLabel,
|
||||
decodeChatOverrides,
|
||||
decodeChatSeen,
|
||||
defaultDirectoryChoice,
|
||||
deltaPartId,
|
||||
directoryChoices,
|
||||
directoryLabel,
|
||||
dismissChatNotice,
|
||||
emptyChatOverrides,
|
||||
emptyChatSeen,
|
||||
encodeChatOverrides,
|
||||
encodeChatSeen,
|
||||
filterSessions,
|
||||
formatToolDuration,
|
||||
groupSessionsByDirectory,
|
||||
hideChatOverride,
|
||||
historyResync,
|
||||
isChatSessionUnseen,
|
||||
lineDiff,
|
||||
makeChatNotice,
|
||||
markChatUnseen,
|
||||
mergeHistoryPage,
|
||||
mergeShellFrame,
|
||||
mergeToolPart,
|
||||
@@ -113,12 +134,16 @@ import {
|
||||
permissionRiskText,
|
||||
prettyToolInput,
|
||||
queuedAfterFrame,
|
||||
readChatSeen,
|
||||
reasoningLabel,
|
||||
renameChatOverride,
|
||||
restoreChatOverride,
|
||||
resumedThread,
|
||||
runningAfterFrame,
|
||||
runningBackgroundShells,
|
||||
runningToolElapsedMillis,
|
||||
runningToolStamps,
|
||||
seedChatSeen,
|
||||
selectChatDirectory,
|
||||
sessionActivity,
|
||||
sessionActivityBadge,
|
||||
@@ -1741,3 +1766,169 @@ test("the create flow's wording is the app's verbatim", () => {
|
||||
assert.equal(chatStartInLabel(HOME_DIRECTORY), "Start in ~");
|
||||
assert.equal(chatStartInLabel("/repo/a"), "Start in /repo/a");
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// 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);
|
||||
});
|
||||
|
||||
@@ -0,0 +1,214 @@
|
||||
// The pure notification model (L5): qualifying transitions, exactly-once
|
||||
// dedupe, pre-existing/dismissed suppression, the app's exact wording and the
|
||||
// total permission/storage helpers. No DOM, no timer, no live server.
|
||||
import { test } from "node:test";
|
||||
import assert from "node:assert/strict";
|
||||
|
||||
import { AttentionKind, attentionKey } from "../src/attention.js";
|
||||
import {
|
||||
NOTIFICATION_DEFAULT,
|
||||
NOTIFICATION_DEFAULT_ASKED,
|
||||
NOTIFICATION_DENIED,
|
||||
NOTIFICATION_GRANTED,
|
||||
NOTIFICATION_INSECURE,
|
||||
NOTIFICATION_UNSUPPORTED,
|
||||
NOTIFY_STORAGE_KEY,
|
||||
alertBody,
|
||||
alertKey,
|
||||
alertTitle,
|
||||
createAlertLedger,
|
||||
decodeNotificationSettings,
|
||||
encodeNotificationSettings,
|
||||
notificationEnvironment,
|
||||
notificationPermissionState,
|
||||
} from "../src/notify.js";
|
||||
|
||||
const frame = (runId, status, extra = {}) => ({
|
||||
run_id: runId,
|
||||
status,
|
||||
name: "release",
|
||||
title: "Ship it",
|
||||
...extra,
|
||||
});
|
||||
|
||||
test("headlines are exactly the app's two, and unknown kinds are blank", () => {
|
||||
assert.equal(alertTitle(AttentionKind.Failed), "A run failed");
|
||||
assert.equal(alertTitle(AttentionKind.Decision), "A run needs your decision");
|
||||
assert.equal(alertTitle({ name: "Failed" }), "A run failed");
|
||||
assert.equal(alertTitle({ name: "Other" }), "");
|
||||
});
|
||||
|
||||
test("the alert identity is the attention identity", () => {
|
||||
assert.equal(alertKey(7, AttentionKind.Failed), attentionKey(7, AttentionKind.Failed));
|
||||
assert.equal(alertKey(7, AttentionKind.Decision), "7:Decision");
|
||||
});
|
||||
|
||||
test("alert body is the title then the pipeline, with the pipeline fallback", () => {
|
||||
assert.equal(alertBody({ label: "Ship it", pipeline: "release" }), "Ship it \u00b7 release");
|
||||
assert.equal(alertBody({ title: " Ship it ", name: "release" }), "Ship it \u00b7 release");
|
||||
assert.equal(alertBody({ title: " ", name: "release" }), "release");
|
||||
assert.equal(alertBody({ label: "release", pipeline: "release" }), "release");
|
||||
assert.equal(alertBody({ label: "Ship it", pipeline: "" }), "Ship it");
|
||||
assert.equal(alertBody(frame(7, "failed")), "Ship it \u00b7 release");
|
||||
});
|
||||
|
||||
test("queued -> failed raises one alert and duplicate frames never repeat it", () => {
|
||||
const ledger = createAlertLedger();
|
||||
ledger.seed([{ id: 4, status: "queued", name: "release", title: "Ship it" }]);
|
||||
const alert = ledger.observe(frame(4, "failed"));
|
||||
assert.equal(alert.title, "A run failed");
|
||||
assert.equal(alert.body, "Ship it \u00b7 release");
|
||||
assert.equal(alert.key, "4:Failed");
|
||||
assert.equal(ledger.observe(frame(4, "failed")), null);
|
||||
assert.equal(ledger.observe(frame(4, "failed")), null);
|
||||
});
|
||||
|
||||
test("running -> waiting raises the decision alert; unchanged waiting raises none", () => {
|
||||
const ledger = createAlertLedger();
|
||||
ledger.seed([{ id: 9, status: "running", name: "release", title: "Ship it" }]);
|
||||
const alert = ledger.observe(frame(9, "waiting"));
|
||||
assert.equal(alert.title, "A run needs your decision");
|
||||
assert.equal(alert.key, "9:Decision");
|
||||
assert.equal(ledger.observe(frame(9, "waiting")), null);
|
||||
});
|
||||
|
||||
test("succeeded, canceled, interrupted and unknown statuses raise nothing", () => {
|
||||
for (const status of ["succeeded", "canceled", "interrupted", "mystery", ""]) {
|
||||
const ledger = createAlertLedger();
|
||||
ledger.seed([{ id: 11, status: "running" }]);
|
||||
assert.equal(ledger.observe(frame(11, status)), null, `status ${status}`);
|
||||
}
|
||||
});
|
||||
|
||||
test("a first-seen failed/waiting run (a snapshot seed) raises nothing", () => {
|
||||
const ledger = createAlertLedger();
|
||||
assert.equal(ledger.observe(frame(21, "failed")), null);
|
||||
assert.equal(ledger.observe(frame(22, "waiting")), null);
|
||||
});
|
||||
|
||||
test("a run already failed/waiting in the seed raises nothing", () => {
|
||||
const ledger = createAlertLedger();
|
||||
ledger.seed([
|
||||
{ id: 31, status: "failed" },
|
||||
{ id: 32, status: "waiting" },
|
||||
]);
|
||||
assert.equal(ledger.observe(frame(31, "failed")), null);
|
||||
assert.equal(ledger.observe(frame(32, "waiting")), null);
|
||||
});
|
||||
|
||||
test("the subscribe snapshot is seeded, so a queued run that failed in the gap does not notify", () => {
|
||||
const ledger = createAlertLedger();
|
||||
ledger.seed([{ id: 41, status: "queued" }]);
|
||||
ledger.beginSeed();
|
||||
assert.equal(ledger.observe(frame(41, "failed")), null);
|
||||
ledger.endSeed();
|
||||
assert.equal(ledger.observe(frame(41, "failed")), null);
|
||||
// A later real transition still raises exactly once.
|
||||
assert.equal(ledger.observe(frame(41, "running")), null);
|
||||
assert.equal(ledger.observe(frame(41, "failed")).key, "41:Failed");
|
||||
});
|
||||
|
||||
test("leaving the qualifying state forgets the key for a genuinely new transition", () => {
|
||||
const ledger = createAlertLedger();
|
||||
ledger.seed([{ id: 51, status: "queued" }]);
|
||||
assert.equal(ledger.observe(frame(51, "failed")).key, "51:Failed");
|
||||
assert.equal(ledger.observe(frame(51, "running")), null);
|
||||
assert.equal(ledger.observe(frame(51, "failed")).key, "51:Failed");
|
||||
// And a failed -> waiting hand-off raises the other kind once.
|
||||
assert.equal(ledger.observe(frame(51, "waiting")).key, "51:Decision");
|
||||
assert.equal(ledger.observe(frame(51, "waiting")), null);
|
||||
});
|
||||
|
||||
test("a dismissed attention key notifies nothing, even on a real transition", () => {
|
||||
const ledger = createAlertLedger();
|
||||
ledger.seed([{ id: 61, status: "queued" }]);
|
||||
const alert = ledger.observe(frame(61, "failed"), {
|
||||
dismissed: new Set([attentionKey(61, AttentionKind.Failed)]),
|
||||
});
|
||||
assert.equal(alert, null);
|
||||
assert.deepEqual(ledger.notifiedKeys(), ["61:Failed"]);
|
||||
});
|
||||
|
||||
test("reset drops the status baseline but keeps the page session's dedupe", () => {
|
||||
const ledger = createAlertLedger();
|
||||
ledger.seed([{ id: 71, status: "queued" }]);
|
||||
assert.equal(ledger.observe(frame(71, "failed")).key, "71:Failed");
|
||||
ledger.reset();
|
||||
// Re-seeding the fresh (still failed) list is not a transition.
|
||||
ledger.seed([{ id: 71, status: "failed" }]);
|
||||
assert.equal(ledger.observe(frame(71, "failed")), null);
|
||||
assert.deepEqual(ledger.notifiedKeys(), ["71:Failed"]);
|
||||
});
|
||||
|
||||
test("a malformed frame is ignored, never crashed on", () => {
|
||||
const ledger = createAlertLedger();
|
||||
assert.equal(ledger.observe(null), null);
|
||||
assert.equal(ledger.observe({}), null);
|
||||
assert.equal(ledger.observe({ run_id: 0, status: "failed" }), null);
|
||||
});
|
||||
|
||||
test("permission wording is honest for every browser state", () => {
|
||||
assert.equal(notificationPermissionState({ supported: false }).body, NOTIFICATION_UNSUPPORTED);
|
||||
assert.equal(
|
||||
notificationPermissionState({ supported: true, secureContext: false }).body,
|
||||
NOTIFICATION_INSECURE,
|
||||
);
|
||||
assert.equal(notificationPermissionState({ permission: "denied" }).body, NOTIFICATION_DENIED);
|
||||
assert.equal(notificationPermissionState({ permission: "granted" }).body, NOTIFICATION_GRANTED);
|
||||
assert.equal(notificationPermissionState({ asked: false }).body, NOTIFICATION_DEFAULT);
|
||||
assert.equal(notificationPermissionState({ asked: true }).body, NOTIFICATION_DEFAULT_ASKED);
|
||||
});
|
||||
|
||||
test("only a supported, secure default permission offers the request control", () => {
|
||||
const defaultView = notificationPermissionState({ asked: false });
|
||||
assert.equal(defaultView.state, "default");
|
||||
assert.equal(defaultView.canRequest, true);
|
||||
assert.equal(defaultView.actionLabel, "Enable notifications");
|
||||
|
||||
for (const options of [
|
||||
{ supported: false },
|
||||
{ supported: true, secureContext: false },
|
||||
{ permission: "granted" },
|
||||
{ permission: "denied" },
|
||||
]) {
|
||||
const view = notificationPermissionState(options);
|
||||
assert.equal(view.canRequest, false, JSON.stringify(options));
|
||||
assert.equal(view.actionLabel, null, JSON.stringify(options));
|
||||
}
|
||||
// Having been asked once does not remove the control while permission stays
|
||||
// default (the browser itself decides whether it may prompt again).
|
||||
assert.equal(notificationPermissionState({ asked: true }).canRequest, true);
|
||||
});
|
||||
|
||||
test("the asked flag round-trips and malformed storage decodes safely", () => {
|
||||
assert.equal(NOTIFY_STORAGE_KEY, "pipelines.web.notify.v1");
|
||||
const stored = encodeNotificationSettings({ asked: true });
|
||||
assert.deepEqual(JSON.parse(stored), { asked: true });
|
||||
assert.equal(decodeNotificationSettings(stored).asked, true);
|
||||
assert.equal(decodeNotificationSettings(encodeNotificationSettings({ asked: false })).asked, false);
|
||||
|
||||
for (const bad of ["", " ", "not json", "[]", "null", '"asked"', "{", '{"asked":"yes"}', "42"]) {
|
||||
assert.deepEqual(decodeNotificationSettings(bad), { asked: false }, bad);
|
||||
}
|
||||
assert.deepEqual(decodeNotificationSettings(null), { asked: false });
|
||||
});
|
||||
|
||||
test("notificationEnvironment reads the browser facts without guessing", () => {
|
||||
const granted = notificationEnvironment({
|
||||
Notification: Object.assign(function Notification() {}, { permission: "granted" }),
|
||||
isSecureContext: true,
|
||||
});
|
||||
assert.deepEqual(granted, { supported: true, secureContext: true, permission: "granted" });
|
||||
|
||||
assert.deepEqual(notificationEnvironment({}), {
|
||||
supported: false,
|
||||
secureContext: false,
|
||||
permission: "default",
|
||||
});
|
||||
|
||||
const odd = notificationEnvironment({
|
||||
Notification: Object.assign(function Notification() {}, { permission: "maybe" }),
|
||||
isSecureContext: false,
|
||||
});
|
||||
assert.deepEqual(odd, { supported: true, secureContext: false, permission: "default" });
|
||||
});
|
||||
@@ -293,6 +293,30 @@ test("a run action throws when the reply has no run detail", async () => {
|
||||
await assert.rejects(() => repo.cancelRun(7), ProtocolError);
|
||||
});
|
||||
|
||||
test("subscribeRuns sends exactly the blank any-workspace watch and no run_ids", async () => {
|
||||
const { repo, ws } = connected();
|
||||
ws.reply = (frame) => ({ id: frame.id, type: "subscribe" });
|
||||
|
||||
await repo.subscribeRuns();
|
||||
assert.deepEqual(lastFrame(ws), { type: "subscribe", workspace: "" });
|
||||
});
|
||||
|
||||
test("unsubscribeRuns sends exactly {type:'unsubscribe'}", async () => {
|
||||
const { repo, ws } = connected();
|
||||
ws.reply = (frame) => ({ id: frame.id, type: "unsubscribe" });
|
||||
|
||||
await repo.unsubscribeRuns();
|
||||
assert.deepEqual(lastFrame(ws), { type: "unsubscribe" });
|
||||
});
|
||||
|
||||
test("subscribeRuns is not sent while the page is not connected", async () => {
|
||||
FakeWebSocket.instances = [];
|
||||
const client = new PipelinesClient({ WebSocketImpl: FakeWebSocket });
|
||||
const repo = new PipelinesRepository(client);
|
||||
await assert.rejects(() => repo.subscribeRuns(), { name: "NotConnectedError" });
|
||||
assert.equal(FakeWebSocket.instances.length, 0);
|
||||
});
|
||||
|
||||
// ---- The composer's own commands (C8/C9) ----------------------------------
|
||||
|
||||
test("chatPrompt trims the text, sends the operation and native message ids, and omits files when empty", async () => {
|
||||
|
||||
+592
-25
@@ -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
|
||||
@@ -32,6 +34,12 @@ import {
|
||||
WORKSPACE_PLACEHOLDER,
|
||||
WORKSPACE_STORAGE_KEY,
|
||||
} from "../src/settings.js";
|
||||
import {
|
||||
NOTIFICATION_DEFAULT,
|
||||
NOTIFICATION_DENIED,
|
||||
NOTIFICATION_GRANTED,
|
||||
NOTIFY_STORAGE_KEY,
|
||||
} from "../src/notify.js";
|
||||
|
||||
const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
|
||||
|
||||
@@ -51,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")),
|
||||
@@ -59,6 +72,8 @@ const out = resolve(
|
||||
// Scratch mode: only the P5 create-from-template flow runs, against a throwaway
|
||||
// server with its own database. The default (live) run sends no submit.
|
||||
const scratch = process.argv.includes("--scratch");
|
||||
// Focused notification evidence only; skips the unrelated live-suite steps.
|
||||
const notifyOnly = process.argv.includes("--notify");
|
||||
|
||||
// The page must connect through its own proxy (the server rejects a cross-origin
|
||||
// upgrade), but serve.mjs only proxies /connect — not /artifacts. Point the URL
|
||||
@@ -161,6 +176,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,
|
||||
@@ -375,6 +400,225 @@ const drag = (dx, dy) =>
|
||||
return true;
|
||||
})()`);
|
||||
|
||||
// L5: the notification Settings states and the synthetic transition assertions.
|
||||
// Extracted so `--notify` can run exactly this evidence without the unrelated
|
||||
// live-suite steps; the default full run calls it in its L1/L5 position.
|
||||
async function runNotificationChecks() {
|
||||
// L5: notifications. A real OS notification cannot be captured reliably in
|
||||
// headless Chrome, so the browser's Notification constructor is stubbed and
|
||||
// recorded before this document loads; the qualifying transitions are then
|
||||
// pushed through the page's own socket `onmessage`/`frame` path and matched
|
||||
// against the pure ledger's decisions. The Settings states are real renders.
|
||||
// The stub also pre-dismisses one synthetic run+kind so suppression is proven
|
||||
// through the same attention identity the page loads at boot.
|
||||
step("L5: notification settings and synthetic run transitions");
|
||||
await page.addInitScript(`(() => {
|
||||
if (window.__notificationStubInstalled) return;
|
||||
window.__notificationStubInstalled = true;
|
||||
window.__notificationCalls = [];
|
||||
window.__notificationObjects = [];
|
||||
window.__notificationRequests = 0;
|
||||
window.__notificationPermission = "default";
|
||||
function FakeNotification(title, options) {
|
||||
const call = {
|
||||
title: String(title),
|
||||
body: String(options && options.body != null ? options.body : ""),
|
||||
tag: String(options && options.tag != null ? options.tag : ""),
|
||||
};
|
||||
window.__notificationCalls.push(call);
|
||||
window.__notificationObjects.push(this);
|
||||
this.title = call.title;
|
||||
this.body = call.body;
|
||||
this.tag = call.tag;
|
||||
this.onclick = null;
|
||||
this.close = function () {};
|
||||
}
|
||||
Object.defineProperty(FakeNotification, "permission", {
|
||||
configurable: true,
|
||||
get: function () { return window.__notificationPermission; },
|
||||
});
|
||||
FakeNotification.requestPermission = function () {
|
||||
window.__notificationRequests += 1;
|
||||
window.__notificationPermission = "granted";
|
||||
return Promise.resolve("granted");
|
||||
};
|
||||
Object.defineProperty(window, "Notification", {
|
||||
configurable: true,
|
||||
writable: true,
|
||||
value: FakeNotification,
|
||||
});
|
||||
localStorage.setItem("pipelines.web.attention.v1", JSON.stringify(["990001:Failed"]));
|
||||
})()`);
|
||||
await page.evaluate(`location.reload()`);
|
||||
await page.waitForSelector("#url", { timeout: 15000 });
|
||||
await page.fill("#url", `ws://127.0.0.1:${port}/connect`);
|
||||
await page.click("#connectBtn");
|
||||
await page.waitForSelector(".conn-banner.conn-ok", { timeout: 25000 });
|
||||
// The watch is sent once per connected epoch, after the list has seeded the
|
||||
// ledger. Wait for that send (and its ack continuation) so the synthetic
|
||||
// frames below are observed as deltas rather than as part of the snapshot.
|
||||
await eventually(
|
||||
() => page.evaluate(`(window.__pipelinesSentTypes || []).includes("subscribe")`),
|
||||
{ timeout: 15000, what: "the run-event subscribe frame" },
|
||||
);
|
||||
await page.evaluate(`new Promise((resolve) => setTimeout(resolve, 250))`);
|
||||
await page.clickText("nav.tabs button.tab", "Settings");
|
||||
await page.waitForSelector("#settingsNotificationState", { timeout: 15000 });
|
||||
|
||||
// Default state: honest wording, one explicit control, and nothing asked on
|
||||
// load or on connect.
|
||||
const defaultNotificationState = await text("#settingsNotificationState");
|
||||
if (defaultNotificationState !== NOTIFICATION_DEFAULT) {
|
||||
throw new Error(`default notification copy: ${defaultNotificationState}`);
|
||||
}
|
||||
const notificationsOnLoad = await page.evaluate(`window.__notificationRequests`);
|
||||
if (notificationsOnLoad !== 0) {
|
||||
throw new Error(`the page requested notification permission on load: ${notificationsOnLoad}`);
|
||||
}
|
||||
const enableControl = await page.evaluate(
|
||||
`document.querySelector("#settingsEnableNotifications")?.textContent ?? ""`,
|
||||
);
|
||||
if (enableControl !== "Enable notifications") {
|
||||
throw new Error(`notification request control: ${enableControl}`);
|
||||
}
|
||||
await page.evaluate(`document.querySelector("#settingsNotifications")?.scrollIntoView({ block: "center" })`);
|
||||
await shot("L5-notifications-settings.png");
|
||||
console.log(` notifications default: "${defaultNotificationState}" (0 permission requests on load)`);
|
||||
|
||||
// The explicit control grants through the stub; the page must remember that it
|
||||
// asked and stop offering the control.
|
||||
await page.click("#settingsEnableNotifications");
|
||||
await eventually(
|
||||
() => page.evaluate(`document.querySelector("#settingsNotificationState")?.textContent === ${JSON.stringify(NOTIFICATION_GRANTED)}`),
|
||||
{ timeout: 10000, what: "the granted notification wording" },
|
||||
);
|
||||
const grantState = await page.evaluate(`({
|
||||
requests: window.__notificationRequests,
|
||||
stored: localStorage.getItem(${JSON.stringify(NOTIFY_STORAGE_KEY)}),
|
||||
control: !!document.querySelector("#settingsEnableNotifications"),
|
||||
})`);
|
||||
if (grantState.requests !== 1 || grantState.control) {
|
||||
throw new Error(`grant state: ${JSON.stringify(grantState)}`);
|
||||
}
|
||||
if (grantState.stored !== JSON.stringify({ asked: true })) {
|
||||
throw new Error(`asked flag not stored: ${grantState.stored}`);
|
||||
}
|
||||
await page.evaluate(`document.querySelector("#settingsNotifications")?.scrollIntoView({ block: "center" })`);
|
||||
await shot("L5-notifications-granted.png");
|
||||
console.log(` notifications granted after one explicit click; asked=${grantState.stored}`);
|
||||
|
||||
// Drive the real frame path. The run id is a real run so the notification's
|
||||
// click can open it through the page's existing Runs navigation (L6 is todo).
|
||||
await page.clickText("nav.tabs button.tab", "Runs");
|
||||
await page.waitForSelector(".list.runs .run-row-meta[data-run-id]", { timeout: 25000 });
|
||||
const realRunId = await page.evaluate(
|
||||
`Number(document.querySelector(".list.runs .run-row-meta[data-run-id]")?.getAttribute("data-run-id"))`,
|
||||
);
|
||||
if (!(realRunId > 0)) throw new Error(`no real run id for the notification click: ${realRunId}`);
|
||||
const runFrame = (runId, status, extra = {}) => ({
|
||||
run_id: runId,
|
||||
status,
|
||||
name: "Smoke pipeline",
|
||||
title: "Smoke run",
|
||||
...extra,
|
||||
});
|
||||
const replayRunEvents = (frames) =>
|
||||
page.evaluate(`(() => {
|
||||
const ws = window.__pipelinesSocket;
|
||||
if (!ws || typeof ws.onmessage !== "function") return false;
|
||||
for (const frame of ${JSON.stringify(frames)}) {
|
||||
ws.onmessage({ data: JSON.stringify({ type: "run_event", run_event: frame }) });
|
||||
}
|
||||
return true;
|
||||
})()`);
|
||||
const notificationCount = () => page.evaluate(`window.__notificationCalls.length`);
|
||||
const notifications = () => page.evaluate(`window.__notificationCalls`);
|
||||
|
||||
// queued -> failed raises exactly one; duplicate/terminal/unknown frames add none.
|
||||
if (!(await replayRunEvents([runFrame(realRunId, "queued")]))) {
|
||||
throw new Error("L5: the socket shim did not expose the live socket for run events");
|
||||
}
|
||||
await replayRunEvents([runFrame(realRunId, "failed")]);
|
||||
if ((await notificationCount()) !== 1) {
|
||||
throw new Error(`queued->failed should notify once: ${JSON.stringify(await notifications())}`);
|
||||
}
|
||||
const failedAlert = (await notifications())[0];
|
||||
const failedTag = `${realRunId}:Failed`;
|
||||
if (
|
||||
failedAlert.title !== "A run failed" ||
|
||||
failedAlert.body !== "Smoke run \u00b7 Smoke pipeline" ||
|
||||
failedAlert.tag !== failedTag
|
||||
) {
|
||||
throw new Error(`failed alert wording/tag: ${JSON.stringify(failedAlert)}`);
|
||||
}
|
||||
await replayRunEvents([runFrame(realRunId, "failed")]);
|
||||
if ((await notificationCount()) !== 1) throw new Error("a duplicate failed frame repeated the notification");
|
||||
for (const status of ["succeeded", "canceled", "interrupted", "mystery"]) {
|
||||
await replayRunEvents([runFrame(realRunId, status)]);
|
||||
}
|
||||
if ((await notificationCount()) !== 1) {
|
||||
throw new Error(`a non-qualifying status raised a notification: ${JSON.stringify(await notifications())}`);
|
||||
}
|
||||
console.log(` queued -> failed raised one: ${JSON.stringify(failedAlert)}`);
|
||||
|
||||
// running -> waiting raises exactly one decision alert; a duplicate adds none.
|
||||
await replayRunEvents([runFrame(realRunId, "running"), runFrame(realRunId, "waiting")]);
|
||||
if ((await notificationCount()) !== 2) {
|
||||
throw new Error(`running->waiting should notify once: ${JSON.stringify(await notifications())}`);
|
||||
}
|
||||
const waitingAlert = (await notifications())[1];
|
||||
if (
|
||||
waitingAlert.title !== "A run needs your decision" ||
|
||||
waitingAlert.body !== "Smoke run \u00b7 Smoke pipeline" ||
|
||||
waitingAlert.tag !== `${realRunId}:Decision`
|
||||
) {
|
||||
throw new Error(`waiting alert wording/tag: ${JSON.stringify(waitingAlert)}`);
|
||||
}
|
||||
await replayRunEvents([runFrame(realRunId, "waiting")]);
|
||||
if ((await notificationCount()) !== 2) throw new Error("a duplicate waiting frame repeated the notification");
|
||||
|
||||
// First-seen failed/waiting (the subscribe/seed rule) and a dismissed key
|
||||
// raise nothing; the dismissed identity is the one loaded at boot.
|
||||
await replayRunEvents([
|
||||
runFrame(990002, "failed"),
|
||||
runFrame(990003, "waiting"),
|
||||
runFrame(990001, "queued"),
|
||||
runFrame(990001, "failed"),
|
||||
]);
|
||||
if ((await notificationCount()) !== 2) {
|
||||
throw new Error(`pre-existing/dismissed runs notified: ${JSON.stringify(await notifications())}`);
|
||||
}
|
||||
console.log(" running -> waiting raised one; duplicates, terminal/unknown statuses, first-seen and dismissed runs raised none");
|
||||
|
||||
// The click focuses the page and uses the existing Runs navigation to select
|
||||
// the run (L6's URL route is still todo; no route is invented).
|
||||
await page.evaluate(`window.__notificationObjects[0]?.onclick?.()`);
|
||||
await eventually(
|
||||
() =>
|
||||
page.evaluate(
|
||||
`!!document.querySelector('.list.runs .run-row.selected .run-row-meta[data-run-id="${realRunId}"]')`,
|
||||
),
|
||||
{ timeout: 20000, what: "the notification click to open Runs with the run selected" },
|
||||
);
|
||||
console.log(` notification click opened Runs with run ${realRunId} selected`);
|
||||
|
||||
// The denied state is rendered from the same pure wording and offers no control.
|
||||
await page.evaluate(`window.__notificationPermission = "denied"`);
|
||||
await page.clickText("nav.tabs button.tab", "Settings");
|
||||
await eventually(
|
||||
() => page.evaluate(`document.querySelector("#settingsNotificationState")?.textContent === ${JSON.stringify(NOTIFICATION_DENIED)}`),
|
||||
{ timeout: 10000, what: "the denied notification wording" },
|
||||
);
|
||||
const deniedControl = await page.evaluate(`!!document.querySelector("#settingsEnableNotifications")`);
|
||||
if (deniedControl) throw new Error("the denied state still offers the request control");
|
||||
await page.evaluate(`document.querySelector("#settingsNotifications")?.scrollIntoView({ block: "center" })`);
|
||||
await shot("L5-notifications-denied.png");
|
||||
console.log(` notifications denied: "${NOTIFICATION_DENIED}" (no request control)`);
|
||||
console.log(
|
||||
" NOTE: the notification frames above are synthetic and the browser Notification was recorded by a stub; no real OS notification was observed",
|
||||
);
|
||||
}
|
||||
|
||||
try {
|
||||
await mkdir(out, { recursive: true });
|
||||
|
||||
@@ -519,7 +763,11 @@ try {
|
||||
for (const shot of shots) console.log(` ${shot}`);
|
||||
}
|
||||
|
||||
if (!scratch) {
|
||||
if (notifyOnly) {
|
||||
await runNotificationChecks();
|
||||
console.log("\nUI SMOKE PASS");
|
||||
for (const shot of shots) console.log(` ${shot}`);
|
||||
} else if (!scratch) {
|
||||
const pipelineCount = await page.evaluate(
|
||||
`document.querySelectorAll("#pipelineRows button.row").length`,
|
||||
);
|
||||
@@ -1482,6 +1730,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(`(() => {
|
||||
@@ -1499,7 +1750,7 @@ try {
|
||||
// detail loaded; this capture is documented as best effort, so say so rather
|
||||
// than fail an unrelated step on live-data timing.
|
||||
if (!live) {
|
||||
console.log(` -- run ${liveRunId} stopped before its active stage rendered; skipped the live halo capture`);
|
||||
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}`);
|
||||
@@ -2414,6 +2665,8 @@ try {
|
||||
meta: row.querySelector(".chat-row-meta")?.textContent ?? "",
|
||||
close: !!row.querySelector(".chat-close"),
|
||||
closed: !!row.querySelector(".chat-closed-chip"),
|
||||
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}`);
|
||||
@@ -2421,13 +2674,15 @@ try {
|
||||
if (chatList.rows.length === 0) throw new Error("no chat sessions rendered");
|
||||
const operatorRow =
|
||||
chatList.rows.find((row) => row.id === expectedSession) ??
|
||||
chatList.rows.find((row) => !row.closed && row.close);
|
||||
chatList.rows.find((row) => !row.closed && row.menu);
|
||||
if (!operatorRow) throw new Error("no open chat row rendered");
|
||||
if (!operatorRow.title) throw new Error("the operator chat row has no title");
|
||||
if (!operatorRow.chips.includes("Operator")) {
|
||||
throw new Error(`chat kind chip: ${operatorRow.chips.join(", ")}`);
|
||||
}
|
||||
if (!operatorRow.close) throw new Error("the open chat row offers no Close chat action");
|
||||
if (!operatorRow.menu || operatorRow.menuLabel !== "Chat actions") {
|
||||
throw new Error(`the open chat row's Chat actions menu: ${JSON.stringify(operatorRow)}`);
|
||||
}
|
||||
console.log(
|
||||
` chat list: ${chatList.rows.length} session(s); "${operatorRow.title}" ` +
|
||||
`[${operatorRow.chips.join(", ")}] — ${operatorRow.meta}`,
|
||||
@@ -2435,9 +2690,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="${operatorRow.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(operatorRow.id);
|
||||
await page.click(`#chatRows .chat-row[data-session="${operatorRow.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 ?? ""`,
|
||||
@@ -2603,9 +2860,11 @@ try {
|
||||
);
|
||||
await shot("76-chat-created-list.png");
|
||||
|
||||
// Close the one real session it created (chat_close through the C3 confirm) and
|
||||
// capture the Closed chip. Nothing is deleted; the row stays as closed history.
|
||||
await page.click(`#chatRows .chat-row[data-session="${createdId}"] .chat-close`);
|
||||
// Close the one real session it created (chat_close through the C3 confirm,
|
||||
// behind C13's Chat actions menu) and capture the Closed chip. Nothing is
|
||||
// deleted; the row stays as closed history.
|
||||
await openChatRowMenu(createdId);
|
||||
await page.click(`#chatRows .chat-row[data-session="${createdId}"] .chat-menu-close`);
|
||||
await page.waitForSelector(".confirm-chat-close", { timeout: 15000 });
|
||||
await page.click(".confirm-chat-close .confirm-accept");
|
||||
await eventually(
|
||||
@@ -2620,13 +2879,15 @@ try {
|
||||
row?.scrollIntoView({ block: "center" });
|
||||
return {
|
||||
closed: !!row?.querySelector(".chat-closed-chip"),
|
||||
hasClose: !!row?.querySelector(".chat-close"),
|
||||
hasReopen: !!row?.querySelector(".chat-reopen"),
|
||||
hasClose: !!row?.querySelector(".chat-menu-close"),
|
||||
hasReopen: !!row?.querySelector(".chat-menu-reopen"),
|
||||
};
|
||||
})()`);
|
||||
if (!createdClosed.closed || createdClosed.hasClose || !createdClosed.hasReopen) {
|
||||
throw new Error(`C2 closed row: ${JSON.stringify(createdClosed)}`);
|
||||
}
|
||||
// Close the actions menu so the capture shows the row itself, not the panel.
|
||||
await page.click(`#chatRows .chat-row[data-session="${createdId}"] .chat-menu-button`);
|
||||
console.log(
|
||||
` C2: created real session ${createdId} ("New chat" in ~) and closed it via chat_close; ` +
|
||||
"it now shows the Closed chip (kept as history, not deleted)",
|
||||
@@ -2644,6 +2905,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}"]`);
|
||||
@@ -2664,15 +2931,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(
|
||||
@@ -3146,7 +3415,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 ?? "",
|
||||
@@ -3565,10 +3835,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 }))`,
|
||||
@@ -3785,15 +4056,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.
|
||||
@@ -4844,6 +5131,8 @@ try {
|
||||
}
|
||||
console.log(` reload restored url=${restoredUrl} workspace=${restoredWorkspace}`);
|
||||
|
||||
await runNotificationChecks();
|
||||
|
||||
// C11: the background-tasks bar. The live server has no running shell to read
|
||||
// safely, so the bar is driven from synthetic `shell` frames replayed through
|
||||
// the page's own socket handler (the same shim) and the bounded output pages are
|
||||
@@ -5181,6 +5470,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}`);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user