flying-lobster 1.6.2 → 1.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flying-lobster",
-  "version": "1.6.2",
+  "version": "1.8.0",
   "description": "Always-on-top chat window for OpenClaw gateways 🦞",
   "author": "Rootlab.ai",
   "license": "MIT",
@@ -31,15 +31,20 @@
       "assets/**/*"
     ],
     "mac": {
+      "icon": "assets/icon.icns",
       "category": "public.app-category.productivity",
       "target": [
         {
           "target": "dmg",
-          "arch": ["universal"]
+          "arch": [
+            "universal"
+          ]
         },
         {
           "target": "dir",
-          "arch": ["universal"]
+          "arch": [
+            "universal"
+          ]
         }
       ]
     },

package/src/main/index.js

@@ -2,6 +2,7 @@ const { app, BrowserWindow, globalShortcut, Tray, Menu, nativeImage, ipcMain, we
 const path = require('path');
 const store = require('./store');
 const { randomUUID } = require('crypto');
+const updater = require('./updater');
 
 // CSS to inject into OpenClaw webview to create chat-only view
 const OPENCLAW_CSS = `
@@ -36,6 +37,8 @@ const OPENCLAW_CSS = `
   .chat-compose__actions .btn { padding: 0 10px !important; }
   .chat-group-messages { max-width: 100% !important; }
   .chat-group { margin-right: 4px !important; margin-left: 4px !important; }
+  /* Hide tool call/result cards */
+  .chat-tool-card { display: none !important; }
 `;
 
 const OPENCLAW_JS = `
@@ -74,6 +77,7 @@ const OPENCLAW_JS = `
 
 let mainWindow = null;
 let settingsWindow = null;
+let sessionWindows = new Map(); // Map of sessionId -> BrowserWindow
 let tray = null;
 
 // ── IPC Handlers ──────────────────────────────────────────────
@@ -107,9 +111,17 @@ ipcMain.handle('delete-gateway', (_e, id) => {
   return gateways;
 });
 
-ipcMain.handle('get-active-gateway', () => store.get('activeGateway'));
+ipcMain.handle('get-active-gateway', () => {
+  const id = store.get('activeGateway');
+  console.log('[Main] get-active-gateway:', id);
+  return id;
+});
 
 ipcMain.handle('set-active-gateway', (_e, id) => {
+  console.log('[Main] set-active-gateway:', id);
+  const gateways = store.get('gateways');
+  const gw = gateways.find(g => g.id === id);
+  console.log('[Main] Gateway details:', gw?.name, gw?.url);
   store.set('activeGateway', id);
   return id;
 });
@@ -148,6 +160,311 @@ ipcMain.handle('get-theme', () => {
   return nativeTheme.shouldUseDarkColors ? 'dark' : 'light';
 });
 
+// ── Session Management ────────────────────────────────────────
+
+// Extract session name from session key
+function extractSessionName(sessionKey) {
+  if (!sessionKey) return 'main';
+  
+  // Handle patterns like "agent:main:main" -> "main"
+  const parts = sessionKey.split(':');
+  if (parts.length >= 3 && parts[0] === 'agent') {
+    return parts[parts.length - 1]; // Return last part
+  }
+  
+  // Handle other patterns, default to last part after ':'
+  const lastPart = parts[parts.length - 1];
+  return lastPart || 'session';
+}
+
+// Fetch sessions from a gateway
+async function fetchGatewaySessions(gatewayUrl) {
+  try {
+    const ctrl = new AbortController();
+    const timeout = setTimeout(() => ctrl.abort(), 5000);
+    
+    const response = await fetch(`${gatewayUrl}/api/sessions`, {
+      signal: ctrl.signal,
+      headers: { 'Accept': 'application/json' }
+    });
+    
+    clearTimeout(timeout);
+    
+    if (!response.ok) {
+      console.log(`[Sessions] Gateway ${gatewayUrl} sessions API returned ${response.status}`);
+      return [];
+    }
+    
+    const data = await response.json();
+    
+    // Expect sessions to be an array of strings (session keys)
+    if (!Array.isArray(data)) {
+      console.log(`[Sessions] Gateway ${gatewayUrl} returned non-array:`, typeof data);
+      return [];
+    }
+    
+    return data.map(sessionKey => ({
+      id: sessionKey,
+      name: extractSessionName(sessionKey),
+      url: `${gatewayUrl}/chat?session=${sessionKey}`
+    }));
+    
+  } catch (error) {
+    console.log(`[Sessions] Failed to fetch sessions from ${gatewayUrl}:`, error.message);
+    return [];
+  }
+}
+
+// Update sessions for all gateways
+async function refreshAllSessions() {
+  const gateways = store.get('gateways');
+  const allSessions = {};
+  
+  for (const gateway of gateways) {
+    console.log(`[Sessions] Fetching sessions for gateway ${gateway.name}...`);
+    const sessions = await fetchGatewaySessions(gateway.url);
+    allSessions[gateway.id] = sessions;
+    console.log(`[Sessions] Found ${sessions.length} sessions for ${gateway.name}:`, sessions.map(s => s.name));
+  }
+  
+  store.set('sessions', allSessions);
+  return allSessions;
+}
+
+// Create a session window
+function createSessionWindow(gatewayId, session) {
+  const gateway = store.get('gateways').find(g => g.id === gatewayId);
+  if (!gateway) {
+    console.error(`[Sessions] Gateway ${gatewayId} not found`);
+    return null;
+  }
+  
+  // Check if window already exists
+  if (sessionWindows.has(session.id)) {
+    const existingWindow = sessionWindows.get(session.id);
+    if (!existingWindow.isDestroyed()) {
+      existingWindow.show();
+      existingWindow.focus();
+      return existingWindow;
+    } else {
+      sessionWindows.delete(session.id);
+    }
+  }
+  
+  // Get saved bounds or default offset from main window
+  const savedBounds = store.get('sessionWindowBounds')[session.id];
+  const mainBounds = store.get('windowBounds');
+  
+  const bounds = savedBounds || {
+    x: (mainBounds.x || 100) + 50,
+    y: (mainBounds.y || 100) + 50,
+    width: mainBounds.width || 400,
+    height: mainBounds.height || 600
+  };
+  
+  const sessionWindow = new BrowserWindow({
+    width: bounds.width,
+    height: bounds.height,
+    x: bounds.x,
+    y: bounds.y,
+    frame: false,
+    alwaysOnTop: true,
+    skipTaskbar: true,
+    resizable: true,
+    show: false,
+    transparent: false,
+    visibleOnAllWorkspaces: true,
+    webPreferences: {
+      nodeIntegration: false,
+      contextIsolation: true,
+      preload: path.join(__dirname, 'preload-session.js'),
+      webviewTag: true,
+    }
+  });
+  
+  if (process.platform === 'darwin') {
+    sessionWindow.setAlwaysOnTop(true, 'screen-saver');
+    sessionWindow.setVisibleOnAllWorkspaces(true, { visibleOnFullScreen: true });
+  } else {
+    sessionWindow.setAlwaysOnTop(true, 'screen-saver');
+  }
+  
+  // Load session-specific HTML (we'll create this)
+  sessionWindow.loadFile(path.join(__dirname, '..', 'renderer', 'session.html'));
+  
+  // Store window reference
+  sessionWindows.set(session.id, sessionWindow);
+  
+  // Track active session windows
+  const activeWindows = store.get('activeSessionWindows');
+  activeWindows[sessionWindow.id] = { gatewayId, sessionId: session.id };
+  store.set('activeSessionWindows', activeWindows);
+  
+  // Inject CSS/JS into webview when attached
+  sessionWindow.webContents.on('did-attach-webview', (event, wvWebContents) => {
+    console.log(`[Sessions] Session ${session.name} webview attached`);
+    
+    wvWebContents.on('dom-ready', () => {
+      // wvWebContents.insertCSS(OPENCLAW_CSS).catch(e => console.error('Session CSS injection failed:', e));
+      // wvWebContents.executeJavaScript(OPENCLAW_JS).catch(e => console.error('Session JS injection failed:', e));
+      console.log(`[Sessions] CSS/JS injection disabled for session ${session.name}`);
+    });
+  });
+  
+  // Save bounds on move/resize
+  const saveBounds = () => {
+    if (!sessionWindow.isDestroyed()) {
+      const allBounds = store.get('sessionWindowBounds');
+      allBounds[session.id] = sessionWindow.getBounds();
+      store.set('sessionWindowBounds', allBounds);
+    }
+  };
+  sessionWindow.on('move', saveBounds);
+  sessionWindow.on('resize', saveBounds);
+  
+  // Hide on blur (like main window)
+  sessionWindow.on('blur', () => {
+    if (sessionWindow.isVisible()) {
+      sessionWindow.hide();
+    }
+  });
+  
+  // Handle keyboard shortcuts
+  sessionWindow.webContents.on('before-input-event', (event, input) => {
+    if (input.key === 'Escape') {
+      sessionWindow.hide();
+    }
+    // Cycling shortcuts
+    if (input.type === 'keyDown' && input.shift && (input.meta || input.control)) {
+      if (input.key === 'ArrowRight') {
+        event.preventDefault();
+        cycleWindows('next');
+      } else if (input.key === 'ArrowLeft') {
+        event.preventDefault();
+        cycleWindows('prev');
+      } else if (input.key === 'k' || input.key === 'K') {
+        event.preventDefault();
+        toggleTheme();
+      }
+    }
+  });
+  
+  // Clean up on close
+  sessionWindow.on('closed', () => {
+    sessionWindows.delete(session.id);
+    const activeWindows = store.get('activeSessionWindows');
+    delete activeWindows[sessionWindow.id];
+    store.set('activeSessionWindows', activeWindows);
+  });
+  
+  sessionWindow.once('ready-to-show', () => {
+    sessionWindow.show();
+    // Send session info to renderer
+    sessionWindow.webContents.send('load-session', {
+      gateway: gateway,
+      session: session
+    });
+  });
+  
+  return sessionWindow;
+}
+
+// IPC handlers for session management
+ipcMain.handle('get-sessions', async (e, gatewayId) => {
+  if (gatewayId) {
+    const sessions = store.get('sessions')[gatewayId] || [];
+    return sessions;
+  }
+  return store.get('sessions');
+});
+
+ipcMain.handle('refresh-sessions', async (e, gatewayId) => {
+  if (gatewayId) {
+    const gateway = store.get('gateways').find(g => g.id === gatewayId);
+    if (gateway) {
+      const sessions = await fetchGatewaySessions(gateway.url);
+      const allSessions = store.get('sessions');
+      allSessions[gatewayId] = sessions;
+      store.set('sessions', allSessions);
+      return sessions;
+    }
+    return [];
+  } else {
+    return await refreshAllSessions();
+  }
+});
+
+ipcMain.handle('open-session', (e, gatewayId, sessionData) => {
+  const window = createSessionWindow(gatewayId, sessionData);
+  return window !== null;
+});
+
+ipcMain.handle('close-session', (e, sessionId) => {
+  const window = sessionWindows.get(sessionId);
+  if (window && !window.isDestroyed()) {
+    window.close();
+    return true;
+  }
+  return false;
+});
+
+// ── Visibility Management ─────────────────────────────────────
+
+ipcMain.handle('get-hidden-gateways', () => store.get('hiddenGateways'));
+
+ipcMain.handle('set-gateway-visibility', (e, gatewayId, visible) => {
+  const hiddenGateways = store.get('hiddenGateways');
+  if (visible) {
+    // Remove from hidden list
+    const filtered = hiddenGateways.filter(id => id !== gatewayId);
+    store.set('hiddenGateways', filtered);
+  } else {
+    // Add to hidden list
+    if (!hiddenGateways.includes(gatewayId)) {
+      hiddenGateways.push(gatewayId);
+      store.set('hiddenGateways', hiddenGateways);
+    }
+  }
+  return store.get('hiddenGateways');
+});
+
+ipcMain.handle('get-hidden-sessions', (e, gatewayId) => {
+  const hiddenSessions = store.get('hiddenSessions');
+  return hiddenSessions[gatewayId] || [];
+});
+
+ipcMain.handle('set-session-visibility', (e, gatewayId, sessionId, visible) => {
+  const hiddenSessions = store.get('hiddenSessions');
+  const gatewayHidden = hiddenSessions[gatewayId] || [];
+  
+  if (visible) {
+    // Remove from hidden list
+    hiddenSessions[gatewayId] = gatewayHidden.filter(id => id !== sessionId);
+  } else {
+    // Add to hidden list
+    if (!gatewayHidden.includes(sessionId)) {
+      gatewayHidden.push(sessionId);
+      hiddenSessions[gatewayId] = gatewayHidden;
+    }
+  }
+  
+  store.set('hiddenSessions', hiddenSessions);
+  return hiddenSessions[gatewayId] || [];
+});
+
+// Toggle between dark and light theme
+function toggleTheme() {
+  // Cycle: system -> dark -> light -> system
+  // Or simply toggle: dark <-> light
+  if (nativeTheme.themeSource === 'system') {
+    nativeTheme.themeSource = nativeTheme.shouldUseDarkColors ? 'light' : 'dark';
+  } else if (nativeTheme.themeSource === 'dark') {
+    nativeTheme.themeSource = 'light';
+  } else {
+    nativeTheme.themeSource = 'dark';
+  }
+}
+
 // Notify all windows when theme changes
 nativeTheme.on('updated', () => {
   const theme = nativeTheme.shouldUseDarkColors ? 'dark' : 'light';
@@ -193,11 +510,29 @@ function createWindow() {
 
   mainWindow.loadFile(path.join(__dirname, '..', 'renderer', 'index.html'));
 
+  // Open DevTools with Cmd+Option+I
+  mainWindow.webContents.on('before-input-event', (event, input) => {
+    if (input.meta && input.alt && input.key === 'i') {
+      mainWindow.webContents.openDevTools({ mode: 'detach' });
+    }
+  });
+
   // Inject CSS/JS into any webview that loads inside this window
   mainWindow.webContents.on('did-attach-webview', (event, wvWebContents) => {
+    console.log('[Main] Webview attached, URL:', wvWebContents.getURL());
+    
+    wvWebContents.on('did-start-loading', () => console.log('[Main] Webview did-start-loading'));
+    wvWebContents.on('did-stop-loading', () => console.log('[Main] Webview did-stop-loading'));
+    wvWebContents.on('did-fail-load', (e, code, desc) => console.log('[Main] Webview did-fail-load:', code, desc));
+    
     wvWebContents.on('dom-ready', () => {
-      wvWebContents.insertCSS(OPENCLAW_CSS).catch(e => console.error('Main insertCSS failed:', e));
-      wvWebContents.executeJavaScript(OPENCLAW_JS).catch(e => console.error('Main executeJS failed:', e));
+      const url = wvWebContents.getURL();
+      console.log('[Main] Webview dom-ready, URL:', url);
+      
+      // TEMPORARILY DISABLE INJECTION TO DEBUG
+      // wvWebContents.insertCSS(OPENCLAW_CSS).catch(e => console.error('Main insertCSS failed:', e));
+      // wvWebContents.executeJavaScript(OPENCLAW_JS).catch(e => console.error('Main executeJS failed:', e));
+      console.log('[Main] CSS/JS injection DISABLED for debugging');
     });
   });
 
@@ -223,6 +558,19 @@ function createWindow() {
     if (input.key === 'Escape') {
       mainWindow.hide();
     }
+    // Catch window cycling shortcuts even when webview has focus
+    if (input.type === 'keyDown' && input.shift && (input.meta || input.control)) {
+      if (input.key === 'ArrowRight') {
+        event.preventDefault();
+        cycleWindows('next');
+      } else if (input.key === 'ArrowLeft') {
+        event.preventDefault();
+        cycleWindows('prev');
+      } else if (input.key === 'k' || input.key === 'K') {
+        event.preventDefault();
+        toggleTheme();
+      }
+    }
   });
 
   mainWindow.on('closed', () => {
@@ -240,7 +588,7 @@ function openSettings() {
 
   settingsWindow = new BrowserWindow({
     width: 520,
-    height: 560,
+    height: 640,
     resizable: false,
     frame: false,
     webPreferences: {
@@ -261,36 +609,146 @@ function openSettings() {
   });
 }
 
-// ── Agent Switching Shortcuts ─────────────────────────────────
+// ── Enhanced Window Cycling (Gateway → Sessions → Next Gateway) ─
 
-function cycleGateway(direction) {
+function getAllWindowsInOrder() {
   const gateways = store.get('gateways');
-  if (gateways.length < 2) return; // Nothing to cycle
+  const allSessions = store.get('sessions');
+  const hiddenGateways = store.get('hiddenGateways');
+  const hiddenSessions = store.get('hiddenSessions');
+  const windows = [];
+  
+  for (const gateway of gateways) {
+    // Skip hidden gateways
+    if (hiddenGateways.includes(gateway.id)) {
+      continue;
+    }
+    
+    // Add main gateway window
+    windows.push({
+      type: 'gateway',
+      gatewayId: gateway.id,
+      gateway: gateway,
+      window: mainWindow
+    });
+    
+    // Add session windows for this gateway
+    const sessions = allSessions[gateway.id] || [];
+    const hiddenSessionsForGateway = hiddenSessions[gateway.id] || [];
+    
+    for (const session of sessions) {
+      // Skip hidden sessions
+      if (hiddenSessionsForGateway.includes(session.id)) {
+        continue;
+      }
+      
+      const sessionWindow = sessionWindows.get(session.id);
+      if (sessionWindow && !sessionWindow.isDestroyed()) {
+        windows.push({
+          type: 'session',
+          gatewayId: gateway.id,
+          sessionId: session.id,
+          gateway: gateway,
+          session: session,
+          window: sessionWindow
+        });
+      }
+    }
+  }
+  
+  return windows;
+}
+
+function getCurrentlyFocusedWindow() {
+  const focused = BrowserWindow.getFocusedWindow();
+  if (!focused) return null;
+  
+  if (focused === mainWindow) {
+    return { type: 'gateway', window: mainWindow };
+  }
+  
+  for (const [sessionId, sessionWindow] of sessionWindows.entries()) {
+    if (sessionWindow === focused) {
+      return { type: 'session', sessionId, window: sessionWindow };
+    }
+  }
+  
+  return null;
+}
+
+function cycleWindows(direction) {
+  const allWindows = getAllWindowsInOrder();
+  if (allWindows.length === 0) return;
+  
+  const currentWindow = getCurrentlyFocusedWindow();
+  if (!currentWindow) {
+    // No window focused, show main window
+    if (mainWindow && !mainWindow.isDestroyed()) {
+      mainWindow.show();
+      mainWindow.focus();
+    }
+    return;
+  }
+  
+  // Find current window index
+  let currentIndex = -1;
+  for (let i = 0; i < allWindows.length; i++) {
+    const w = allWindows[i];
+    if (currentWindow.type === 'gateway' && w.type === 'gateway') {
+      currentIndex = i;
+      break;
+    } else if (currentWindow.type === 'session' && w.type === 'session' && w.sessionId === currentWindow.sessionId) {
+      currentIndex = i;
+      break;
+    }
+  }
   
-  const activeId = store.get('activeGateway');
-  const currentIndex = gateways.findIndex(g => g.id === activeId);
+  if (currentIndex === -1) {
+    currentIndex = 0; // Fallback
+  }
   
-  let newIndex;
+  // Calculate next index
+  let nextIndex;
   if (direction === 'next') {
-    newIndex = (currentIndex + 1) % gateways.length;
+    nextIndex = (currentIndex + 1) % allWindows.length;
   } else {
-    newIndex = (currentIndex - 1 + gateways.length) % gateways.length;
+    nextIndex = (currentIndex - 1 + allWindows.length) % allWindows.length;
   }
   
-  const newGateway = gateways[newIndex];
-  store.set('activeGateway', newGateway.id);
+  const nextWindow = allWindows[nextIndex];
   
-  // Notify main window to switch gateway
-  if (mainWindow && !mainWindow.isDestroyed()) {
-    mainWindow.webContents.send('switch-gateway', newGateway.id);
+  // Hide current window
+  if (currentWindow.window && !currentWindow.window.isDestroyed()) {
+    currentWindow.window.hide();
+  }
+  
+  // Show and focus next window
+  if (nextWindow.window && !nextWindow.window.isDestroyed()) {
+    nextWindow.window.show();
+    nextWindow.window.focus();
+    
+    // If switching to main window, update active gateway
+    if (nextWindow.type === 'gateway') {
+      store.set('activeGateway', nextWindow.gatewayId);
+      if (mainWindow && !mainWindow.isDestroyed()) {
+        mainWindow.webContents.send('switch-gateway', nextWindow.gatewayId);
+      }
+    }
   }
 }
 
+// Legacy function for backward compatibility
+function cycleGateway(direction) {
+  cycleWindows(direction);
+}
+
 // ── Toggle / Tray / Hotkey ────────────────────────────────────
 
 function toggleWindow() {
   if (!mainWindow || mainWindow.isDestroyed()) {
     createWindow();
+    // Update updater's main window reference
+    updater.setMainWindow(mainWindow);
     return;
   }
   if (mainWindow.isVisible()) {
@@ -313,6 +771,7 @@ function createTray() {
     { label: 'Show/Hide', click: toggleWindow },
     { type: 'separator' },
     { label: 'Settings', click: openSettings },
+    { label: 'Check for Updates...', click: () => updater.checkForUpdate(true) },
     { type: 'separator' },
     { label: 'Quit', click: () => app.quit() }
   ]);
@@ -331,12 +790,16 @@ function registerHotkey() {
     console.error(`Failed to register hotkey: ${hotkey}`);
   }
   
-  // Agent switching shortcuts (Cmd+Shift+Right/Left)
-  const nextRegistered = globalShortcut.register('CommandOrControl+Shift+Right', () => cycleGateway('next'));
-  const prevRegistered = globalShortcut.register('CommandOrControl+Shift+Left', () => cycleGateway('prev'));
+  // Window cycling shortcuts (Cmd+Shift+Right/Left)
+  const nextRegistered = globalShortcut.register('CommandOrControl+Shift+Right', () => cycleWindows('next'));
+  const prevRegistered = globalShortcut.register('CommandOrControl+Shift+Left', () => cycleWindows('prev'));
   
   if (!nextRegistered) console.error('Failed to register Cmd+Shift+Right');
   if (!prevRegistered) console.error('Failed to register Cmd+Shift+Left');
+  
+  // Theme toggle shortcut (Cmd+Shift+K)
+  const themeRegistered = globalShortcut.register('CommandOrControl+Shift+K', toggleTheme);
+  if (!themeRegistered) console.error('Failed to register Cmd+Shift+K for theme toggle');
 }
 
 if (process.platform === 'darwin') {
@@ -347,6 +810,22 @@ app.whenReady().then(() => {
   createWindow();
   createTray();
   registerHotkey();
+  
+  // Initialize auto-updater
+  updater.registerIpcHandlers();
+  updater.setMainWindow(mainWindow);
+  
+  // Check for updates on launch (respects 24h cache)
+  updater.checkForUpdate(false);
+  
+  // Refresh sessions for all gateways on startup
+  setTimeout(() => {
+    refreshAllSessions().then(() => {
+      console.log('[Sessions] Initial session refresh completed');
+    }).catch(err => {
+      console.log('[Sessions] Initial session refresh failed:', err.message);
+    });
+  }, 2000); // Give gateways time to start
 });
 
 app.on('will-quit', () => {

package/src/main/preload-session.js

@@ -0,0 +1,16 @@
+const { contextBridge, ipcRenderer } = require('electron');
+
+contextBridge.exposeInMainWorld('electronAPI', {
+  // Window management
+  closeWindow: () => {
+    const window = require('@electron/remote').getCurrentWindow();
+    window.close();
+  },
+  
+  // Theme support
+  getTheme: () => ipcRenderer.invoke('get-theme'),
+  onThemeChanged: (cb) => ipcRenderer.on('theme-changed', (_event, theme) => cb(theme)),
+  
+  // Session loading
+  onLoadSession: (cb) => ipcRenderer.on('load-session', (_event, sessionData) => cb(sessionData)),
+});

package/src/main/preload-settings.js

@@ -10,4 +10,18 @@ contextBridge.exposeInMainWorld('api', {
   // Theme support
   getTheme: () => ipcRenderer.invoke('get-theme'),
   onThemeChanged: (cb) => ipcRenderer.on('theme-changed', (_event, theme) => cb(theme)),
+  // Session management
+  getSessions: (gatewayId) => ipcRenderer.invoke('get-sessions', gatewayId),
+  refreshSessions: (gatewayId) => ipcRenderer.invoke('refresh-sessions', gatewayId),
+  // Visibility management
+  getHiddenGateways: () => ipcRenderer.invoke('get-hidden-gateways'),
+  setGatewayVisibility: (gatewayId, visible) => ipcRenderer.invoke('set-gateway-visibility', gatewayId, visible),
+  getHiddenSessions: (gatewayId) => ipcRenderer.invoke('get-hidden-sessions', gatewayId),
+  setSessionVisibility: (gatewayId, sessionId, visible) => ipcRenderer.invoke('set-session-visibility', gatewayId, sessionId, visible),
+  // Auto-update support
+  getAppVersion: () => ipcRenderer.invoke('get-app-version'),
+  checkForUpdate: (force) => ipcRenderer.invoke('check-for-update', force),
+  getUpdateState: () => ipcRenderer.invoke('get-update-state'),
+  startUpdate: () => ipcRenderer.invoke('start-update'),
+  onUpdateStateChanged: (cb) => ipcRenderer.on('update-state-changed', (_event, state) => cb(state)),
 });