Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar.
gui: the Mac's window is in the Dock and Command-Tab while it is open, by default (ShouguangCao on X)
yetone1407c9a3bb87
diff --git a/docs/subsystems/gui-shell.md b/docs/subsystems/gui-shell.mdindex 404220d73..395d1800a 100644--- a/docs/subsystems/gui-shell.md+++ b/docs/subsystems/gui-shell.md@@ -32,7 +32,7 @@ three.5. Closing the window hides it. On the Mac a full-screen window first leaves full screen (`closeStep`). The system's close on the panel (a title bar's X, Alt+F4, a window manager's close key) hides it as Escape does, so the tray icon opens it again; a panel lightweight mode let go, no longer `h.panel`, closes (`makePanel`, `TestPanelCloseHidesIt`). Lightweight mode lets go only of a window closed this way: one covered by another app's window, minimised, or open as magpie was hidden is still open (`windowUp`, not Wails' `IsVisible`, which is the occlusion state), and so is it for the Dock while the window is open and for a restart (#1381, `TestCoveredWindowStaysUp`). On the Mac the tray icon and a usage cell close an open panel by the same test (`windowOpen` in `togglePanelNow` and `trayCellClick`, not Wails' `ToggleWindow`), so under a window over the whole screen, such as a remote-desktop server's privacy curtain, the icon still closes the panel instead of showing it again (#1661, `TestTrayCellClickReleasedPanel`).6. The window opens as it was last left. Its settled size and whether it was maximised are kept in `settings.Window` and `settings.WindowMaximised` (`settle`; per machine, see `KeepOwn`). A maximised window keeps the size it restores to. `makeMain` opens it at that size (`openSize`). On its first show, `placeMain` maximises it again on the Mac and Windows (on Windows once the page has come). On Linux, `makeMain` makes it maximised with `StartState`. On Windows a size larger than the screen's work area is fitted and centred (`fitRoom`), and the larger size stays kept. The window's position is not kept.7. The page's header is the window's title bar. `plainTitlebar` sets it up once the app has started, and again on a window lightweight mode made again (`madeAgain`). On Linux it hides GTK's title bar and keeps the shadow and the resize edges; GTK 3 leaves the corners square. On the Mac the traffic lights are inset into the header (`MacTitleBarHiddenInset`). In the design of macOS 26 a window with a toolbar has larger corners than one with a plain title bar, so `insetLights` ([`titlebar_darwin.go`](../../internal/gui/titlebar_darwin.go)) takes the toolbar off, and `MagpieLights` keeps the lights and the title bar's height where the toolbar had them: after a resize, a new title, light or dark, more contrast or less transparency, and leaving full screen. A sheet, such as the folder chooser, still begins below the title bar. A first press while another app is in front still moves the window from anywhere in that title bar (`firstPress`), as AppKit moved it with the toolbar; AppKit itself now does so only in a plain title bar's top 32pt. AppKit gives a program that design from macOS 26 when the program is linked against the macOS 26 SDK or a later one and its Info.plist doesn't ask for the earlier design (`UIDesignRequiresCompatibility`); `designOf26` reads each at run time, as the SDK depends on the toolchain that built magpie. The toolbar stays in the earlier design, where it doesn't change the corners, with the lights on the right (a right-to-left language), or when the title bar isn't laid out as expected; this is decided once, when the window is set up. In full screen the title bar is AppKit's own. Windows keeps its own title bar.-8. On the Mac, Settings › Show in Dock puts magpie in the Dock never (the default: out of the Dock, and so out of Command-Tab), while the window is open (`DockWindow`) or always (`Dock`); a full-screen window joins it whatever the setting (`inDock`, `dockOnFullscreen`). `openMain` joins before it shows the window (`setDock` runs on the main thread at once). An app activated out of the Dock (the quick panel's focus) that then joins it stays last in Command-Tab's order though it is in front, so joining to the front activates magpie by way of the Dock (`dockStep`, `activateAgain`; #1381, `TestDockStep`, `TestDockJoinLeadsCommandTab`). It does so without asking NSApp whether magpie is active: the Mac makes it the front app at once, and NSApp says so only once the main thread has taken that in, after the join on a busy Mac (#1651).+8. On the Mac, Settings › Show in Dock puts magpie in the Dock never (`DockNever`), while the window is open (the default; `DockWindow` records it chosen, for an older magpie that took none for never) or always (`Dock`, which wins). The default was never until ShouguangCao on X found the open window out of Command-Tab, so going back to it to paste a key copied elsewhere took the menu bar; a file that chose nothing now reads With window, and Hide is a choice of its own (`inDock`, `dockChoice` in app.js, `TestDockFollowsWindowByDefault`, `dock-choice.test.cjs`). A full-screen window joins it whatever the setting (`inDock`, `dockOnFullscreen`). `openMain` joins before it shows the window (`setDock` runs on the main thread at once). An app activated out of the Dock (the quick panel's focus) that then joins it stays last in Command-Tab's order though it is in front, so joining to the front activates magpie by way of the Dock (`dockStep`, `activateAgain`; #1381, `TestDockStep`, `TestDockJoinLeadsCommandTab`). It does so without asking NSApp whether magpie is active: the Mac makes it the front app at once, and NSApp says so only once the main thread has taken that in, after the join on a busy Mac (#1651).## Constraints and failure behaviordiff --git a/internal/gui/api.go b/internal/gui/api.goindex 43e8d5787..aae6f2a22 100644--- a/internal/gui/api.go+++ b/internal/gui/api.go@@ -1467,7 +1467,7 @@ func Handler(w Windows, gw *gateway.Server) http.Handler {if strings.TrimSpace(in.Vision) != strings.TrimSpace(cur.Vision) {catalog.Touched()}- if (in.Dock != cur.Dock || in.DockWindow != cur.DockWindow) && onDock != nil {+ if (in.Dock != cur.Dock || in.DockWindow != cur.DockWindow || in.DockNever != cur.DockNever) && onDock != nil {onDock(in)}// the cards the menu bar shows, any of them (TrayUsage is only the first),diff --git a/internal/gui/app.go b/internal/gui/app.goindex 6d939dab9..0c84e70c8 100644--- a/internal/gui/app.go+++ b/internal/gui/app.go@@ -150,10 +150,10 @@ func (h *host) dock(s settings.Settings, shown bool) {setDock(inDock(s, shown, full), shown)}-// inDock: always, never, or while the window is shown, as s says, and while-// it is full screen whatever s says (dockOnFullscreen).+// inDock: always, never, or while the window is shown (the default), as s+// says, and while it is full screen whatever s says (dockOnFullscreen).func inDock(s settings.Settings, shown, fullscreen bool) bool {- return s.Dock || s.DockWindow && shown || fullscreen+ return s.Dock || !s.DockNever && shown || fullscreen}func (h *host) Quit() { h.app.Quit() }diff --git a/internal/gui/assets/app.js b/internal/gui/assets/app.jsindex 6b97ae6cf..9dd536444 100644--- a/internal/gui/assets/app.js+++ b/internal/gui/assets/app.js@@ -19678,7 +19678,7 @@ function renderSettings() {$("#dockRow").hidden = !document.body.classList.contains("mac");$("#traySegs").parentElement.hidden = $("#loginSegs").parentElement.hidden = web;$("#dockSegs").replaceChildren(segs([["off", t("Hide")], ["window", t("With window")], ["on", t("Show")]],- s.dock ? "on" : s.dockWindow ? "window" : "off", (v) => savePrefs({ ...keep, dock: v === "on", dockWindow: v === "window" })));+ dockChoice(s), (v) => savePrefs({ ...keep, dock: v === "on", dockWindow: v === "window", dockNever: v === "off" })));// a closed window's webview let go (#580): the app's windows alone$("#lightweightRow").hidden = web;$("#lightweightSegs").replaceChildren(segs([["off", t("Off")], ["on", t("On")]], s.lightweight === true ? "on" : "off",@@ -22655,9 +22655,15 @@ function wbCheckinLine(r) {}}+// dockChoice is Show in Dock's choice in s: With window unless Show or Hide+// was chosen (inDock in app.go), so the window is in Command-Tab by default.+function dockChoice(s) {+ return s.dock ? "on" : s.dockNever ? "off" : "window";+}+// prefsKeep is what the settings page sends of s, all of it each time.function prefsKeep(s) {- return { theme: s.theme, colorblind: !!s.colorblind, reduceMotion: !!s.reduceMotion, noBird: !!s.noBird, lang: s.lang, tray: s.tray, dock: !!s.dock, dockWindow: !!s.dockWindow, lightweight: s.lightweight, keepAwake: !!s.keepAwake, keepAwakeDisplay: !!s.keepAwakeDisplay, noWSLAgents: !!s.noWSLAgents, proxy: s.proxy || "",+ return { theme: s.theme, colorblind: !!s.colorblind, reduceMotion: !!s.reduceMotion, noBird: !!s.noBird, lang: s.lang, tray: s.tray, dock: !!s.dock, dockWindow: !!s.dockWindow, dockNever: !!s.dockNever, lightweight: s.lightweight, keepAwake: !!s.keepAwake, keepAwakeDisplay: !!s.keepAwakeDisplay, noWSLAgents: !!s.noWSLAgents, proxy: s.proxy || "",sessionTerminal: s.sessionTerminal || "",uiFont: s.uiFont || null, codeFont: s.codeFont || null,otel: s.otel || {},diff --git a/internal/gui/mainwindow_test.go b/internal/gui/mainwindow_test.goindex c80c1a13c..369d908fb 100644--- a/internal/gui/mainwindow_test.go+++ b/internal/gui/mainwindow_test.go@@ -59,7 +59,7 @@ func TestCloseStepLeavesFullscreen(t *testing.T) {// had no close, minimise or full-screen buttons, and only Esc took it out of// full screen. A full-screen window keeps magpie in the Dock, whatever the setting.func TestFullscreenKeepsDock(t *testing.T) {- hidden, window, shown := settings.Settings{}, settings.Settings{DockWindow: true}, settings.Settings{Dock: true}+ hidden, window, shown := settings.Settings{DockNever: true}, settings.Settings{DockWindow: true}, settings.Settings{Dock: true}cases := []struct {s settings.Settingsshown, fullscreen bool@@ -80,6 +80,32 @@ func TestFullscreenKeepsDock(t *testing.T) {}}+// ShouguangCao on X: with Show in Dock left as it came, the open window was+// out of Command-Tab, so going back to it to paste a key copied in another+// app took the menu bar. Out of the box magpie is in the Dock while its+// window is open and leaves it when the window closes; Hide keeps it out,+// and Show keeps it in.+func TestDockFollowsWindowByDefault(t *testing.T) {+ cases := []struct {+ name string+ s settings.Settings+ shown bool+ want bool+ }{+ {"default, window open", settings.Settings{}, true, true},+ {"default, window closed", settings.Settings{}, false, false},+ {"an older file's With window, open", settings.Settings{DockWindow: true}, true, true},+ {"Hide, window open", settings.Settings{DockNever: true}, true, false},+ {"Show, window closed", settings.Settings{Dock: true}, false, true},+ {"Show wins over Hide", settings.Settings{Dock: true, DockNever: true}, false, true},+ }+ for _, c := range cases {+ if got := inDock(c.s, c.shown, false); got != c.want {+ t.Errorf("%s: inDock = %v, want %v", c.name, got, c.want)+ }+ }+}+// yogurt36 on Discord: an account shown by its eye while Hide accounts is on// is shown for the window's session only. Closing the window only hides it,// so hideMain tells the page; the call it makes is one app.js answers, anddiff --git a/internal/gui/tests/dock-choice.test.cjs b/internal/gui/tests/dock-choice.test.cjsnew file mode 100644index 000000000..3b8428246--- /dev/null+++ b/internal/gui/tests/dock-choice.test.cjs@@ -0,0 +1,117 @@+// Run with Node's test runner and Playwright on the module path; see README.md.+// ShouguangCao on X: with Settings › Show in Dock left as it came, magpie's+// window was out of Command-Tab, so going back to it to paste a key copied+// in another app took the menu bar. The choice now reads With window unless+// Hide or Show was chosen (inDock in app.go), on a Mac, in both engines and+// every language, with the API faked:+// - settings that chose nothing show With window;+// - an older file's dockWindow shows With window, its dock Show;+// - Hide saves dockNever and shows Hide after; With window and Show clear it.+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 { watchSettingsReads, settingsDrawn } = require("./reader.cjs");++const assets = path.resolve(__dirname, "../assets");+const choices = {+ en: ["Hide", "With window", "Show"],+ zh: ["隐藏", "跟随窗口", "显示"],+ "zh-TW": ["隱藏", "跟隨視窗", "顯示"],+ ja: ["非表示", "ウィンドウと連動", "表示"],+ de: ["Ausblenden", "Mit Fenster", "Anzeigen"],+};++function serve(lang, posted, st) {+ const settings = () => ({ lang, theme: "light", searchVendors: [], searchAPIs: [], ...st });+ return async (r) => {+ const url = new URL(r.request().url());+ const json = (data, status = 200) => r.fulfill({ status, json: data });+ if (url.pathname === "/boot.js") return r.fulfill({ contentType: "text/javascript", body: `window.bootPrefs = {lang:"${lang}",theme:"light",web:false};` });+ if (url.pathname === "/wails/runtime.js") return r.fulfill({ contentType: "text/javascript", body: "export const Window = {};" });+ if (url.pathname === "/api/state") return json({ agents: [], profiles: [], settings: settings() });+ if (url.pathname === "/api/settings") {+ if (r.request().method() === "POST") {+ const b = JSON.parse(r.request().postData());+ posted.push(b);+ Object.assign(st, b);+ }+ return json(settings());+ }+ if (url.pathname === "/api/providers") return json({ providers: [], presets: [], excluded: [], gateway: { running: true, window: true, url: "http://127.0.0.1:3999" } });+ if (url.pathname === "/api/groups") return json({ models: [], groups: [], pools: [] });+ if (url.pathname === "/api/plugins") return json({ plugins: [] });+ if (url.pathname === "/api/usage/quotas") return json([]);+ 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 r.fulfill({ body: await fs.readFile(file), contentType });+ };+}++for (const engine of (process.env.BROWSER ? [process.env.BROWSER] : ["chromium", "webkit"])) {+ for (const lang of Object.keys(choices)) {+ test(`${engine} ${lang}: Show in Dock reads With window unless Hide or Show was chosen`, async (t) => {+ const browser = await (engine === "webkit" ? webkit.launch() : chromium.launch({ channel: "chromium" }));+ t.after(() => browser.close());+ const open = async (st) => {+ const page = await (await browser.newContext({ viewport: { width: 1000, height: 760 } })).newPage();+ page.setDefaultTimeout(5000);+ const errors = [];+ page.on("pageerror", (e) => errors.push(e.message));+ await page.addInitScript(() => Object.defineProperty(navigator, "platform", { get: () => "MacIntel" }));+ const posted = [];+ await page.route("**/*", serve(lang, posted, st));+ await watchSettingsReads(page);+ await page.goto("http://magpie.test/?view=settings&tab=general");+ await settingsDrawn(page);+ await page.locator("#dockSegs .opt").first().waitFor();+ return { page, posted, errors };+ };+ // which of Hide, With window and Show is on, by place+ const on = (page) => page.locator("#dockSegs .opt").evaluateAll((os) => os.findIndex((o) => o.classList.contains("on")));+ const names = (page) => page.locator("#dockSegs .opt").evaluateAll((os) => os.map((o) => o.textContent.trim()));++ // nothing chosen: With window+ const { page, posted, errors } = await open({});+ assert.equal(await page.locator("#dockRow").isHidden(), false, "the Dock row shows on a Mac");+ assert.deepEqual(await names(page), choices[lang]);+ assert.equal(await on(page), 1, "settings that chose nothing read Hide");++ // Hide: saved as dockNever, and shown chosen+ const pick = async (i, key, want) => {+ await page.waitForFunction(() => prefsBusy === 0);+ // the page comes in animated: a place read mid-way isn't where it rests+ await page.evaluate(() => Promise.all(document.getAnimations().map((a) => a.finished.catch(() => {}))));+ await page.locator("#dockSegs .opt").nth(i).click();+ for (let n = 0; n < 50 && posted.at(-1)?.[key] !== want; n++) await page.waitForTimeout(50);+ assert.equal(posted.at(-1)?.[key], want, `posted ${JSON.stringify(posted.at(-1))}`);+ };+ await pick(0, "dockNever", true);+ assert.equal(posted.at(-1).dock, false);+ assert.equal(posted.at(-1).dockWindow, false);+ for (let n = 0; n < 50 && (await on(page)) !== 0; n++) await page.waitForTimeout(50);+ assert.equal(await on(page), 0, "Hide isn't shown chosen");+ // another setting saved keeps Hide+ await page.waitForFunction(() => prefsBusy === 0);+ const n = posted.length;+ await page.locator("#traySegs .opt").last().click();+ for (let i = 0; i < 50 && posted.length === n; i++) await page.waitForTimeout(50);+ if (posted.length > n) assert.equal(posted.at(-1).dockNever, true, "another setting's save cleared Hide");+ // With window and Show each clear it+ await pick(1, "dockWindow", true);+ assert.equal(posted.at(-1).dockNever, false);+ await pick(2, "dock", true);+ assert.equal(posted.at(-1).dockNever, false);+ assert.deepEqual(errors, []);++ // an older magpie's file+ for (const [st, want] of [[{ dockWindow: true }, 1], [{ dock: true }, 2], [{ dockNever: true }, 0]]) {+ const o = await open(st);+ assert.equal(await on(o.page), want, `${JSON.stringify(st)} reads ${await on(o.page)}`);+ assert.deepEqual(o.errors, []);+ }+ });+ }+}diff --git a/internal/settings/dock_test.go b/internal/settings/dock_test.gonew file mode 100644index 000000000..56c87aca3--- /dev/null+++ b/internal/settings/dock_test.go@@ -0,0 +1,19 @@+package settings++import "testing"++// Show in Dock's Hide (DockNever) is this computer's own, as Dock and+// DockWindow are: a sync or restored backup from a Mac that left it as it+// came never takes a Hide chosen here away, nor brings one.+func TestDockNeverIsMachineLocal(t *testing.T) {+ from := Settings{}+ from.KeepOwn(Settings{DockNever: true})+ if !from.DockNever {+ t.Fatal("a sync cleared this Mac's Hide")+ }+ from = Settings{DockNever: true}+ from.KeepOwn(Settings{})+ if from.DockNever {+ t.Fatal("a sync brought another Mac's Hide")+ }+}diff --git a/internal/settings/settings.go b/internal/settings/settings.goindex 499533701..1d3fa27e6 100644--- a/internal/settings/settings.go+++ b/internal/settings/settings.go@@ -76,10 +76,16 @@ type Settings struct {// Dock keeps magpie in the Mac's Dock as well as the menu bar, for a// menu bar too full to show its icon.Dock bool `json:"dock,omitempty"`- // DockWindow shows it in the Dock only while its window is open, so- // Cmd-Tab reaches the window without an icon kept there the rest of- // the time. Dock wins over it.+ // DockWindow is the With window choice: magpie is in the Dock, and so+ // in Command-Tab, only while its window is open. It is what magpie+ // does with neither Dock nor DockNever set (ShouguangCao on X: the+ // window was out of Command-Tab, so going back to it to paste a key+ // copied elsewhere took the menu bar), so it is still written for an+ // older magpie reading the file, which took none for Hide.DockWindow bool `json:"dockWindow,omitempty"`+ // DockNever keeps magpie out of the Dock and Command-Tab even while+ // its window is open, the Hide choice. Dock wins over it.+ DockNever bool `json:"dockNever,omitempty"`// Proxy for magpie's own requests to vendors: "" follows the// environment and then the system, "direct" uses none, anything else// is the proxy (http://, https:// or socks5://; host:port means http).@@ -1152,6 +1158,7 @@ func (s *Settings) KeepOwn(cur Settings) {s.GatewayConversations = cur.GatewayConversationss.UIFont, s.CodeFont = cur.UIFont, cur.CodeFonts.Window, s.Proxy, s.Port, s.Dock, s.DockWindow, s.Lightweight = cur.Window, cur.Proxy, cur.Port, cur.Dock, cur.DockWindow, cur.Lightweight+ s.DockNever = cur.DockNevers.ProxyCustom = cur.ProxyCustoms.WindowMaximised, s.KeepAwake, s.KeepAwakeDisplay = cur.WindowMaximised, cur.KeepAwake, cur.KeepAwakeDisplays.TrayUsages, s.TrayUsage, s.TrayUsageEvery, s.TrayNoLogos, s.TrayNoBird, s.TrayPace, s.TrayNoCost = cur.TrayUsages, cur.TrayUsage, cur.TrayUsageEvery, cur.TrayNoLogos, cur.TrayNoBird, cur.TrayPace, cur.TrayNoCost