Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar.
gui: a page wheeled right after a click that redraws scrolls on macOS 13's WebKit (issennknight on Discord)
yetonef92db4cdd07e
diff --git a/docs/subsystems/gui-shell.md b/docs/subsystems/gui-shell.mdindex 7cf7e1467..eb4e07e23 100644--- a/docs/subsystems/gui-shell.md+++ b/docs/subsystems/gui-shell.md@@ -375,7 +375,7 @@ covers it in both engines, every language and a narrow window.- Settings' Search APIs add row has a base URL field under the key for every API (#1580): the vendor's own address is its placeholder, picking an API already added fills in its saved URL so a new key alone keeps it, and Add with no key changes only the URL. See [a search API's base URL](gateway-routing.md#a-search-apis-base-url), [`renderSearch`](../../internal/gui/assets/app.js) and `search-api.test.cjs`.- Every user-visible string has zh, zh-TW, ja and de translations with the same placeholders. `gui-zh-tw.test.cjs`, `gui-ja.test.cjs` and `gui-de.test.cjs` fail on a missing one; `gui-zh-tw.test.cjs` also fails on a zh-TW string with a Simplified character left in it.- A click never moves the page. Code scrolls a view only with the reader's event in hand (`scrollOnPurpose`); `click-scroll.test.cjs` guards this. A click is taken where the reader left the view: a scroll not theirs made just before it, whose scroll event the browser sends only at the next frame, after the click, is put back first (`backToReader` in the click guard, #1554). What was clicked is held where it was (`hold`); a view at its top when clicked stays at its top, and what comes in above the control moves it down instead (#2134, `update-auto.test.cjs`), as long as it moves less than half its own height and so stays under the pointer. When what the click does leaves the page shorter under it (a list emptied), the view keeps room at its foot for it to stay (`.view-room`), room that goes as the reader scrolls back. A control under what it unrolls (`data-unrolls`, "Show 7 more") goes down with what it opens: what's held is the part it is in, so the rows open downwards. Anything larger above it, as the stage a day picked on Routing brings in above the bar, is scrolled past, and the control stays where it was clicked (`routing-days-fit.test.cjs`, `routing-failed-open.test.cjs`).-- A scroll not the reader's is put back, so every way the reader scrolls has to count as theirs: the wheel and a trackpad's coast after the lift (WebKit on the Mac plays the coast itself and the page hears its scrolls with no wheel for each, so the wheel starts the same chain a touch fling does, `flings`/`flingUntil`: each scroll keeps the next one the reader's till it rests, and a click ends it; issenn on Discord, `view-trackpad-coast.test.cjs`), a wheel or coast the page is never told of (macOS 13's WebKit, Safari 16.6's, scrolled a view under wheels it never dispatched, so every scroll was put back and only the bar's drag moved the page: three scrolls put back the same way within a second are taken as the reader's run and given back, and so is each one after it that goes on the same way within a second of the last, so a wheel turned slowly or on a loaded Mac loses no step; a scroll by code is one, not a run, and two at rest are still put back; issenn on Discord, `view-wheel-unheard.test.cjs`. Under a click's 4s hold the same holds: only a put-back that comes with the page redrawn since the hold last held (`redrawn`: the view's height or where the first held parts sit moved from `h.lay`) is the hold's and never counts toward a run, so a profile opened on the Agents page and wheeled through at once scrolls, issennknight on Discord, `view-wheel-after-click.test.cjs`), a touch and its fling, the keys, a drag, the scrollbar's own drag (`barDrag`, #1089) and the middle button's autoscroll (`panning`, 多喝热水 on Discord). Chromium and WebView2 give the autoscroll a press of button 1 and then no event of the reader's while it scrolls; from that press the view follows it till Chromium ends it, on the next press (which reaches the page only as a pointerup), a key (a keyup), or the lift after the mouse moved while held. A field the guard brings back into view after putting a scroll back is one focused since the reader last scrolled that view, not one they scrolled away from (`scrolledFrom`): the middle press focuses the button under it. See `view-middle-autoscroll.test.cjs`.+- A scroll not the reader's is put back, so every way the reader scrolls has to count as theirs: the wheel and a trackpad's coast after the lift (WebKit on the Mac plays the coast itself and the page hears its scrolls with no wheel for each, so the wheel starts the same chain a touch fling does, `flings`/`flingUntil`: each scroll keeps the next one the reader's till it rests, and a click ends it; issenn on Discord, `view-trackpad-coast.test.cjs`), a wheel or coast the page is never told of (macOS 13's WebKit, Safari 16.6's, scrolled a view under wheels it never dispatched, so every scroll was put back and only the bar's drag moved the page: three scrolls put back the same way within a second are taken as the reader's run and given back, and so is each one after it that goes on the same way within a second of the last, so a wheel turned slowly or on a loaded Mac loses no step; a scroll by code is one, not a run, and two at rest are still put back; issenn on Discord, `view-wheel-unheard.test.cjs`. Under a click's 4s hold the same holds: only a put-back that comes with the page redrawn since the hold last held (`redrawn`: the view's height or where the first held parts sit moved from `h.lay`) is the hold's and never counts toward a run, so a profile opened on the Agents page and wheeled through at once scrolls, issennknight on Discord, `view-wheel-after-click.test.cjs`. The parts `h.lay` measures are those still in the page that scroll with it: a part drawn again since (the Usage page's tabs, the agents' list under an agent opened or closed) is a redraw once, not at every scroll, and a sticky one (Settings' tabs at a narrow width) is left out, as it sits still while the page scrolls; `view-wheel-after-redraw.test.cjs`), a touch and its fling, the keys, a drag, the scrollbar's own drag (`barDrag`, #1089) and the middle button's autoscroll (`panning`, 多喝热水 on Discord). Chromium and WebView2 give the autoscroll a press of button 1 and then no event of the reader's while it scrolls; from that press the view follows it till Chromium ends it, on the next press (which reaches the page only as a pointerup), a key (a keyup), or the lift after the mouse moved while held. A field the guard brings back into view after putting a scroll back is one focused since the reader last scrolled that view, not one they scrolled away from (`scrolledFrom`): the middle press focuses the button under it. See `view-middle-autoscroll.test.cjs`.- Typing never moves the page either. A textarea that grows with its text (the Library's `autosize` in plugins/library/client.js: a set's text, an agent's own text, a skill's description, a subagent's fields) is measured at height auto with what holds it kept at its height, so the page never goes short for a moment: a page gone short has its view's scroll clamped by the browser at every input, an input method's every composing step included, and the guard's putting it back pulled a textarea taller than the view to one of its edges (#2636, `library-ime-scroll.test.cjs`).- There are no native `<select>` elements and no colored left-border stripes. State is shown with a dot or a swatch.- What the window shows can be selected and copied, its controls can't, as in a Mac app (Outvi V on Discord: nothing could be copied into a bug report). The page is `user-select: none`, and two `:where()` rules after `body` in `app.css` make text content selectable (paragraphs, `pre` and `code`, a detail's values, hints and notes, every error class, a conversation, a request's story on Routing) and keep every control unselectable with what is in it (buttons, labels, tabs, menus, the navigation, grips). Both have no specificity, so a view's own rule still decides, as a list being sorted does; a field stays selectable. See `user-select.test.cjs`.diff --git a/internal/gui/assets/app.js b/internal/gui/assets/app.jsindex 0fb45bb46..08775fb27 100644--- a/internal/gui/assets/app.js+++ b/internal/gui/assets/app.js@@ -23264,9 +23264,18 @@ function standIn(h) {}}// where the held parts are in the page, and how tall it is: what the hold-// left (h.lay), and a redraw changes, a scroll not-const laid = (h) => [h.v.scrollHeight, ...h.chain.slice(0, 3).map(([n]) => n.isConnected ? onScreen(n, h.v) + h.v.scrollTop : NaN)];-const redrawn = (h) => !h.lay || laid(h).some((x, i) => !(Math.abs(x - h.lay[i]) < 1.5));+// left (h.lay), and a redraw changes, a scroll not. Only parts that scroll+// with the page and are in it: one drawn again (the Usage page's tabs, the+// agents' list under an agent opened or closed) or stuck to the view's edge+// (Settings' tabs, sticky) read as moved at every scroll, and for the hold's+// 4s every scroll was put back (issennknight on macOS 13)+const scrolls = (n, v) => { for (; n && n !== v; n = n.parentElement) if (/sticky|fixed/.test(getComputedStyle(n).position)) return false; return !!n; };+function laid(h) {+ const at = [];+ for (const [n] of h.chain) if (at.length < 3 && n.isConnected && n.offsetParent && scrolls(n, h.v)) at.push([n, onScreen(n, h.v) + h.v.scrollTop]);+ return { sh: h.v.scrollHeight, at };+}+const redrawn = (h) => !h.lay || Math.abs(h.v.scrollHeight - h.lay.sh) >= 1.5 || h.lay.at.some(([n, y]) => !n.isConnected || !(Math.abs(onScreen(n, h.v) + h.v.scrollTop - y) < 1.5));function hold(h) {// held by what can be seen: an empty part (a row's value with nothing in it// yet) has no height, so "moved by less than half its height" below neverdiff --git a/internal/gui/tests/view-wheel-after-redraw.test.cjs b/internal/gui/tests/view-wheel-after-redraw.test.cjsnew file mode 100644index 000000000..78c8366e8--- /dev/null+++ b/internal/gui/tests/view-wheel-after-redraw.test.cjs@@ -0,0 +1,160 @@+// Run with Node's test runner and Playwright on the module path; see README.md.+// issennknight on Discord (macOS 13, v0.1.1621), after view-wheel-after-click:+// the page still stood still and shook back under the wheel right after+// switching the Usage page's tabs (Overview, Requests, Sessions, Context),+// and after an agent's row on the Agents page was opened and then closed.+// macOS 13's WebKit scrolls a view under a wheel it never tells the page of,+// and the view guard gives such scrolls back as the reader's run unless a+// click's hold says the page was redrawn. Both clicks draw what was clicked+// again (the tabs, the agents' list), so the held parts were gone from the+// page, and a part gone read as moved at every scroll: for the hold's 4s+// every scroll was put back. A part that stays in place on the screen as+// the view scrolls (Settings' tabs, sticky at a narrow width) read the same.+// Here the wheel, unheard, goes on right after each such click: the page+// follows it down and back up, in every language, narrow and wide, in+// Chromium and WebKit.+const assert = require("node:assert/strict");+const fs = require("node:fs/promises");+const path = require("node:path");+const { test } = require("node:test");+const { chromium, webkit } = require("playwright");++const assets = process.env.MAGPIE_AFTER_REDRAW_ASSETS || path.resolve(__dirname, "../assets");+const LANGS = ["en", "zh", "zh-TW", "ja", "de"];+const model = (id) => ({ key: "model", label: "model", value: id, options: [{ value: id, label: id, ref: "relay/" + id, note: "Relay · via magpie" }] });+const AGENTS = Array.from({ length: 14 }, (_, i) => ({+ id: "a" + i, name: "Agent " + i, path: "/t/a" + i + ".json", icon: "generic", wired: true,+ fields: [model("m" + i), { key: "effort", label: "effort", value: "high", options: [{ value: "high", label: "High" }] }],+}));++function server(lang) {+ return async (route) => {+ const url = new URL(route.request().url());+ const json = (data) => route.fulfill({ json: data });+ if (url.pathname === "/boot.js") return route.fulfill({ contentType: "text/javascript", body: `window.bootPrefs = {lang:"${lang}",theme:"light",web:true};` });+ if (url.pathname === "/wails/runtime.js") return route.fulfill({ contentType: "text/javascript", body: "export const Window = {};" });+ if (url.pathname === "/api/state") return json({ agents: AGENTS, profiles: [], settings: { lang, theme: "light", guideHidden: true } });+ if (url.pathname === "/api/providers") return json({ providers: [], presets: [], excluded: [], gateway: { running: true, window: true } });+ if (url.pathname === "/api/gateway/trace") {+ if (url.searchParams.get("wait")) return new Promise(() => {});+ return json({ mine: true, now: new Date().toISOString(), seq: 0, totals: { requests: 0, rerouted: 0, errors: 0 }, routes: [] });+ }+ if (url.pathname === "/api/usage/quotas") return json([]);+ if (url.pathname === "/api/groups") return json({ groups: [], models: [] });+ if (url.pathname === "/api/plugins") return json({ plugins: [] });+ if (url.pathname === "/api/agents/cli") return json({ agents: {}, pending: false });+ if (url.pathname === "/api/window/fit") return route.fulfill({ status: 204 });+ if (url.pathname.startsWith("/api/")) return json({});+ const file = path.join(assets, url.pathname === "/" ? "index.html" : url.pathname);+ const contentType = { ".html": "text/html", ".js": "text/javascript", ".css": "text/css", ".svg": "image/svg+xml", ".png": "image/png" }[path.extname(file)];+ await route.fulfill({ body: await fs.readFile(file).catch(() => ""), contentType });+ };+}++// the view at rest: its scrollTop the same across a few looks+async function rested(p, view, ms = 3000) {+ let last = NaN, same = 0;+ const until = Date.now() + ms;+ while (Date.now() < until) {+ const t = await view.evaluate((v) => v.scrollTop);+ same = t === last ? same + 1 : 0;+ if (same >= 3) return t;+ last = t;+ await p.waitForTimeout(50);+ }+ return last;+}+const wheels = async (p, n, dy) => { for (let i = 0; i < n; i++) { await p.mouse.wheel(0, dy); await p.waitForTimeout(16); } };+// a page taller than the window whatever a pane draws: the test is about the+// scroll, not the figures. A pseudo-element, which no redraw takes out.+const tall = (view) => view.evaluate((v) => { const s = document.createElement("style"); s.textContent = `#${v.id}::after { content: ""; display: block; flex: none; height: 2400px; min-height: 2400px; }`; document.head.append(s); });+const DEAF = `addEventListener("wheel", (e) => e.stopImmediatePropagation(), { capture: true, passive: true });`;++// after the click, ten wheels down and ten back up go where the wheel takes them+async function follows(p, view, what) {+ const r = await view.boundingBox();+ await p.mouse.move(r.x + r.width / 2, r.y + r.height * 0.6);+ const at = await view.evaluate((v) => v.scrollTop);+ await wheels(p, 10, 30);+ const down = await rested(p, view);+ assert(down >= at + 200, `${what}: ten wheels of 30px right after the click scroll the page: from ${at} to ${down}`);+ await wheels(p, 10, -30);+ const up = await rested(p, view);+ assert(up <= down - 200, `${what}: and back up: from ${down} to ${up}`);+}++const CASES = {+ // each tab in turn, clicked and wheeled at once+ async usage(p) {+ const view = p.locator("#view-usage");+ await p.goto("http://magpie.test/?view=usage");+ await p.locator("#usageTab .opt").nth(3).waitFor();+ await tall(view);+ await rested(p, view);+ for (const i of [1, 2, 3, 0]) {+ await view.evaluate((v) => { v.scrollTop = 0; });+ await rested(p, view);+ await p.waitForTimeout(1100); // the last run's second is over+ await p.locator("#usageTab .opt").nth(i).click();+ await p.locator("#usageTab .opt.on").nth(0).waitFor();+ assert.equal(await p.locator("#usageTab .opt").nth(i).evaluate((b) => b.classList.contains("on")), true, "the tab clicked is on");+ await follows(p, view, "Usage tab " + i);+ }+ },+ // an agent's row opened, then closed, wheeled at once after each+ async agents(p) {+ const view = p.locator("#view-agents");+ await p.goto("http://magpie.test/?view=agents");+ await p.locator('#agents .row.agent[data-id="a1"] .ag-link').waitFor();+ await tall(view);+ await rested(p, view);+ await p.locator('#agents .row.agent[data-id="a1"] .ag-link').click();+ await p.locator('#agents .row.agent[data-id="a1"] > .ag-exp').waitFor();+ await rested(p, view);+ await follows(p, view, "an agent opened");+ await view.evaluate((v) => { v.scrollTop = 0; });+ await rested(p, view);+ await p.waitForTimeout(1100);+ await p.locator('#agents .row.agent[data-id="a1"] .ag-link').click();+ await p.locator('#agents .row.agent[data-id="a1"] > .ag-exp').waitFor({ state: "detached" });+ await follows(p, view, "an agent closed");+ },+ // Settings' tabs stay at the top as the page scrolls under them (narrow)+ async settings(p) {+ const view = p.locator("#view-settings");+ await p.goto("http://magpie.test/?view=settings");+ await p.locator("#setTab-network").waitFor();+ await tall(view);+ await rested(p, view);+ await view.evaluate((v) => { v.scrollTop = 300; });+ await rested(p, view);+ await p.waitForTimeout(1100);+ await p.locator("#setTab-general").click();+ await follows(p, view, "a Settings tab");+ },+};++for (const engine of (process.env.BROWSER ? [process.env.BROWSER] : ["chromium", "webkit"])) {+ test(engine + ": a wheel the page never hears scrolls right after a click that redraws", { timeout: 900000 }, async (t) => {+ assert(["chromium", "webkit"].includes(engine), "BROWSER must be chromium or webkit");+ const browser = await (engine === "webkit" ? webkit : chromium).launch();+ t.after(() => browser.close());+ for (const lang of LANGS) for (const width of [420, 1000]) for (const name of Object.keys(CASES)) {+ if (name === "settings" && width !== 420) continue;+ await t.test(`${name}, ${lang}, ${width}px`, async () => {+ const ctx = await browser.newContext({ viewport: { width, height: 600 }, reducedMotion: "reduce" });+ const p = await ctx.newPage();+ p.setDefaultTimeout(8000);+ const errors = [];+ p.on("pageerror", (e) => { if (!/^ResizeObserver loop/.test(e.message)) errors.push(e.message); });+ await p.addInitScript(DEAF);+ await p.route("**/*", server(lang));+ await CASES[name](p);+ const others = await p.evaluate(() => [document.scrollingElement, ...document.querySelectorAll(".view:not([hidden]) *")].filter((n) => n.scrollTop > 0 && !n.matches(".sess-menu *, .heat-grid, .led-hscroll")).map((n) => n.id || n.className));+ assert.deepEqual(others, [], "nothing but the view scrolls");+ assert.deepEqual(errors, []);+ await ctx.close();+ });+ }+ });+}