initial ws

apps/desktop/src/lib/electron-app/factories/app/setup.ts

@@ -11,7 +11,10 @@ import { ignoreConsoleWarnings } from "../../utils/ignore-console-warnings";
 
 ignoreConsoleWarnings(["Manifest version 2 is deprecated"]);
 
-export async function makeAppSetup(createWindow: () => Promise<BrowserWindow>) {
+export async function makeAppSetup(
+	createWindow: () => Promise<BrowserWindow>,
+	restoreWindows?: () => Promise<void>,
+) {
 	if (ENVIRONMENT.IS_DEV) {
 		try {
 			await installExtension([REACT_DEVELOPER_TOOLS], {
@@ -24,7 +27,19 @@ export async function makeAppSetup(createWindow: () => Promise<BrowserWindow>) {
 		}
 	}
 
-	let window = await createWindow();
+	// Restore windows from previous session if available
+	if (restoreWindows) {
+		await restoreWindows();
+	}
+
+	// If no windows were restored, create a new one
+	const existingWindows = BrowserWindow.getAllWindows();
+	let window: BrowserWindow;
+	if (existingWindows.length > 0) {
+		window = existingWindows[0];
+	} else {
+		window = await createWindow();
+	}
 
 	app.on("activate", async () => {
 		const windows = BrowserWindow.getAllWindows();

apps/desktop/src/main/index.ts

@@ -50,6 +50,11 @@ app.on("open-url", (event, url) => {
 	registerWorkspaceIPCs();
 	registerPortIpcs();
 	registerDeepLinkIpcs();
+	const { registerWindowIPCs } = await import("main/lib/window-ipcs");
+	registerWindowIPCs();
 
-	await makeAppSetup(() => windowManager.createWindow());
+	await makeAppSetup(
+		() => windowManager.createWindow(),
+		() => windowManager.restoreWindows(),
+	);
 })();

apps/desktop/src/main/lib/window-ipcs.ts

@@ -1,4 +1,4 @@
-import { ipcMain } from "electron";
+import { BrowserWindow, ipcMain } from "electron";
 import windowManager from "./window-manager";
 
 export function registerWindowIPCs() {
@@ -14,4 +14,12 @@ export function registerWindowIPCs() {
 			};
 		}
 	});
+
+	ipcMain.handle("window-is-restored", async (event) => {
+		const senderWindow = BrowserWindow.fromWebContents(event.sender);
+		if (!senderWindow) {
+			return false;
+		}
+		return windowManager.isRestoredWindow(senderWindow);
+	});
 }

apps/desktop/src/main/lib/window-manager.ts

@@ -1,19 +1,97 @@
 import type { BrowserWindow } from "electron";
 import { MainWindow } from "../windows/main";
+import windowStateManager from "./window-state-manager";
 
 class WindowManager {
 	private windows: Set<BrowserWindow> = new Set();
 	private windowWorkspaces: Map<BrowserWindow, string | null> = new Map();
+	private restoredWindowIds: Set<number> = new Set();
 
-	async createWindow(): Promise<BrowserWindow> {
+	async createWindow(
+		restoreState?: { workspaceId: string | null; bounds?: Electron.Rectangle },
+	): Promise<BrowserWindow> {
 		const window = await MainWindow();
+
+		// Restore window bounds if provided
+		if (restoreState?.bounds) {
+			window.setBounds(restoreState.bounds);
+		}
+
 		this.windows.add(window);
-		// New windows start with no workspace - user must select one
-		this.windowWorkspaces.set(window, null);
+		const workspaceId = restoreState?.workspaceId ?? null;
+		this.windowWorkspaces.set(window, workspaceId);
+
+		// Mark as restored if we're restoring state
+		if (restoreState) {
+			this.restoredWindowIds.add(window.webContents.id);
+		}
+
+		// Save window state when workspace changes
+		if (workspaceId) {
+			windowStateManager.saveWindowState(window, workspaceId);
+		}
+
+		// Store window ID before it might be destroyed
+		const windowId = window.webContents.id;
+
+		// Save window bounds periodically and on move/resize
+		const saveBounds = () => {
+			// Check if window still exists and is not destroyed
+			if (window.isDestroyed() || !this.windows.has(window)) {
+				return;
+			}
+			const currentWorkspaceId = this.windowWorkspaces.get(window) ?? null;
+			windowStateManager.saveWindowState(window, currentWorkspaceId);
+		};
+
+		window.on("moved", saveBounds);
+		window.on("resized", saveBounds);
+
+		window.on("close", () => {
+			// Remove event listeners to prevent them from firing after close
+			window.removeListener("moved", saveBounds);
+			window.removeListener("resized", saveBounds);
+
+			// Save final state before closing (window is still valid here)
+			// Get workspace ID from our map before window might be destroyed
+			const workspaceId = this.windowWorkspaces.get(window) ?? null;
+
+			try {
+				if (!window.isDestroyed()) {
+					const bounds = window.getBounds();
+					// Save using window ID to avoid issues if window is destroyed
+					windowStateManager.saveWindowStateById(windowId, workspaceId, bounds);
+				} else {
+					// Window already destroyed, use last known bounds from state
+					if (workspaceId) {
+						const lastState = windowStateManager.getWindowState(windowId);
+						if (lastState) {
+							windowStateManager.saveWindowStateById(
+								windowId,
+								workspaceId,
+								lastState.bounds,
+							);
+						}
+					}
+				}
+			} catch (error) {
+				// Silently fail if window is destroyed - we'll clean up in closed handler
+				if (!(error instanceof Error && error.message.includes("destroyed"))) {
+					console.error("[WindowManager] Failed to save window state on close:", error);
+				}
+			}
+		});
 
 		window.on("closed", () => {
+			// Remove from state after window is fully closed
+			// Use stored window ID since window is now destroyed
+			setTimeout(() => {
+				windowStateManager.removeWindowState(windowId);
+			}, 100);
+
 			this.windows.delete(window);
 			this.windowWorkspaces.delete(window);
+			this.restoredWindowIds.delete(windowId);
 		});
 
 		return window;
@@ -33,6 +111,43 @@ class WindowManager {
 
 	setWorkspaceForWindow(window: BrowserWindow, workspaceId: string | null): void {
 		this.windowWorkspaces.set(window, workspaceId);
+		// Persist the workspace association
+		windowStateManager.saveWindowState(window, workspaceId);
+	}
+
+	isRestoredWindow(window: BrowserWindow): boolean {
+		return this.restoredWindowIds.has(window.webContents.id);
+	}
+
+	async restoreWindows(): Promise<void> {
+		const savedStates = windowStateManager.getWindowStates();
+
+		// Only restore windows that have a workspace assigned
+		// Windows without workspace were likely closed intentionally
+		const windowsToRestore = savedStates.filter((state) => state.workspaceId);
+		const windowsWithoutWorkspace = savedStates.filter(
+			(state) => !state.workspaceId,
+		);
+
+		// Clean up windows without workspaces (they were closed intentionally)
+		for (const state of windowsWithoutWorkspace) {
+			windowStateManager.removeWindowState(Number.parseInt(state.id, 10));
+		}
+
+		// Restore all saved windows with workspaces
+		for (const state of windowsToRestore) {
+			try {
+				await this.createWindow({
+					workspaceId: state.workspaceId,
+					bounds: state.bounds,
+				});
+			} catch (error) {
+				console.error(
+					`[WindowManager] Failed to restore window ${state.id}:`,
+					error,
+				);
+			}
+		}
 	}
 }
 

apps/desktop/src/main/lib/window-state-manager.ts

@@ -0,0 +1,160 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import type { BrowserWindow } from "electron";
+
+interface WindowState {
+	id: string; // webContents.id as string
+	workspaceId: string | null;
+	bounds: {
+		x: number;
+		y: number;
+		width: number;
+		height: number;
+	};
+}
+
+interface WindowStateConfig {
+	windows: WindowState[];
+}
+
+class WindowStateManager {
+	private static instance: WindowStateManager;
+	private statePath: string;
+	private stateDir: string;
+
+	private constructor() {
+		this.stateDir = path.join(os.homedir(), ".superset");
+		this.statePath = path.join(this.stateDir, "window-state.json");
+		this.ensureStateExists();
+	}
+
+	static getInstance(): WindowStateManager {
+		if (!WindowStateManager.instance) {
+			WindowStateManager.instance = new WindowStateManager();
+		}
+		return WindowStateManager.instance;
+	}
+
+	private ensureStateExists(): void {
+		// Create directory if it doesn't exist
+		if (!existsSync(this.stateDir)) {
+			mkdirSync(this.stateDir, { recursive: true });
+		}
+
+		// Create state file with default structure if it doesn't exist
+		if (!existsSync(this.statePath)) {
+			const defaultState: WindowStateConfig = {
+				windows: [],
+			};
+			writeFileSync(
+				this.statePath,
+				JSON.stringify(defaultState, null, 2),
+				"utf-8",
+			);
+		}
+	}
+
+	read(): WindowStateConfig {
+		try {
+			const content = readFileSync(this.statePath, "utf-8");
+			return JSON.parse(content) as WindowStateConfig;
+		} catch (error) {
+			console.error("Failed to read window state:", error);
+			return { windows: [] };
+		}
+	}
+
+	write(state: WindowStateConfig): boolean {
+		try {
+			writeFileSync(this.statePath, JSON.stringify(state, null, 2), "utf-8");
+			return true;
+		} catch (error) {
+			console.error("Failed to write window state:", error);
+			return false;
+		}
+	}
+
+	saveWindowState(window: BrowserWindow, workspaceId: string | null): void {
+		// Check if window is destroyed before accessing properties
+		if (window.isDestroyed()) {
+			return;
+		}
+
+		try {
+			const state = this.read();
+			const windowId = String(window.webContents.id);
+			const bounds = window.getBounds();
+
+			const existingIndex = state.windows.findIndex((w) => w.id === windowId);
+			const windowState: WindowState = {
+				id: windowId,
+				workspaceId,
+				bounds,
+			};
+
+			if (existingIndex >= 0) {
+				state.windows[existingIndex] = windowState;
+			} else {
+				state.windows.push(windowState);
+			}
+
+			this.write(state);
+		} catch (error) {
+			// Window might be destroyed between check and access
+			if (error instanceof Error && error.message.includes("destroyed")) {
+				return;
+			}
+			console.error("[WindowStateManager] Failed to save window state:", error);
+		}
+	}
+
+	saveWindowStateById(
+		windowId: number,
+		workspaceId: string | null,
+		bounds: Electron.Rectangle,
+	): void {
+		try {
+			const state = this.read();
+			const id = String(windowId);
+			const windowState: WindowState = {
+				id,
+				workspaceId,
+				bounds,
+			};
+
+			const existingIndex = state.windows.findIndex((w) => w.id === id);
+			if (existingIndex >= 0) {
+				state.windows[existingIndex] = windowState;
+			} else {
+				state.windows.push(windowState);
+			}
+
+			this.write(state);
+		} catch (error) {
+			console.error("[WindowStateManager] Failed to save window state by ID:", error);
+		}
+	}
+
+	removeWindowState(windowId: number): void {
+		const state = this.read();
+		state.windows = state.windows.filter((w) => w.id !== String(windowId));
+		this.write(state);
+	}
+
+	getWindowStates(): WindowState[] {
+		return this.read().windows;
+	}
+
+	getWindowState(windowId: number): WindowState | undefined {
+		const state = this.read();
+		return state.windows.find((w) => w.id === String(windowId));
+	}
+
+	clearAll(): void {
+		this.write({ windows: [] });
+	}
+}
+
+export default WindowStateManager.getInstance();
+

apps/desktop/src/renderer/screens/main/MainScreen.tsx

@@ -164,7 +164,7 @@ export function MainScreen() {
 					/>
 
 					{/* Main content area - conditionally render based on mode */}
-					<div className="flex-1 overflow-hidden">
+					<div className="flex-1 overflow-hidden p-2 gap-2">
 						<MainContentArea
 							mode={mode}
 							loading={loading}

apps/desktop/src/renderer/screens/main/components/AppFrame/AppFrame.tsx

@@ -4,7 +4,7 @@ interface AppFrameProps {
 
 export function AppFrame({ children }: AppFrameProps) {
 	return (
-		<div className="absolute inset-0 p-2 bg-stone-950 flex gap-2">
+		<div className="absolute inset-0 bg-stone-950 flex">
 			{children}
 		</div>
 	);