diff --git a/e2e/README.md b/e2e/README.md
index eb7e7239a..2ca639d1a 100644
--- a/e2e/README.md
+++ b/e2e/README.md
@@ -84,7 +84,8 @@ console or page error fails the check. One module covers one behaviour;
families share a prefix: `audit-*` for the audit page (redirect,
filters, revert, runtime, views-export, retention-live, phone),
`workflow-*` for the canvas (loading, validation, phone-layout, logic),
-`chat-composer` for chat input.
+`chat-composer` for chat input, `chat-dock-*` for the chat dock (pin, drag-cancel,
+layout, resize, drafts, picker, phone).
`routes` loads every static route and flags text with stray leading,
trailing or doubled spaces. `seeded` checks the seed is visible.
diff --git a/e2e/checks/chat-dock-drafts.cjs b/e2e/checks/chat-dock-drafts.cjs
new file mode 100644
index 000000000..d7285a6b3
--- /dev/null
+++ b/e2e/checks/chat-dock-drafts.cjs
@@ -0,0 +1,42 @@
+// Each conversation keeps its own unsent text and attached tasks. Starting a
+// new chat opens an empty composer, switching back restores the earlier
+// draft, and hiding and reopening the conversation loses nothing.
+const assert = require('node:assert/strict');
+const h = require('./helpers/chat-dock.cjs');
+
+module.exports = async ({ page, go, shot }) => {
+ await page.route('**/api/tasks?*', (route) =>
+ route.fulfill({ contentType: 'application/json', body: JSON.stringify([{ id: 1861, title: 'Task picker', status: 'running' }]) }),
+ );
+ await h.load(page, go);
+ await h.expand(page);
+ const composer = h.composerOf(page);
+ const tags = page.getByRole('list', { name: 'Attached tasks' });
+
+ await composer.fill('draft for the first chat');
+ await composer.fill('#');
+ await page.getByRole('listbox', { name: 'Tasks' }).getByRole('option').first().click();
+ await tags.getByText('#1861').waitFor();
+ await composer.fill('draft for the first chat');
+
+ await page.getByRole('button', { name: 'New chat' }).click();
+ await h.until(async () => (await composer.inputValue()) === '' && (await tags.count()) === 0, 'a new chat inherited the first chat draft');
+ await composer.fill('draft for the second chat');
+
+ await h.hideOf(page).click();
+ await h.expand(page);
+ assert.equal(await composer.inputValue(), 'draft for the second chat', 'hiding the conversation lost the draft');
+
+ const pick = async (index) => {
+ await page.getByRole('combobox', { name: 'Conversation' }).click();
+ await page.getByRole('option').nth(index).click();
+ };
+ await pick(1);
+ await h.until(async () => (await composer.inputValue()) === 'draft for the first chat', 'switching back did not restore the first draft');
+ await tags.getByText('#1861').waitFor();
+ await shot('first-chat-draft');
+
+ await pick(0);
+ await h.until(async () => (await composer.inputValue()) === 'draft for the second chat', 'switching forward did not restore the second draft');
+ assert.equal(await tags.count(), 0, 'the first chat task tag leaked into the second chat');
+};
diff --git a/e2e/checks/chat-dock-drag-cancel.cjs b/e2e/checks/chat-dock-drag-cancel.cjs
new file mode 100644
index 000000000..46be294aa
--- /dev/null
+++ b/e2e/checks/chat-dock-drag-cancel.cjs
@@ -0,0 +1,27 @@
+// A drag the browser cancels (a touch turned into a scroll, a lost pointer)
+// leaves the dock where it was: nothing pins, nothing stays offset, and the
+// next drag still works.
+const assert = require('node:assert/strict');
+const h = require('./helpers/chat-dock.cjs');
+
+module.exports = async ({ page, go }) => {
+ await h.load(page, go);
+ await h.expand(page);
+ const dock = h.dockOf(page);
+ const before = await dock.boundingBox();
+ const header = dock.locator('div.cursor-grab');
+
+ await h.dragTo(page, 1430);
+ const dragging = await dock.getAttribute('style');
+ assert.ok(/translate/.test(dragging || ''), 'the drag never started, so cancelling it proves nothing');
+ await header.dispatchEvent('pointercancel');
+ await page.mouse.up();
+
+ await h.until(async () => !/translate/.test((await dock.getAttribute('style')) || ''), 'the dock stayed offset after the drag was cancelled');
+ assert.deepEqual(await dock.boundingBox(), before, 'cancelling the drag moved the dock');
+ assert.equal((await h.saved(page)).side, null, 'a cancelled drag pinned the dock');
+
+ await h.dragTo(page, 1430);
+ await page.mouse.up();
+ await h.until(async () => (await h.saved(page)).side === 'right', 'a drag after a cancelled one did not pin');
+};
diff --git a/e2e/checks/chat-dock-layout.cjs b/e2e/checks/chat-dock-layout.cjs
new file mode 100644
index 000000000..3707982a5
--- /dev/null
+++ b/e2e/checks/chat-dock-layout.cjs
@@ -0,0 +1,46 @@
+// The saved dock layout: a stored side and width are honoured, widths outside
+// the allowed range are clamped, unreadable JSON falls back to a usable
+// floating dock that saves again, and visiting phone width never overwrites
+// the desktop choice.
+const assert = require('node:assert/strict');
+const h = require('./helpers/chat-dock.cjs');
+
+module.exports = async ({ page, go, shot, tolerate }) => {
+ tolerate(/JSON|SyntaxError/);
+ const dock = h.dockOf(page);
+
+ await h.load(page, go, JSON.stringify({ side: 'left', width: 500 }));
+ await h.expand(page);
+ let box = await dock.boundingBox();
+ h.near(box.x, 0, 'saved left side');
+ h.near(box.width, 500, 'saved width');
+ assert.ok((await h.mainRect(page)).x >= 499, 'page did not reflow beside the restored dock');
+
+ await h.load(page, go, JSON.stringify({ side: 'right', width: -4 }));
+ await h.expand(page);
+ h.near((await dock.boundingBox()).width, 320, 'a negative width clamps to the minimum');
+
+ await h.load(page, go, JSON.stringify({ side: 'right', width: 9999 }));
+ await h.expand(page);
+ h.near((await dock.boundingBox()).width, 720, 'a huge width clamps to the maximum');
+
+ await h.load(page, go, '{broken');
+ await h.expand(page);
+ box = await dock.boundingBox();
+ assert.ok(box.height < 900 && box.x > 0 && box.x + box.width < 1440, 'unreadable layout did not fall back to a floating dock');
+ await h.composerOf(page).fill('still usable');
+ await h.dragTo(page, 1430);
+ await page.mouse.up();
+ await h.until(async () => (await h.saved(page)).side === 'right', 'the dock did not save a layout over the unreadable one');
+ await shot('recovered');
+
+ await h.load(page, go, JSON.stringify({ side: 'left', width: 460 }));
+ const layout = await h.stored(page);
+ await page.setViewportSize({ width: 390, height: 844 });
+ await h.expand(page);
+ box = await dock.boundingBox();
+ assert.ok(box.x >= 0 && box.x + box.width <= 390, 'the dock overflows the phone viewport');
+ await page.setViewportSize({ width: 1440, height: 900 });
+ assert.equal(await h.stored(page), layout, 'visiting phone width rewrote the saved layout');
+ await h.until(async () => Math.abs((await dock.boundingBox()).width - 460) <= 1, 'the desktop layout did not return after phone width');
+};
diff --git a/e2e/checks/chat-dock-phone.cjs b/e2e/checks/chat-dock-phone.cjs
new file mode 100644
index 000000000..a955fd9a5
--- /dev/null
+++ b/e2e/checks/chat-dock-phone.cjs
@@ -0,0 +1,41 @@
+// The chat dock at phone width: the bar and the open conversation fit the
+// screen on a few pages, a stored desktop pin is ignored, the composer stays
+// reachable, and the dock adds no sideways scroll. The page's own overflow is
+// phone-overflow's to report, so the dock is measured against the page
+// without it.
+const assert = require('node:assert/strict');
+const h = require('./helpers/chat-dock.cjs');
+
+module.exports = async ({ page, go, shot, tolerate }) => {
+ tolerate(/extensions\/catalogue/);
+ await page.setViewportSize({ width: 390, height: 844 });
+ const fits = async (label) => {
+ const { scroll, bare, inner } = await page.evaluate(() => {
+ const root = document.querySelector('aside[aria-label="Chat with Archie"]').parentElement;
+ const scroll = document.documentElement.scrollWidth;
+ root.style.display = 'none';
+ const bare = document.documentElement.scrollWidth;
+ root.style.display = '';
+ return { scroll, bare, inner: window.innerWidth };
+ });
+ assert.ok(scroll <= Math.max(bare, inner), `${label}: the dock widens the page (${scroll} > ${Math.max(bare, inner)})`);
+ const box = await h.dockOf(page).boundingBox();
+ assert.ok(box.x >= 0 && box.x + box.width <= inner, `${label}: dock leaves the screen (${box.x}..${box.x + box.width})`);
+ assert.ok(box.y >= 0 && box.y + box.height <= 844, `${label}: dock leaves the screen vertically`);
+ };
+
+ for (const path of ['/events', '/account', '/org/agents']) {
+ await h.load(page, go, JSON.stringify({ side: 'right', width: 420 }));
+ await go(path);
+ await fits(`${path} collapsed`);
+ await h.expand(page);
+ await fits(`${path} open`);
+ assert.equal(await page.evaluate(() => document.documentElement.style.getPropertyValue('--chat-pin-r')), '0px', `${path}: the page reserved room for a pin on a phone`);
+ const composer = await h.composerOf(page).boundingBox();
+ assert.ok(composer.y + composer.height <= 844 && composer.x >= 0 && composer.x + composer.width <= 390, `${path}: composer is off screen`);
+ assert.equal(await h.dividerOf(page).count(), 0, `${path}: a phone shows the pin divider`);
+ await h.composerOf(page).fill('A long unbroken line '.repeat(20));
+ await fits(`${path} long draft`);
+ await shot(path);
+ }
+};
diff --git a/e2e/checks/chat-dock-picker.cjs b/e2e/checks/chat-dock-picker.cjs
new file mode 100644
index 000000000..8e0460477
--- /dev/null
+++ b/e2e/checks/chat-dock-picker.cjs
@@ -0,0 +1,59 @@
+// The # task picker by keyboard: arrows move the selection and wrap, Enter
+// attaches the selected task, Escape closes the picker and leaves the
+// conversation open, and an IME confirmation Enter never picks.
+const assert = require('node:assert/strict');
+const h = require('./helpers/chat-dock.cjs');
+
+const tasks = [
+ { id: 1861, title: 'Task picker', status: 'running' },
+ { id: 1842, title: 'Retry stalled task runs', status: 'done' },
+ { id: 1830, title: 'Filter forge text', status: 'queued' },
+];
+
+module.exports = async ({ page, go, shot }) => {
+ await page.route('**/api/tasks?*', (route) => route.fulfill({ contentType: 'application/json', body: JSON.stringify(tasks) }));
+ await h.load(page, go);
+ await h.expand(page);
+ const composer = h.composerOf(page);
+ const palette = page.getByRole('listbox', { name: 'Tasks' });
+ const options = palette.getByRole('option');
+ const selected = () => options.evaluateAll((els) => els.findIndex((el) => el.getAttribute('aria-selected') === 'true'));
+ const tags = page.getByRole('list', { name: 'Attached tasks' });
+
+ await composer.fill('Look at #');
+ await options.first().waitFor();
+ assert.equal(await options.count(), 3);
+ assert.equal(await selected(), 0);
+ await shot('picker');
+
+ await composer.press('ArrowDown');
+ assert.equal(await selected(), 1);
+ assert.equal(await composer.getAttribute('aria-activedescendant'), 'slash-palette-option-1');
+ await composer.press('ArrowUp');
+ await composer.press('ArrowUp');
+ assert.equal(await selected(), 2, 'ArrowUp from the first row did not wrap to the last');
+ await composer.press('ArrowDown');
+ assert.equal(await selected(), 0, 'ArrowDown from the last row did not wrap to the first');
+ await composer.press('ArrowDown');
+
+ for (const event of [{ isComposing: true }, { keyCode: 229 }]) {
+ await composer.dispatchEvent('keydown', { key: 'Enter', bubbles: true, cancelable: true, ...event });
+ assert.equal(await options.count(), 3, 'an IME confirmation closed the picker');
+ assert.equal(await tags.count(), 0, 'an IME confirmation attached a task');
+ }
+
+ await composer.press('Enter');
+ await palette.waitFor({ state: 'hidden' });
+ await tags.getByText('#1842').waitFor();
+ assert.equal(await tags.getByRole('listitem').count(), 1);
+ assert.equal(await composer.inputValue(), 'Look at ', 'the # token stayed in the text');
+ assert.ok(await composer.evaluate((el) => document.activeElement === el), 'focus left the composer');
+
+ await composer.fill('Look at #');
+ await options.first().waitFor();
+ await composer.press('Escape');
+ await palette.waitFor({ state: 'hidden' });
+ assert.equal(await h.hideOf(page).isVisible(), true, 'Escape on the picker also closed the conversation');
+ await composer.press('Escape');
+ await h.hideOf(page).waitFor({ state: 'hidden' });
+};
diff --git a/e2e/checks/chat-dock-pin.cjs b/e2e/checks/chat-dock-pin.cjs
new file mode 100644
index 000000000..797069c82
--- /dev/null
+++ b/e2e/checks/chat-dock-pin.cjs
@@ -0,0 +1,52 @@
+// Pinning the chat dock: dragging its header to an edge pins it there and the
+// page reflows beside it; double-clicking the header unpins it; hiding the
+// conversation gives the page back its width; the choice survives a reload.
+const assert = require('node:assert/strict');
+const h = require('./helpers/chat-dock.cjs');
+
+module.exports = async ({ page, go, shot }) => {
+ await h.load(page, go);
+ await h.expand(page);
+ const dock = h.dockOf(page);
+ const free = await h.mainRect(page);
+ const floating = await dock.boundingBox();
+ assert.ok(floating.height < 900, 'the dock starts as a floating card');
+
+ await h.dragTo(page, 1430);
+ await page.mouse.up();
+ await h.until(async () => (await h.saved(page)).side === 'right', 'dragging to the right edge did not pin right');
+ const right = await dock.boundingBox();
+ h.near(right.x + right.width, 1440, 'right pin touches the right edge');
+ h.near(right.height, 900, 'a pinned dock is full height');
+ const reflowed = await h.mainRect(page);
+ assert.ok(reflowed.x + reflowed.width <= right.x + 1, `page content runs under the pinned dock: ${reflowed.x + reflowed.width} > ${right.x}`);
+ assert.ok(reflowed.width < free.width, 'the page did not give up any width');
+ assert.ok(await page.evaluate(() => document.documentElement.scrollWidth <= window.innerWidth), 'pinning made the page scroll sideways');
+ await shot('pinned-right');
+
+ await page.reload();
+ await h.expand(page);
+ await h.until(async () => Math.abs((await dock.boundingBox()).x - right.x) <= 1, 'the right pin did not survive a reload');
+
+ await h.hideOf(page).click();
+ await h.until(async () => Math.abs((await h.mainRect(page)).width - free.width) <= 1, 'hiding the conversation kept the page narrowed');
+ await h.expand(page);
+ await h.until(async () => Math.abs((await dock.boundingBox()).x - right.x) <= 1, 'reopening did not restore the pin');
+
+ const strip = await h.grip(page);
+ await page.mouse.dblclick(strip.x, strip.y);
+ await h.until(async () => (await h.saved(page)).side === null, 'double-clicking the header did not unpin');
+ assert.ok((await dock.boundingBox()).height < 900, 'an unpinned dock is a floating card again');
+ h.near((await h.mainRect(page)).width, free.width, 'the page returns to its full width');
+
+ await h.dragTo(page, 10);
+ await page.mouse.up();
+ await h.until(async () => (await h.saved(page)).side === 'left', 'dragging to the left edge did not pin left');
+ const left = await dock.boundingBox();
+ h.near(left.x, 0, 'left pin touches the left edge');
+ assert.ok((await h.mainRect(page)).x >= left.x + left.width - 1, 'page content runs under the left-pinned dock');
+ await shot('pinned-left');
+
+ await page.mouse.dblclick((await h.grip(page)).x, (await h.grip(page)).y);
+ await h.until(async () => (await h.saved(page)).side === null, 'double-clicking did not unpin the left pin');
+};
diff --git a/e2e/checks/chat-dock-resize.cjs b/e2e/checks/chat-dock-resize.cjs
new file mode 100644
index 000000000..958e31a2d
--- /dev/null
+++ b/e2e/checks/chat-dock-resize.cjs
@@ -0,0 +1,37 @@
+// The pinned dock's divider is a keyboard separator: the arrow toward the
+// page widens the dock, the arrow away narrows it, both stop at the allowed
+// range, and the width is saved.
+const assert = require('node:assert/strict');
+const h = require('./helpers/chat-dock.cjs');
+
+const width = (page) => h.dockOf(page).boundingBox().then((b) => Math.round(b.width));
+const value = (page) => h.dividerOf(page).getAttribute('aria-valuenow').then(Number);
+
+module.exports = async ({ page, go }) => {
+ const divider = h.dividerOf(page);
+ for (const [side, grow, shrink] of [['right', 'ArrowLeft', 'ArrowRight'], ['left', 'ArrowRight', 'ArrowLeft']]) {
+ await h.load(page, go, JSON.stringify({ side, width: 420 }));
+ await h.expand(page);
+ await divider.focus();
+ assert.equal(await value(page), 420);
+ assert.equal(await divider.getAttribute('aria-valuemin'), '320');
+
+ await page.keyboard.press(grow);
+ await h.until(async () => (await value(page)) === 436 && (await width(page)) === 436, `${side}: ${grow} did not widen by 16`);
+ await page.keyboard.press(shrink);
+ await page.keyboard.press(shrink);
+ await h.until(async () => (await value(page)) === 404 && (await width(page)) === 404, `${side}: ${shrink} did not narrow by 16`);
+ assert.equal((await h.saved(page)).width, 404, `${side}: the width was not saved`);
+
+ await page.keyboard.press('ArrowUp');
+ assert.equal(await value(page), 404, `${side}: a vertical arrow resized the dock`);
+
+ for (let i = 0; i < 12; i++) await page.keyboard.press(shrink);
+ await h.until(async () => (await width(page)) === 320, `${side}: the dock narrowed past its minimum`);
+ assert.equal(await value(page), 320);
+
+ for (let i = 0; i < 30; i++) await page.keyboard.press(grow);
+ await h.until(async () => (await width(page)) === 720, `${side}: the dock widened past its maximum`);
+ assert.equal(await value(page), 720);
+ }
+};
diff --git a/e2e/checks/helpers/chat-dock.cjs b/e2e/checks/helpers/chat-dock.cjs
new file mode 100644
index 000000000..e21b3154a
--- /dev/null
+++ b/e2e/checks/helpers/chat-dock.cjs
@@ -0,0 +1,63 @@
+// Shared handles for the chat dock checks: the dock's own storage key, its
+// landmarks, and the pointer gestures that pin it.
+const assert = require('node:assert/strict');
+
+const KEY = 'archie.chat.dock';
+
+const dockOf = (page) => page.getByRole('complementary', { name: 'Chat with Archie' });
+const composerOf = (page) => page.getByRole('combobox', { name: 'Message Archie', exact: true });
+const hideOf = (page) => page.getByRole('button', { name: 'Hide conversation' });
+const dividerOf = (page) => page.getByRole('separator', { name: 'Resize chat' });
+
+const stored = (page) => page.evaluate((key) => localStorage.getItem(key), KEY);
+const saved = async (page) => JSON.parse(await stored(page));
+
+// Loads /events with the given stored layout (a string, or null for none).
+async function load(page, go, layout = null) {
+ await go('/events');
+ await page.evaluate(([key, value]) => (value === null ? localStorage.removeItem(key) : localStorage.setItem(key, value)), [KEY, layout]);
+ await go('/events');
+}
+
+// Focusing the composer is how the operator opens the conversation.
+async function expand(page) {
+ await composerOf(page).focus();
+ await hideOf(page).waitFor();
+}
+
+// Retries an assertion until it holds: the dock settles over a few frames.
+async function until(check, message, timeout = 5000) {
+ const end = Date.now() + timeout;
+ let last;
+ for (;;) {
+ try {
+ const ok = await check();
+ if (ok) return;
+ last = ok;
+ } catch (e) {
+ last = e;
+ }
+ if (Date.now() > end) throw new Error(`${message}${last instanceof Error ? `: ${last.message}` : ''}`);
+ await new Promise((r) => setTimeout(r, 50));
+ }
+}
+
+const near = (a, b, message, tolerance = 1) => assert.ok(Math.abs(a - b) <= tolerance, `${message}: ${a} is not within ${tolerance} of ${b}`);
+
+// The empty strip at the top of the header, where a drag starts.
+async function grip(page) {
+ const box = await dockOf(page).boundingBox();
+ return { x: box.x + box.width / 2, y: box.y + 8 };
+}
+
+async function dragTo(page, x, steps = 10) {
+ const from = await grip(page);
+ await page.mouse.move(from.x, from.y);
+ await page.mouse.down();
+ await page.mouse.move(x, from.y, { steps });
+ return from;
+}
+
+const mainRect = (page) => page.locator('#main-content').boundingBox();
+
+module.exports = { KEY, dockOf, composerOf, hideOf, dividerOf, stored, saved, load, expand, until, near, grip, dragTo, mainRect };
diff --git a/internal/webui/chat.go b/internal/webui/chat.go
index 8fc81ac99..cf8ab74b6 100644
--- a/internal/webui/chat.go
+++ b/internal/webui/chat.go
@@ -5,6 +5,7 @@ import (
"encoding/json"
"errors"
"fmt"
+ "log/slog"
"net/http"
"path/filepath"
"strings"
@@ -141,6 +142,7 @@ type chatToolView struct {
// waiting for the browser's answer and files a turn offered for download.
type chatAPI struct {
chat *ChatService
+ log *slog.Logger
updateReportPath string
configSource func() ConfigViewSource
@@ -149,7 +151,7 @@ type chatAPI struct {
}
func newChatAPI(s *Server) *chatAPI {
- return &chatAPI{chat: s.Chat, updateReportPath: s.UpdateReportPath, configSource: s.configSource}
+ return &chatAPI{chat: s.Chat, log: s.Log, updateReportPath: s.UpdateReportPath, configSource: s.configSource}
}
func (a *chatAPI) register(mux *http.ServeMux) {
@@ -173,6 +175,21 @@ func (a *chatAPI) chatReady(w http.ResponseWriter) (*ChatService, bool) {
return a.chat, true
}
+// chatFailureText is what the browser sees when a chat backend call fails.
+// The cause can carry SQL, gRPC status details or host paths, so failChat
+// logs it server-side and sends this sentence instead, in the same plain
+// wording the gateway gives chat readers for a failed turn.
+const chatFailureText = "something went wrong on Archie's side. Try again; the server log has the cause."
+
+// failChat logs the real cause with the request's trace and answers with the
+// plain sentence. A nil logger is tolerated, as tests build servers without one.
+func (a *chatAPI) failChat(ctx context.Context, w http.ResponseWriter, status int, err error) {
+ if a.log != nil {
+ a.log.ErrorContext(ctx, "chat endpoint failed", "error", err, "status", status)
+ }
+ http.Error(w, chatFailureText, status)
+}
+
func chatUpdateServiceConfigured(updates ChatUpdateService) bool {
return !lifecycle.IsNil(updates)
}
@@ -184,7 +201,7 @@ func (a *chatAPI) handleChatSessions(w http.ResponseWriter, r *http.Request) {
}
snapshot, err := chat.Contract.Snapshot(r.Context())
if err != nil {
- http.Error(w, err.Error(), http.StatusInternalServerError)
+ a.failChat(r.Context(), w, http.StatusInternalServerError, err)
return
}
out := make([]messaging.SessionContext, 0, len(snapshot.Sessions))
@@ -218,7 +235,7 @@ func (a *chatAPI) handleChatMessages(w http.ResponseWriter, r *http.Request) {
sessionID := r.PathValue("id")
session, found, err := chat.Contract.GetSession(r.Context(), sessionID)
if err != nil {
- http.Error(w, err.Error(), http.StatusInternalServerError)
+ a.failChat(r.Context(), w, http.StatusInternalServerError, err)
return
}
if !found || !a.ownsChatSession(r.Context(), session) {
@@ -227,7 +244,7 @@ func (a *chatAPI) handleChatMessages(w http.ResponseWriter, r *http.Request) {
}
messages, err := chat.Contract.RecentMessages(r.Context(), sessionID, 200)
if err != nil {
- http.Error(w, err.Error(), http.StatusInternalServerError)
+ a.failChat(r.Context(), w, http.StatusInternalServerError, err)
return
}
views := make([]chatMessageView, 0, len(messages))
@@ -249,7 +266,7 @@ func (a *chatAPI) handleChatTurns(w http.ResponseWriter, r *http.Request) {
sessionID := r.PathValue("id")
session, found, err := chat.Contract.GetSession(r.Context(), sessionID)
if err != nil {
- http.Error(w, err.Error(), http.StatusInternalServerError)
+ a.failChat(r.Context(), w, http.StatusInternalServerError, err)
return
}
if !found || !a.ownsChatSession(r.Context(), session) {
@@ -258,7 +275,7 @@ func (a *chatAPI) handleChatTurns(w http.ResponseWriter, r *http.Request) {
}
turns, err := chat.Contract.RecentTurns(r.Context(), sessionID, 200)
if err != nil {
- http.Error(w, err.Error(), http.StatusInternalServerError)
+ a.failChat(r.Context(), w, http.StatusInternalServerError, err)
return
}
views := make([]chatTurnView, 0, len(turns))
@@ -475,7 +492,7 @@ func (a *chatAPI) handleChatStream(w http.ResponseWriter, r *http.Request) {
asker := dashboardAsker{asks: &a.asks, write: func(frame chatStreamEvent) { writeChatEvent(frame, "") }}
events, err := chat.Contract.Stream(withDashboardAsks(r.Context(), asker), msg)
if err != nil {
- writeChatEvent(chatStreamEvent{Type: "error", Text: err.Error()}, "")
+ a.failChatStream(r.Context(), writeChatEvent, err)
return
}
sink := chatStreamSink{showToolCalls: a.chatShowToolCalls(r.Context()), files: &a.files, owner: chatUser(r.Context())}
@@ -492,6 +509,15 @@ func (a *chatAPI) handleChatStream(w http.ResponseWriter, r *http.Request) {
}
}
+// failChatStream answers a stream that never opened with the plain sentence
+// as its error frame, logging the real cause server-side.
+func (a *chatAPI) failChatStream(ctx context.Context, write func(chatStreamEvent, string), err error) {
+ if a.log != nil {
+ a.log.ErrorContext(ctx, "chat stream failed to start", "error", err)
+ }
+ write(chatStreamEvent{Type: "error", Text: chatFailureText}, "")
+}
+
func (a *chatAPI) handleChatCancel(w http.ResponseWriter, r *http.Request) {
chat, ok := a.chatReady(w)
if !ok {
@@ -499,7 +525,7 @@ func (a *chatAPI) handleChatCancel(w http.ResponseWriter, r *http.Request) {
}
snapshot, err := chat.Contract.Snapshot(r.Context())
if err != nil {
- http.Error(w, err.Error(), http.StatusInternalServerError)
+ a.failChat(r.Context(), w, http.StatusInternalServerError, err)
return
}
if !snapshot.CancellationAvailable {
@@ -513,7 +539,7 @@ func (a *chatAPI) handleChatCancel(w http.ResponseWriter, r *http.Request) {
}
session, found, err := chat.Contract.GetSession(r.Context(), req.SessionID)
if err != nil {
- http.Error(w, err.Error(), http.StatusInternalServerError)
+ a.failChat(r.Context(), w, http.StatusInternalServerError, err)
return
}
if !found || !a.ownsChatSession(r.Context(), session) {
@@ -522,7 +548,7 @@ func (a *chatAPI) handleChatCancel(w http.ResponseWriter, r *http.Request) {
}
result, err := chat.Contract.Cancel(r.Context(), req.SessionID)
if err != nil {
- http.Error(w, err.Error(), http.StatusInternalServerError)
+ a.failChat(r.Context(), w, http.StatusInternalServerError, err)
return
}
writeJSON(w, map[string]any{"cancelled": result.Cancelled, "dropped": result.Dropped})
@@ -538,6 +564,17 @@ func writeUpdateCheckError(w http.ResponseWriter, err error) {
http.Error(w, err.Error(), http.StatusBadGateway)
}
+// failUpdateCheck is the chat endpoints' version of writeUpdateCheckError: any
+// other cause can carry registry URLs or host paths, so it gets the plain
+// sentence and the log rather than the raw error.
+func (a *chatAPI) failUpdateCheck(ctx context.Context, w http.ResponseWriter, err error) {
+ if errors.Is(err, releaseupdate.ErrNotConfigured) {
+ http.Error(w, "updates are not configured", http.StatusNotImplemented)
+ return
+ }
+ a.failChat(ctx, w, http.StatusBadGateway, err)
+}
+
func (a *chatAPI) handleChatUpdate(w http.ResponseWriter, r *http.Request) {
chat, ok := a.chatReady(w)
if !ok {
@@ -549,7 +586,7 @@ func (a *chatAPI) handleChatUpdate(w http.ResponseWriter, r *http.Request) {
}
snapshot, err := chat.Updates.Check(r.Context(), 0)
if err != nil {
- writeUpdateCheckError(w, err)
+ a.failUpdateCheck(r.Context(), w, err)
return
}
// The snapshot carries when the installed release was committed on this
@@ -586,7 +623,7 @@ func (a *chatAPI) handleChatUpdateDefer(w http.ResponseWriter, r *http.Request)
return
}
if err := chat.Updates.Defer(r.Context(), 0, req.Snapshot); err != nil {
- http.Error(w, err.Error(), http.StatusConflict)
+ a.failChat(r.Context(), w, http.StatusConflict, err)
return
}
writeJSON(w, map[string]bool{"ok": true})
@@ -608,7 +645,7 @@ func (a *chatAPI) handleChatUpdateInstall(w http.ResponseWriter, r *http.Request
}
fresh, err := chat.Updates.Check(r.Context(), 0)
if err != nil {
- writeUpdateCheckError(w, err)
+ a.failUpdateCheck(r.Context(), w, err)
return
}
if !releaseupdate.SameAvailable(fresh, req.Snapshot) {
@@ -633,7 +670,7 @@ func (a *chatAPI) handleChatUpdateInstall(w http.ResponseWriter, r *http.Request
meta := releaseupdate.InstallMeta{Channel: "webui", ReportPath: a.updateReportPath}
result, err := chat.Updates.Install(r.Context(), fresh, meta, func(message string) { progress = append(progress, message) })
if err != nil {
- http.Error(w, err.Error(), http.StatusBadGateway)
+ a.failChat(r.Context(), w, http.StatusBadGateway, err)
return
}
writeJSON(w, map[string]any{"ok": true, "progress": progress, "result": result})
diff --git a/internal/webui/chat_errors_test.go b/internal/webui/chat_errors_test.go
new file mode 100644
index 000000000..f82d44dd7
--- /dev/null
+++ b/internal/webui/chat_errors_test.go
@@ -0,0 +1,202 @@
+package webui
+
+import (
+ "bytes"
+ "context"
+ "errors"
+ "log/slog"
+ "net/http"
+ "net/http/httptest"
+ "strings"
+ "testing"
+
+ "github.com/samcharles93/archie-core/internal/domain/identity"
+ "github.com/samcharles93/archie-core/internal/domain/messaging"
+ "github.com/samcharles93/archie-core/internal/releaseupdate"
+)
+
+// internalDetail stands in for the SQL fragments, gRPC status details and host
+// paths a real contract failure carries; none of it may reach the browser.
+const internalDetail = `pq: relation "chat_messages" does not exist: SELECT * FROM chat_messages WHERE session_id=$1 (/var/lib/archie/state.db): rpc error: code = Internal desc = session store unavailable`
+
+var errInternal = errors.New(internalDetail)
+
+// plainChatFailure is the sentence the browser must see instead; spelled out
+// here so the test also compiles, and fails, against the unsanitised handlers.
+const plainChatFailure = "something went wrong on Archie's side. Try again; the server log has the cause."
+
+// failingChat fails the contract methods its fields name, so one fake covers
+// every chat endpoint.
+type failingChat struct {
+ messaging.ChatContract
+ snapshotErr, sessionErr, messagesErr, turnsErr, cancelErr, streamErr error
+}
+
+func (f failingChat) Snapshot(context.Context) (messaging.ChatSnapshot, error) {
+ if f.snapshotErr != nil {
+ return messaging.ChatSnapshot{}, f.snapshotErr
+ }
+ return messaging.ChatSnapshot{CancellationAvailable: true}, nil
+}
+
+func (f failingChat) GetSession(context.Context, string) (messaging.SessionContext, bool, error) {
+ if f.sessionErr != nil {
+ return messaging.SessionContext{}, false, f.sessionErr
+ }
+ return messaging.SessionContext{SessionID: "s1", Source: messaging.SessionSource{Platform: "web", ThreadID: "alice"}}, true, nil
+}
+
+func (f failingChat) RecentMessages(context.Context, string, int) ([]messaging.Message, error) {
+ if f.messagesErr != nil {
+ return nil, f.messagesErr
+ }
+ return []messaging.Message{}, nil
+}
+
+func (f failingChat) RecentTurns(context.Context, string, int) ([]messaging.TurnRecord, error) {
+ if f.turnsErr != nil {
+ return nil, f.turnsErr
+ }
+ return []messaging.TurnRecord{}, nil
+}
+
+func (f failingChat) Stream(context.Context, messaging.Inbound) (<-chan messaging.ChatEvent, error) {
+ return nil, f.streamErr
+}
+
+func (f failingChat) Cancel(context.Context, string) (messaging.ChatCancellation, error) {
+ if f.cancelErr != nil {
+ return messaging.ChatCancellation{}, f.cancelErr
+ }
+ return messaging.ChatCancellation{Cancelled: true}, nil
+}
+
+type failingUpdates struct {
+ ChatUpdateService
+ err error
+}
+
+func (f failingUpdates) Check(context.Context, int64) (releaseupdate.Snapshot, error) {
+ return releaseupdate.Snapshot{}, f.err
+}
+
+func chatErrorRequest(t *testing.T, method, target, body string) *http.Request {
+ t.Helper()
+ ctx := WithActingIdentity(t.Context(), identity.Identity{ID: identity.IdentityID("alice")})
+ req := httptest.NewRequestWithContext(ctx, method, target, strings.NewReader(body))
+ req.SetPathValue("id", "s1")
+ return req
+}
+
+func assertSanitised(t *testing.T, body, log string) {
+ t.Helper()
+ if strings.Contains(body, internalDetail) {
+ t.Errorf("response leaks the internal error: %s", body)
+ }
+ for _, fragment := range []string{"pq:", "chat_messages", "/var/lib", "rpc error"} {
+ if strings.Contains(body, fragment) {
+ t.Errorf("response leaks internal fragment %q: %s", fragment, body)
+ }
+ }
+ if !strings.Contains(body, plainChatFailure) {
+ t.Errorf("response is missing the plain message, got: %s", body)
+ }
+ if !strings.Contains(log, "session store unavailable") {
+ t.Errorf("the real error was not logged server-side, log: %s", log)
+ }
+}
+
+func TestChatEndpointErrorsAreSanitised(t *testing.T) {
+ for _, tc := range []struct {
+ name string
+ contract failingChat
+ handler func(*chatAPI, http.ResponseWriter, *http.Request)
+ body string
+ wantStatus int
+ }{
+ {"sessions snapshot", failingChat{snapshotErr: errInternal}, (*chatAPI).handleChatSessions, "", http.StatusInternalServerError},
+ {"messages session lookup", failingChat{sessionErr: errInternal}, (*chatAPI).handleChatMessages, "", http.StatusInternalServerError},
+ {"messages history", failingChat{messagesErr: errInternal}, (*chatAPI).handleChatMessages, "", http.StatusInternalServerError},
+ {"turns session lookup", failingChat{sessionErr: errInternal}, (*chatAPI).handleChatTurns, "", http.StatusInternalServerError},
+ {"turns history", failingChat{turnsErr: errInternal}, (*chatAPI).handleChatTurns, "", http.StatusInternalServerError},
+ {"cancel snapshot", failingChat{snapshotErr: errInternal}, (*chatAPI).handleChatCancel, `{"session_id":"s1"}`, http.StatusInternalServerError},
+ {"cancel session lookup", failingChat{sessionErr: errInternal}, (*chatAPI).handleChatCancel, `{"session_id":"s1"}`, http.StatusInternalServerError},
+ {"cancel call", failingChat{cancelErr: errInternal}, (*chatAPI).handleChatCancel, `{"session_id":"s1"}`, http.StatusInternalServerError},
+ } {
+ t.Run(tc.name, func(t *testing.T) {
+ var logBuf bytes.Buffer
+ srv := &Server{Log: slog.New(slog.NewTextHandler(&logBuf, nil)), Chat: &ChatService{Contract: tc.contract}}
+ rec := httptest.NewRecorder()
+ tc.handler(newChatAPI(srv), rec, chatErrorRequest(t, "POST", "https://archie.example/api/chat/x", tc.body))
+ if rec.Code != tc.wantStatus {
+ t.Fatalf("status=%d want=%d body=%s", rec.Code, tc.wantStatus, rec.Body.String())
+ }
+ assertSanitised(t, rec.Body.String(), logBuf.String())
+ })
+ }
+}
+
+func TestChatStreamErrorFrameIsSanitised(t *testing.T) {
+ var logBuf bytes.Buffer
+ srv := &Server{Log: slog.New(slog.NewTextHandler(&logBuf, nil)), Chat: &ChatService{Contract: failingChat{streamErr: errInternal}}}
+ rec := httptest.NewRecorder()
+ req := chatErrorRequest(t, "POST", "https://archie.example/api/chat/stream", `{"channel_id":"c","text":"hi"}`)
+ newChatAPI(srv).handleChatStream(rec, req)
+ body := rec.Body.String()
+ if !strings.Contains(body, `"type":"error"`) {
+ t.Fatalf("no error frame in stream: %s", body)
+ }
+ assertSanitised(t, body, logBuf.String())
+}
+
+func TestChatUpdateCheckErrorIsSanitised(t *testing.T) {
+ for _, tc := range []struct {
+ name string
+ err error
+ wantStatus int
+ wantBody string
+ }{
+ {"internal cause", errInternal, http.StatusBadGateway, plainChatFailure},
+ {"not configured", releaseupdate.ErrNotConfigured, http.StatusNotImplemented, "updates are not configured"},
+ } {
+ t.Run(tc.name, func(t *testing.T) {
+ var logBuf bytes.Buffer
+ srv := &Server{Log: slog.New(slog.NewTextHandler(&logBuf, nil)), Chat: &ChatService{Contract: failingChat{}, Updates: failingUpdates{err: tc.err}}}
+ rec := httptest.NewRecorder()
+ newChatAPI(srv).handleChatUpdate(rec, chatErrorRequest(t, "GET", "https://archie.example/api/chat/update", ""))
+ if rec.Code != tc.wantStatus {
+ t.Fatalf("status=%d want=%d body=%s", rec.Code, tc.wantStatus, rec.Body.String())
+ }
+ if got := strings.TrimSpace(rec.Body.String()); got != tc.wantBody {
+ t.Fatalf("body=%q want=%q", got, tc.wantBody)
+ }
+ if errors.Is(tc.err, errInternal) {
+ assertSanitised(t, rec.Body.String(), logBuf.String())
+ }
+ })
+ }
+}
+
+func TestChatValidationMessagesStayUserFacing(t *testing.T) {
+ for _, tc := range []struct {
+ name, body, want string
+ }{
+ {"missing fields", `{"channel_id":"","text":""}`, "text and channel_id are required"},
+ {"undecodable", `{`, "invalid chat message"},
+ {"empty voice", `{"channel_id":"c","text":"hi","voice":{"data":"","mime_type":"audio/ogg"}}`, "voice clip is empty or too long"},
+ } {
+ t.Run(tc.name, func(t *testing.T) {
+ rec := httptest.NewRecorder()
+ req := chatErrorRequest(t, "POST", "https://archie.example/api/chat/stream", tc.body)
+ if _, ok := newChatAPI(&Server{}).decodeChatMessage(rec, req); ok {
+ t.Fatal("message accepted")
+ }
+ if rec.Code != http.StatusBadRequest {
+ t.Fatalf("status=%d want=400", rec.Code)
+ }
+ if got := strings.TrimSpace(rec.Body.String()); got != tc.want {
+ t.Fatalf("body=%q want=%q", got, tc.want)
+ }
+ })
+ }
+}
diff --git a/ui/src/App.vue b/ui/src/App.vue
index e145e9dab..0c2fd567a 100644
--- a/ui/src/App.vue
+++ b/ui/src/App.vue
@@ -116,7 +116,7 @@ watch(() => accounts.status?.user, (user) => {