termdock 1.4.108 → 1.4.110

package/.desktop-dist/main.js

@@ -1,4 +1,4 @@
-import { app, BrowserWindow, dialog, ipcMain, Menu, net, Notification, session, shell, } from 'electron';
+import { app, BrowserWindow, dialog, ipcMain, Menu, net, nativeImage, Notification, screen, session, shell, Tray, } from 'electron';
 import { execFile, spawn } from 'node:child_process';
 import crypto from 'node:crypto';
 import dgram from 'node:dgram';
@@ -8,6 +8,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { promisify } from 'node:util';
 import { fileURLToPath } from 'node:url';
+import { desktopStatusTooltip, formatCompactDesktopStatus, mergeServiceActivity, nextServiceOrigin, normalizeServiceActivity, summarizeServiceActivity, } from './activityStatus.js';
 import { checkForDesktopUpdates, configureDesktopUpdater, ensureLatestRuntime, getDesktopUpdateState, installDownloadedDesktopUpdate, subscribeDesktopUpdateState, } from './updater.js';
 import { resolvePackagedRuntime, rollbackDownloadedRuntime, } from './runtime.js';
 import { isExternalLinkStagingUrl, isSafeExternalUrl } from './externalLinks.js';
@@ -52,9 +53,17 @@ function triggerLocalNetworkPermission() {
 let mainWindow = null;
 const serviceWindows = new Map();
 const windowServiceOrigins = new WeakMap();
-const serviceActivity = new Map();
+const restorableServiceWindows = new WeakSet();
+const reportedServiceActivity = new Map();
+const observedServiceActivity = new Map();
 let lastFocusedServiceWindow = null;
+let menuBarStatus = null;
+let menuBarStatusWidth = 0;
+let floatingWidgetWindow = null;
+let floatingPositionTimer = null;
 let isQuitting = false;
+const FLOATING_WIDGET_WIDTHS = [64, 108, 152];
+const FLOATING_WIDGET_HEIGHT = 40;
 function focusedWorkspaceWindow() {
     const focused = BrowserWindow.getFocusedWindow();
     if (focused && windowServiceOrigins.has(focused))
@@ -77,7 +86,7 @@ function serviceActivitySnapshot(targetWindow) {
     return [...serviceWindows.entries()].flatMap(([origin, window]) => {
         if (window.isDestroyed())
             return [];
-        const activity = serviceActivity.get(origin) ?? { runningCount: 0, reviewCount: 0 };
+        const activity = mergeServiceActivity(reportedServiceActivity.get(origin), observedServiceActivity.get(origin));
         return [{
                 origin,
                 label: serviceLabel(origin),
@@ -93,6 +102,7 @@ function broadcastServiceActivity() {
             continue;
         window.webContents.send('desktop:service-activity-changed', serviceActivitySnapshot(window));
     }
+    refreshDesktopStatusSurfaces();
 }
 function serviceLabel(url) {
     const normalized = normalizeServiceUrl(url);
@@ -104,6 +114,311 @@ function serviceLabel(url) {
         ? '本机'
         : parsed.host;
 }
+function allServiceActivity() {
+    const focused = BrowserWindow.getFocusedWindow();
+    return [...serviceWindows.entries()].flatMap(([origin, window]) => {
+        if (window.isDestroyed())
+            return [];
+        return [{
+                origin,
+                label: serviceLabel(origin),
+                current: window === lastFocusedServiceWindow,
+                focused: window === focused,
+                ...mergeServiceActivity(reportedServiceActivity.get(origin), observedServiceActivity.get(origin)),
+            }];
+    });
+}
+function desktopStatusSnapshot() {
+    const services = allServiceActivity();
+    const summary = summarizeServiceActivity(services);
+    return {
+        ...summary,
+        text: formatCompactDesktopStatus(summary),
+        tooltip: desktopStatusTooltip(summary),
+        services,
+        preferences: readDesktopConfig().desktopPreferences,
+    };
+}
+function nextServiceWindow(scope) {
+    const currentOrigin = lastFocusedServiceWindow && !lastFocusedServiceWindow.isDestroyed()
+        ? windowServiceOrigins.get(lastFocusedServiceWindow) ?? null
+        : null;
+    const origin = nextServiceOrigin(allServiceActivity(), currentOrigin, scope);
+    return origin ? serviceWindows.get(origin) ?? null : focusedWorkspaceWindow();
+}
+function focusNextService(scope = 'attention') {
+    const target = nextServiceWindow(scope);
+    if (target && !target.isDestroyed()) {
+        showAndFocusWindow(target);
+        return;
+    }
+    void showConnectionCenter();
+}
+function menuBarContextMenu() {
+    const status = desktopStatusSnapshot();
+    const serviceItems = status.services.length > 0
+        ? status.services
+            .sort((left, right) => right.reviewCount - left.reviewCount
+            || right.runningCount - left.runningCount
+            || left.label.localeCompare(right.label))
+            .map((service) => ({
+            label: `${service.label}${service.runningCount > 0 ? `  运行 ${service.runningCount}` : ''}${service.reviewCount > 0 ? `  待办 ${service.reviewCount}` : ''}`,
+            click: () => {
+                const target = serviceWindows.get(service.origin);
+                if (target && !target.isDestroyed())
+                    showAndFocusWindow(target);
+            },
+        }))
+        : [{ label: '暂无已打开服务', enabled: false }];
+    return Menu.buildFromTemplate([
+        { label: status.tooltip, enabled: false },
+        { type: 'separator' },
+        ...serviceItems,
+        { type: 'separator' },
+        { label: '连接中心…', click: () => void showConnectionCenter() },
+        {
+            label: '显示悬浮状态',
+            type: 'checkbox',
+            checked: status.preferences.floatingWidgetEnabled,
+            click: (item) => updateDesktopPreferences({ floatingWidgetEnabled: item.checked }),
+        },
+        { type: 'separator' },
+        { role: 'quit' },
+    ]);
+}
+function menuBarStatusImage(status) {
+    const size = 18;
+    const scale = 2;
+    const bitmap = Buffer.alloc(size * scale * size * scale * 4);
+    const glyphs = {
+        '0': ['111', '101', '101', '101', '111'],
+        '1': ['010', '110', '010', '010', '111'],
+        '2': ['111', '001', '111', '100', '111'],
+        '3': ['111', '001', '111', '001', '111'],
+        '4': ['101', '101', '111', '001', '001'],
+        '5': ['111', '100', '111', '001', '111'],
+        '6': ['111', '100', '111', '101', '111'],
+        '7': ['111', '001', '010', '010', '010'],
+        '8': ['111', '101', '111', '101', '111'],
+        '9': ['111', '101', '111', '001', '111'],
+        '+': ['000', '010', '111', '010', '000'],
+    };
+    const drawPixel = (x, y, alpha = 255) => {
+        for (let offsetY = 0; offsetY < scale; offsetY += 1) {
+            for (let offsetX = 0; offsetX < scale; offsetX += 1) {
+                const pixelX = x * scale + offsetX;
+                const pixelY = y * scale + offsetY;
+                if (pixelX < 0 || pixelX >= size * scale || pixelY < 0 || pixelY >= size * scale)
+                    continue;
+                bitmap[(pixelY * size * scale + pixelX) * 4 + 3] = alpha;
+            }
+        }
+    };
+    const drawGlyph = (value, x, y, alpha) => {
+        const glyph = glyphs[value > 9 ? '+' : String(value)] ?? glyphs['0'];
+        glyph.forEach((row, rowIndex) => {
+            [...row].forEach((cell, columnIndex) => {
+                if (cell === '1')
+                    drawPixel(x + columnIndex, y + rowIndex, alpha);
+            });
+        });
+    };
+    // Three quiet, consistently aligned rows read much better at menu-bar size
+    // than squeezing two metrics beside each other. The ordering mirrors the
+    // floating widget: running, review, then connected services.
+    const rows = [
+        { value: status.runningCount, y: 0, icon: [[0, 0], [0, 1], [1, 1], [0, 2], [1, 2], [2, 2], [3, 2], [0, 3], [1, 3], [0, 4]] },
+        { value: status.reviewCount, y: 6, icon: [[2, 0], [1, 1], [3, 1], [0, 2], [4, 2], [1, 3], [3, 3], [2, 4]] },
+        { value: status.serviceCount, y: 12, icon: [[0, 0], [1, 0], [3, 0], [4, 0], [1, 1], [3, 1], [2, 2], [2, 3], [1, 4], [2, 4], [3, 4]] },
+    ];
+    rows.forEach(({ value, y, icon }) => {
+        const alpha = value > 0 ? 255 : 96;
+        icon.forEach(([offsetX, offsetY]) => drawPixel(1 + offsetX, y + offsetY, alpha));
+        drawGlyph(value, 11, y, alpha);
+    });
+    // Template images are intentionally monochrome; macOS supplies the correct
+    // menu-bar color for the active appearance and accessibility state.
+    const image = nativeImage.createFromBitmap(bitmap, {
+        width: size * scale,
+        height: size * scale,
+        scaleFactor: scale,
+    });
+    image.setTemplateImage(true);
+    return image;
+}
+function refreshMenuBarStatus(status) {
+    if (process.platform !== 'darwin' || !status.preferences.menuBarStatusEnabled) {
+        menuBarStatus?.destroy();
+        menuBarStatus = null;
+        menuBarStatusWidth = 0;
+        return;
+    }
+    const image = menuBarStatusImage(status);
+    const imageWidth = image.getSize().width;
+    if (!menuBarStatus || menuBarStatus.isDestroyed() || menuBarStatusWidth !== imageWidth) {
+        menuBarStatus?.destroy();
+        menuBarStatus = new Tray(image);
+        menuBarStatusWidth = imageWidth;
+        menuBarStatus.on('click', () => focusNextService('attention'));
+        menuBarStatus.on('right-click', () => menuBarStatus?.popUpContextMenu(menuBarContextMenu()));
+    }
+    else {
+        menuBarStatus.setImage(image);
+    }
+    menuBarStatus.setTitle('');
+    menuBarStatus.setToolTip(`${status.tooltip}\n点击循环切换需关注的服务`);
+}
+function constrainFloatingPosition(position, width = FLOATING_WIDGET_WIDTHS[2]) {
+    const height = FLOATING_WIDGET_HEIGHT;
+    const display = position
+        ? screen.getDisplayMatching({ x: position.x, y: position.y, width, height })
+        : screen.getPrimaryDisplay();
+    const area = display.workArea;
+    const preferred = position ?? {
+        x: area.x + area.width - width - 18,
+        y: area.y + 18,
+    };
+    return {
+        x: Math.min(area.x + area.width - width, Math.max(area.x, Math.round(preferred.x))),
+        y: Math.min(area.y + area.height - height, Math.max(area.y, Math.round(preferred.y))),
+    };
+}
+function createFloatingWidget(position) {
+    const bounds = constrainFloatingPosition(position);
+    const window = new BrowserWindow({
+        title: 'Termdock Status',
+        type: 'panel',
+        width: FLOATING_WIDGET_WIDTHS[2],
+        height: FLOATING_WIDGET_HEIGHT,
+        x: bounds.x,
+        y: bounds.y,
+        show: false,
+        frame: false,
+        transparent: true,
+        backgroundColor: 'rgba(0, 0, 0, 0)',
+        vibrancy: 'popover',
+        visualEffectState: 'active',
+        resizable: false,
+        maximizable: false,
+        minimizable: false,
+        fullscreenable: false,
+        focusable: false,
+        skipTaskbar: true,
+        alwaysOnTop: true,
+        acceptFirstMouse: true,
+        hasShadow: true,
+        webPreferences: {
+            preload: path.join(currentDir, 'preload.cjs'),
+            nodeIntegration: false,
+            contextIsolation: true,
+            sandbox: true,
+            backgroundThrottling: false,
+        },
+    });
+    window.setAlwaysOnTop(true, 'floating');
+    window.setVisibleOnAllWorkspaces(true, {
+        visibleOnFullScreen: true,
+        // Electron otherwise temporarily transforms the whole process into a UI
+        // element, which can hide the app menu and remove normal windows from App
+        // Expose while this panel exists.
+        skipTransformProcessType: true,
+    });
+    // Keep the auxiliary status panel out of App Expose / Mission Control so it
+    // cannot disrupt macOS's three-finger application-window gesture.
+    window.setHiddenInMissionControl(true);
+    let constrainingMove = false;
+    window.on('move', () => {
+        if (constrainingMove || window.isDestroyed())
+            return;
+        const [x, y] = window.getPosition();
+        const [width] = window.getSize();
+        const constrained = constrainFloatingPosition({ x, y }, width);
+        if (constrained.x === x && constrained.y === y)
+            return;
+        constrainingMove = true;
+        window.setPosition(constrained.x, constrained.y, false);
+        constrainingMove = false;
+    });
+    window.on('moved', () => {
+        if (floatingPositionTimer)
+            clearTimeout(floatingPositionTimer);
+        floatingPositionTimer = setTimeout(() => {
+            floatingPositionTimer = null;
+            if (window.isDestroyed())
+                return;
+            const [x, y] = window.getPosition();
+            const config = readDesktopConfig();
+            config.desktopPreferences.floatingWidgetPosition = { x, y };
+            writeDesktopConfig(config);
+        }, 250);
+    });
+    window.on('closed', () => {
+        if (floatingWidgetWindow === window)
+            floatingWidgetWindow = null;
+    });
+    const rendererPath = app.isPackaged
+        ? path.join(process.resourcesPath, 'renderer', 'floating.html')
+        : path.join(projectRoot, 'desktop', 'renderer', 'floating.html');
+    void window.loadFile(rendererPath).then(() => window.showInactive());
+    return window;
+}
+function resizeFloatingWidget(metricCount) {
+    const window = floatingWidgetWindow;
+    if (!window || window.isDestroyed())
+        return;
+    const safeCount = Math.min(3, Math.max(1, Math.round(metricCount)));
+    const width = FLOATING_WIDGET_WIDTHS[safeCount - 1];
+    const [currentWidth] = window.getSize();
+    if (currentWidth === width)
+        return;
+    const [x, y] = window.getPosition();
+    window.setSize(width, FLOATING_WIDGET_HEIGHT, false);
+    const constrained = constrainFloatingPosition({ x: x + currentWidth - width, y }, width);
+    window.setPosition(constrained.x, constrained.y, false);
+}
+function refreshFloatingWidget(status) {
+    if (process.platform !== 'darwin' || !status.preferences.floatingWidgetEnabled) {
+        if (floatingWidgetWindow && !floatingWidgetWindow.isDestroyed())
+            floatingWidgetWindow.destroy();
+        floatingWidgetWindow = null;
+        return;
+    }
+    if (!floatingWidgetWindow || floatingWidgetWindow.isDestroyed()) {
+        floatingWidgetWindow = createFloatingWidget(status.preferences.floatingWidgetPosition);
+    }
+}
+function keepFloatingWidgetOnScreen() {
+    if (!floatingWidgetWindow || floatingWidgetWindow.isDestroyed())
+        return;
+    const [x, y] = floatingWidgetWindow.getPosition();
+    const [width] = floatingWidgetWindow.getSize();
+    const constrained = constrainFloatingPosition({ x, y }, width);
+    if (constrained.x !== x || constrained.y !== y) {
+        floatingWidgetWindow.setPosition(constrained.x, constrained.y, false);
+    }
+}
+function refreshDesktopStatusSurfaces() {
+    if (!app.isReady())
+        return;
+    const status = desktopStatusSnapshot();
+    refreshMenuBarStatus(status);
+    refreshFloatingWidget(status);
+    for (const window of BrowserWindow.getAllWindows()) {
+        if (!window.isDestroyed())
+            window.webContents.send('desktop:status-changed', status);
+    }
+}
+function updateDesktopPreferences(patch) {
+    const config = readDesktopConfig();
+    if (typeof patch.menuBarStatusEnabled === 'boolean') {
+        config.desktopPreferences.menuBarStatusEnabled = patch.menuBarStatusEnabled;
+    }
+    if (typeof patch.floatingWidgetEnabled === 'boolean') {
+        config.desktopPreferences.floatingWidgetEnabled = patch.floatingWidgetEnabled;
+    }
+    writeDesktopConfig(config);
+    refreshDesktopStatusSurfaces();
+}
 function showDesktopMessageBox(options) {
     const parent = BrowserWindow.getFocusedWindow() ?? mainWindow;
     return parent
@@ -156,7 +471,30 @@ function defaultConfig() {
         version: 1,
         connections: [],
         lastConnectionUrl: null,
+        openConnectionUrls: [],
         trustedCertificateAuthorities: [],
+        desktopPreferences: {
+            menuBarStatusEnabled: true,
+            floatingWidgetEnabled: false,
+            floatingWidgetPosition: null,
+        },
+    };
+}
+function normalizeDesktopPreferences(value) {
+    const input = value && typeof value === 'object'
+        ? value
+        : {};
+    const position = input.floatingWidgetPosition;
+    return {
+        // The compact, text-only status is the useful default on macOS. Existing
+        // desktop.json files therefore gain the feature without a migration step.
+        menuBarStatusEnabled: input.menuBarStatusEnabled !== false,
+        floatingWidgetEnabled: input.floatingWidgetEnabled === true,
+        floatingWidgetPosition: position
+            && Number.isFinite(position.x)
+            && Number.isFinite(position.y)
+            ? { x: Math.round(position.x), y: Math.round(position.y) }
+            : null,
     };
 }
 function normalizeServiceUrl(raw) {
@@ -272,13 +610,20 @@ function readDesktopConfig() {
         const parsed = JSON.parse(fs.readFileSync(desktopConfigPath, 'utf8'));
         if (parsed.version !== 1 || !Array.isArray(parsed.connections))
             return defaultConfig();
+        const lastConnectionUrl = typeof parsed.lastConnectionUrl === 'string' ? parsed.lastConnectionUrl : null;
         return {
             version: 1,
             connections: parsed.connections.filter((entry) => Boolean(entry)
                 && typeof entry.id === 'string'
                 && typeof entry.label === 'string'
                 && typeof entry.url === 'string'),
-            lastConnectionUrl: typeof parsed.lastConnectionUrl === 'string' ? parsed.lastConnectionUrl : null,
+            lastConnectionUrl,
+            // Older desktop.json files only remembered the most recent window. Use
+            // that value once as their restore list, while preserving an explicit
+            // empty list when the user intentionally closed every service window.
+            openConnectionUrls: Array.isArray(parsed.openConnectionUrls)
+                ? parsed.openConnectionUrls.filter((url) => typeof url === 'string')
+                : lastConnectionUrl ? [lastConnectionUrl] : [],
             trustedCertificateAuthorities: Array.isArray(parsed.trustedCertificateAuthorities)
                 ? parsed.trustedCertificateAuthorities.filter((entry) => Boolean(entry)
                     && typeof entry.origin === 'string'
@@ -286,6 +631,7 @@ function readDesktopConfig() {
                     && typeof entry.subject === 'string'
                     && typeof entry.trustedAt === 'number')
                 : [],
+            desktopPreferences: normalizeDesktopPreferences(parsed.desktopPreferences),
         };
     }
     catch {
@@ -616,6 +962,7 @@ async function snapshot() {
         localService,
         connections: config.connections,
         lastConnectionUrl: config.lastConnectionUrl,
+        desktopPreferences: config.desktopPreferences,
     };
 }
 function desktopRuntimeEnv(runtime = runtimePaths()) {
@@ -810,7 +1157,7 @@ async function installCli() {
     ], { timeout: 120_000, maxBuffer: 256 * 1024 });
     return snapshot();
 }
-async function connectWindow(rawUrl) {
+async function connectWindow(rawUrl, options = {}) {
     let probe = await probeServiceWithLocalNetworkPermission(rawUrl);
     if (!probe.ok)
         return probe;
@@ -819,28 +1166,67 @@ async function connectWindow(rawUrl) {
     const existingWindow = serviceWindows.get(key);
     if (existingWindow && !existingWindow.isDestroyed()) {
         const config = readDesktopConfig();
-        config.lastConnectionUrl = probe.url;
+        if (options.updateLastConnection !== false)
+            config.lastConnectionUrl = probe.url;
+        config.openConnectionUrls = [
+            ...config.openConnectionUrls.filter((url) => {
+                try {
+                    return new URL(url).origin !== key;
+                }
+                catch {
+                    return false;
+                }
+            }),
+            probe.url,
+        ];
         const existing = config.connections.find((entry) => entry.url === probe.url);
         if (existing)
             existing.lastConnectedAt = Date.now();
         writeDesktopConfig(config);
-        mainWindow?.hide();
-        showAndFocusWindow(existingWindow);
+        if (options.focus !== false) {
+            mainWindow?.hide();
+            showAndFocusWindow(existingWindow);
+        }
+        else {
+            existingWindow.showInactive();
+        }
         return probe;
     }
     const workspaceWindow = createDesktopWindow({ serviceOrigin: key, label: serviceLabel(probe.url) });
     serviceWindows.set(key, workspaceWindow);
+    broadcastServiceActivity();
     while (!workspaceWindow.isDestroyed()) {
         try {
             await workspaceWindow.loadURL(probe.url);
             const config = readDesktopConfig();
-            config.lastConnectionUrl = probe.url;
+            if (options.updateLastConnection !== false)
+                config.lastConnectionUrl = probe.url;
+            config.openConnectionUrls = [
+                ...config.openConnectionUrls.filter((url) => {
+                    try {
+                        return new URL(url).origin !== key;
+                    }
+                    catch {
+                        return false;
+                    }
+                }),
+                probe.url,
+            ];
             const existing = config.connections.find((entry) => entry.url === probe.url);
             if (existing)
                 existing.lastConnectedAt = Date.now();
             writeDesktopConfig(config);
-            mainWindow?.hide();
-            showAndFocusWindow(workspaceWindow);
+            restorableServiceWindows.add(workspaceWindow);
+            if (options.focus !== false) {
+                mainWindow?.hide();
+                showAndFocusWindow(workspaceWindow);
+            }
+            else {
+                // Restored workspaces must be real visible macOS windows so App Expose
+                // can select them, but opening several at launch must not steal focus
+                // from each other.
+                workspaceWindow.showInactive();
+            }
             return probe;
         }
         catch (error) {
@@ -1030,7 +1416,8 @@ function createDesktopWindow(options) {
         const serviceOrigin = windowServiceOrigins.get(window);
         if (serviceOrigin && serviceWindows.get(serviceOrigin) === window) {
             serviceWindows.delete(serviceOrigin);
-            serviceActivity.delete(serviceOrigin);
+            reportedServiceActivity.delete(serviceOrigin);
+            observedServiceActivity.delete(serviceOrigin);
             broadcastServiceActivity();
         }
     });
@@ -1042,6 +1429,19 @@ function createDesktopWindow(options) {
         clearUnreadNotifications();
     });
     window.on('close', (event) => {
+        const serviceOrigin = windowServiceOrigins.get(window);
+        if (serviceOrigin && !isQuitting && restorableServiceWindows.has(window)) {
+            const config = readDesktopConfig();
+            config.openConnectionUrls = config.openConnectionUrls.filter((url) => {
+                try {
+                    return new URL(url).origin !== serviceOrigin;
+                }
+                catch {
+                    return false;
+                }
+            });
+            writeDesktopConfig(config);
+        }
         if (window === mainWindow && process.platform === 'darwin' && !isQuitting) {
             event.preventDefault();
             window.hide();
@@ -1085,18 +1485,28 @@ function installIpcHandlers() {
         const origin = windowServiceOrigins.get(sourceWindow);
         if (!origin)
             return;
-        const normalizeCount = (value) => Math.min(999, Math.max(0, typeof value === 'number' && Number.isFinite(value) ? Math.floor(value) : 0));
-        const next = {
-            runningCount: normalizeCount(activity?.runningCount),
-            reviewCount: normalizeCount(activity?.reviewCount),
-        };
-        const current = serviceActivity.get(origin);
+        const next = normalizeServiceActivity(activity);
+        const current = reportedServiceActivity.get(origin);
         if (current?.runningCount === next.runningCount && current.reviewCount === next.reviewCount) {
             // The sender may have just reloaded and still needs the complete roster.
             sourceWindow.webContents.send('desktop:service-activity-changed', serviceActivitySnapshot(sourceWindow));
             return;
         }
-        serviceActivity.set(origin, next);
+        reportedServiceActivity.set(origin, next);
+        broadcastServiceActivity();
+    });
+    ipcMain.on('desktop:observe-service-activity', (event, activity) => {
+        const sourceWindow = BrowserWindow.fromWebContents(event.sender);
+        if (!sourceWindow)
+            return;
+        const origin = windowServiceOrigins.get(sourceWindow);
+        if (!origin)
+            return;
+        const next = normalizeServiceActivity(activity);
+        const current = observedServiceActivity.get(origin);
+        if (current?.runningCount === next.runningCount && current.reviewCount === next.reviewCount)
+            return;
+        observedServiceActivity.set(origin, next);
         broadcastServiceActivity();
     });
     ipcMain.handle('desktop:focus-service', (event, origin) => {
@@ -1111,6 +1521,36 @@ function installIpcHandlers() {
         return true;
     });
     ipcMain.handle('desktop:start-local', () => startLocalService());
+    ipcMain.handle('desktop:update-preferences', async (_event, preferences) => {
+        updateDesktopPreferences({
+            ...(typeof preferences?.menuBarStatusEnabled === 'boolean'
+                ? { menuBarStatusEnabled: preferences.menuBarStatusEnabled }
+                : {}),
+            ...(typeof preferences?.floatingWidgetEnabled === 'boolean'
+                ? { floatingWidgetEnabled: preferences.floatingWidgetEnabled }
+                : {}),
+        });
+        return snapshot();
+    });
+    ipcMain.handle('desktop:status-snapshot', () => desktopStatusSnapshot());
+    ipcMain.handle('desktop:focus-next-service', (_event, scope) => {
+        const normalized = scope === 'running'
+            || scope === 'review'
+            || scope === 'all'
+            ? scope
+            : 'attention';
+        focusNextService(normalized);
+    });
+    ipcMain.handle('desktop:set-floating-metric-count', (event, count) => {
+        const sourceWindow = BrowserWindow.fromWebContents(event.sender);
+        if (sourceWindow !== floatingWidgetWindow || typeof count !== 'number' || !Number.isFinite(count))
+            return;
+        resizeFloatingWidget(count);
+    });
+    ipcMain.handle('desktop:disable-floating-widget', async () => {
+        updateDesktopPreferences({ floatingWidgetEnabled: false });
+        return snapshot();
+    });
     ipcMain.handle('desktop:install-cli', () => installCli());
     ipcMain.handle('desktop:update-state', () => getDesktopUpdateState());
     ipcMain.handle('desktop:check-update', () => checkForDesktopUpdates());
@@ -1388,6 +1828,9 @@ app.whenReady().then(async () => {
     configureLocalServiceCertificateTrust();
     installIpcHandlers();
     installMenu();
+    refreshDesktopStatusSurfaces();
+    screen.on('display-removed', keepFloatingWidgetOnScreen);
+    screen.on('display-metrics-changed', keepFloatingWidgetOnScreen);
     configureDesktopUpdater(showDesktopMessageBox);
     subscribeDesktopUpdateState((state) => {
         for (const window of BrowserWindow.getAllWindows()) {
@@ -1395,11 +1838,27 @@ app.whenReady().then(async () => {
                 window.webContents.send('desktop:update-state-changed', state);
         }
     });
-    const lastConnectionUrl = readDesktopConfig().lastConnectionUrl;
-    if (lastConnectionUrl) {
-        const probe = await connectWindow(lastConnectionUrl);
-        if (!probe.ok)
-            await showConnectionCenter();
+    const startupConfig = readDesktopConfig();
+    const restoreUrls = startupConfig.openConnectionUrls;
+    let restoredWindowCount = 0;
+    for (const url of restoreUrls) {
+        const probe = await connectWindow(url, { focus: false, updateLastConnection: false });
+        if (probe.ok)
+            restoredWindowCount += 1;
+    }
+    if (restoredWindowCount > 0) {
+        let preferredOrigin = null;
+        try {
+            preferredOrigin = startupConfig.lastConnectionUrl
+                ? new URL(startupConfig.lastConnectionUrl).origin
+                : null;
+        }
+        catch {
+            // A malformed legacy value must not prevent the other saved windows
+            // from being restored.
+        }
+        const preferredWindow = preferredOrigin ? serviceWindows.get(preferredOrigin) : null;
+        showAndFocusWindow(preferredWindow ?? [...serviceWindows.values()][0]);
     }
     else {
         await showConnectionCenter();