Manage workspaces using trpc/lowdb, implement recent projects

apps/desktop/package.json

@@ -49,6 +49,7 @@
 		"framer-motion": "^12.23.24",
 		"http-proxy": "^1.18.1",
 		"lowdb": "^7.0.1",
+		"nanoid": "^5.1.6",
 		"node-pty": "1.1.0-beta30",
 		"react": "^19.1.1",
 		"react-arborist": "^3.4.3",
@@ -63,6 +64,7 @@
 		"superjson": "^2.2.5",
 		"tailwind-merge": "^2.6.0",
 		"trpc-electron": "^0.1.2",
+		"zod": "^4.1.12",
 		"zustand": "^5.0.8"
 	},
 	"devDependencies": {

apps/desktop/src/lib/trpc/routers/index.ts

@@ -1,6 +1,8 @@
 import type { BrowserWindow } from "electron";
 import { router } from "..";
 import { createWindowRouter } from "./window";
+import { createProjectsRouter } from "./projects";
+import { createWorkspacesRouter } from "./workspaces";
 
 /**
  * Main application router
@@ -9,6 +11,8 @@ import { createWindowRouter } from "./window";
 export const createAppRouter = (window: BrowserWindow) => {
 	return router({
 		window: createWindowRouter(window),
+		projects: createProjectsRouter(window),
+		workspaces: createWorkspacesRouter(),
 	});
 };
 

apps/desktop/src/lib/trpc/routers/projects/index.ts

@@ -0,0 +1,2 @@
+export { createProjectsRouter } from "./projects";
+export type { ProjectsRouter } from "./projects";

apps/desktop/src/lib/trpc/routers/projects/projects.ts

@@ -0,0 +1,91 @@
+import { dialog } from "electron";
+import type { BrowserWindow } from "electron";
+import { basename } from "node:path";
+import { z } from "zod";
+import { publicProcedure, router } from "../..";
+import { db } from "../../../../main/lib/db";
+import type { RecentProject } from "../../../../main/lib/db/schemas";
+
+/**
+ * Projects router
+ * Handles project selection, recents management, and workspace creation
+ */
+export const createProjectsRouter = (window: BrowserWindow) => {
+	return router({
+		/**
+		 * Open a new project via folder picker
+		 * Adds to recents and returns path for UI to handle
+		 */
+		openProject: publicProcedure.mutation(async () => {
+			const result = await dialog.showOpenDialog(window, {
+				properties: ["openDirectory"],
+				title: "Open Project",
+			});
+
+			if (result.canceled || result.filePaths.length === 0) {
+				return { success: false as const };
+			}
+
+			const path = result.filePaths[0];
+			const name = basename(path);
+
+			await db.update((data) => {
+				const existingIndex = data.recentProjects.findIndex(
+					(p) => p.path === path,
+				);
+				if (existingIndex !== -1) {
+					data.recentProjects[existingIndex].lastOpenedAt = Date.now();
+				} else {
+					data.recentProjects.push({
+						path,
+						name,
+						lastOpenedAt: Date.now(),
+					});
+				}
+			});
+
+			return {
+				success: true as const,
+				path,
+				name,
+			};
+		}),
+		openRecent: publicProcedure
+			.input(z.object({ path: z.string() }))
+			.mutation(async ({ input }) => {
+				const { path } = input;
+				const name = basename(path);
+
+				await db.update((data) => {
+					const recent = data.recentProjects.find((p) => p.path === path);
+					if (recent) {
+						recent.lastOpenedAt = Date.now();
+					}
+				});
+
+				return {
+					success: true as const,
+					path,
+					name,
+				};
+			}),
+		getRecents: publicProcedure.query((): RecentProject[] => {
+			return db.data.recentProjects
+				.slice()
+				.sort((a, b) => b.lastOpenedAt - a.lastOpenedAt);
+		}),
+		removeRecent: publicProcedure
+			.input(z.object({ path: z.string() }))
+			.mutation(async ({ input }) => {
+				await db.update((data) => {
+					data.recentProjects = data.recentProjects.filter(
+						(p) => p.path !== input.path,
+					);
+				});
+
+				return { success: true };
+			}),
+	});
+};
+
+export type ProjectsRouter = ReturnType<typeof createProjectsRouter>;

apps/desktop/src/lib/trpc/routers/workspaces/index.ts

@@ -0,0 +1,2 @@
+export { createWorkspacesRouter } from "./workspaces";
+export type { WorkspacesRouter } from "./workspaces";

apps/desktop/src/lib/trpc/routers/workspaces/workspaces.ts

@@ -0,0 +1,216 @@
+import { z } from "zod";
+import { nanoid } from "nanoid";
+import { publicProcedure, router } from "../..";
+import { db } from "../../../../main/lib/db";
+
+/**
+ * Workspaces router
+ * Handles workspace CRUD operations
+ */
+export const createWorkspacesRouter = () => {
+	return router({
+		/**
+		 * Create a new workspace
+		 */
+		create: publicProcedure
+			.input(
+				z.object({
+					name: z.string(),
+					path: z.string().nullable().optional(),
+				}),
+			)
+			.mutation(async ({ input }) => {
+				// Set order to be at the end of the list
+				const maxOrder = db.data.workspaces.length > 0
+					? Math.max(...db.data.workspaces.map((w) => w.order))
+					: -1;
+
+				const workspace = {
+					id: nanoid(),
+					name: input.name,
+					path: input.path ?? null,
+					order: maxOrder + 1,
+					createdAt: Date.now(),
+					updatedAt: Date.now(),
+					lastOpenedAt: Date.now(),
+				};
+
+				await db.update((data) => {
+					data.workspaces.push(workspace);
+					data.settings.lastActiveWorkspaceId = workspace.id;
+				});
+
+				return workspace;
+			}),
+
+		/**
+		 * Get a workspace by ID
+		 */
+		get: publicProcedure
+			.input(z.object({ id: z.string() }))
+			.query(({ input }) => {
+				const workspace = db.data.workspaces.find((w) => w.id === input.id);
+				return workspace || null;
+			}),
+
+		/**
+		 * Get all workspaces sorted by order
+		 */
+		getAll: publicProcedure.query(() => {
+			return db.data.workspaces
+				.slice()
+				.sort((a, b) => a.order - b.order);
+		}),
+
+		/**
+		 * Get the last active workspace
+		 */
+		getActive: publicProcedure.query(() => {
+			const { lastActiveWorkspaceId } = db.data.settings;
+
+			if (!lastActiveWorkspaceId) {
+				return null;
+			}
+
+			return db.data.workspaces.find((w) => w.id === lastActiveWorkspaceId) || null;
+		}),
+
+		/**
+		 * Update a workspace
+		 * Supports partial updates to workspace properties
+		 */
+		update: publicProcedure
+			.input(
+				z.object({
+					id: z.string(),
+					patch: z.object({
+						name: z.string().optional(),
+						path: z.string().nullable().optional(),
+					}),
+				}),
+			)
+			.mutation(async ({ input }) => {
+				await db.update((data) => {
+					const workspace = data.workspaces.find((w) => w.id === input.id);
+					if (!workspace) {
+						throw new Error(`Workspace ${input.id} not found`);
+					}
+
+					// Apply patches
+					if (input.patch.name !== undefined) {
+						workspace.name = input.patch.name;
+					}
+					if (input.patch.path !== undefined) {
+						workspace.path = input.patch.path;
+					}
+
+					// Update timestamps
+					workspace.updatedAt = Date.now();
+					workspace.lastOpenedAt = Date.now();
+				});
+
+				return { success: true };
+			}),
+
+		/**
+		 * Delete a workspace
+		 * Also removes from recents if no other workspace uses that path
+		 */
+		delete: publicProcedure
+			.input(z.object({ id: z.string() }))
+			.mutation(async ({ input }) => {
+				const workspace = db.data.workspaces.find((w) => w.id === input.id);
+
+				if (!workspace) {
+					return { success: false, error: "Workspace not found" };
+				}
+
+				const workspacePath = workspace.path;
+
+				await db.update((data) => {
+					// Remove workspace
+					data.workspaces = data.workspaces.filter((w) => w.id !== input.id);
+
+					// Check if any other workspace uses this path
+					const otherWorkspaceWithSamePath = data.workspaces.some(
+						(w) => w.path === workspacePath,
+					);
+
+					// If no other workspace uses this path, remove from recents
+					if (!otherWorkspaceWithSamePath) {
+						data.recentProjects = data.recentProjects.filter(
+							(p) => p.path !== workspacePath,
+						);
+					}
+
+					// Update last active workspace if needed
+					if (data.settings.lastActiveWorkspaceId === input.id) {
+						// Set to the most recently opened workspace, if any
+						const sorted = data.workspaces
+							.slice()
+							.sort((a, b) => b.lastOpenedAt - a.lastOpenedAt);
+						data.settings.lastActiveWorkspaceId = sorted[0]?.id || undefined;
+					}
+				});
+
+				return { success: true };
+			}),
+
+		/**
+		 * Set active workspace
+		 */
+		setActive: publicProcedure
+			.input(z.object({ id: z.string() }))
+			.mutation(async ({ input }) => {
+				await db.update((data) => {
+					const workspace = data.workspaces.find((w) => w.id === input.id);
+					if (!workspace) {
+						throw new Error(`Workspace ${input.id} not found`);
+					}
+
+					data.settings.lastActiveWorkspaceId = input.id;
+					workspace.lastOpenedAt = Date.now();
+					workspace.updatedAt = Date.now();
+				});
+
+				return { success: true };
+			}),
+
+		/**
+		 * Reorder workspaces
+		 */
+		reorder: publicProcedure
+			.input(
+				z.object({
+					fromIndex: z.number(),
+					toIndex: z.number(),
+				}),
+			)
+			.mutation(async ({ input }) => {
+				await db.update((data) => {
+					const { fromIndex, toIndex } = input;
+
+					// Get all workspaces sorted by order
+					const workspaces = data.workspaces
+						.slice()
+						.sort((a, b) => a.order - b.order);
+
+					// Move workspace from fromIndex to toIndex
+					const [removed] = workspaces.splice(fromIndex, 1);
+					workspaces.splice(toIndex, 0, removed);
+
+					// Update order fields to reflect new positions
+					workspaces.forEach((workspace, index) => {
+						const ws = data.workspaces.find((w) => w.id === workspace.id);
+						if (ws) {
+							ws.order = index;
+						}
+					});
+				});
+
+				return { success: true };
+			}),
+	});
+};
+
+export type WorkspacesRouter = ReturnType<typeof createWorkspacesRouter>;

apps/desktop/src/main/index.ts

@@ -3,6 +3,7 @@ import { app } from "electron";
 import { makeAppSetup } from "lib/electron-app/factories/app/setup";
 import { registerStorageHandlers } from "./lib/storage-ipcs";
 import { MainWindow } from "./windows/main";
+import { initDb } from "./lib/db";
 
 // Protocol scheme for deep linking
 const PROTOCOL_SCHEME = "superset";
@@ -31,6 +32,9 @@ registerStorageHandlers();
 (async () => {
 	await app.whenReady();
 
+	// Initialize database
+	await initDb();
+
 	await makeAppSetup(() => MainWindow());
 
 	// Stop all periodic rescans when app is quitting

apps/desktop/src/main/lib/db/index.ts

@@ -0,0 +1,26 @@
+import { JSONFilePreset } from "lowdb/node";
+import { join } from "node:path";
+import { app } from "electron";
+import type { Database } from "./schemas";
+import { defaultDatabase } from "./schemas";
+
+type DB = Awaited<ReturnType<typeof JSONFilePreset<Database>>>;
+
+let _db: DB | null = null;
+
+export async function initDb(): Promise<void> {
+	if (_db) return;
+
+	const dbPath = join(app.getPath("userData"), "db.json");
+	_db = await JSONFilePreset<Database>(dbPath, defaultDatabase);
+	console.log(`Database initialized at: ${dbPath}`);
+}
+
+export const db = new Proxy({} as DB, {
+	get(_target, prop) {
+		if (!_db) {
+			throw new Error("Database not initialized. Call initDb() first.");
+		}
+		return _db[prop as keyof DB];
+	},
+});