implementing favorite apps feature (#1410)

drizzle/0013_damp_mephistopheles.sql

+ALTER TABLE `apps` ADD `is_favorite` integer DEFAULT 0 NOT NULL;
\ No newline at end of file

drizzle/meta/_journal.json

@@ -92,6 +92,13 @@
       "when": 1758320228637,
       "tag": "0012_bouncy_fenris",
       "breakpoints": true
+    },
+    {
+      "idx": 13,
+      "version": "6",
+      "when": 1759068733234,
+      "tag": "0013_damp_mephistopheles",
+      "breakpoints": true
     }
   ]
 }
\ No newline at end of file

e2e-tests/favorite_app.spec.ts

+import { test } from "./helpers/test_helper";
+import { expect } from "@playwright/test";
+
+test.describe("Favorite App Tests", () => {
+  test("Add app to favorite", async ({ po }) => {
+    await po.setUp({ autoApprove: true });
+
+    // Create a test app
+    await po.sendPrompt("create a test app");
+    await po.goToAppsTab();
+
+    // Get the app name from the UI (randomly generated)
+    const appItems = await po.page.getByTestId(/^app-list-item-/).all();
+    expect(appItems.length).toBeGreaterThan(0);
+    const firstAppItem = appItems[0];
+    const testId = await firstAppItem.getAttribute("data-testid");
+    const appName = testId!.replace("app-list-item-", "");
+
+    // Get the app item (assuming it's not favorited initially)
+    const appItem = po.page.locator(`[data-testid="app-list-item-${appName}"]`);
+    await expect(appItem).toBeVisible();
+
+    // Click the favorite button
+    const favoriteButton = appItem
+      .locator("xpath=..")
+      .locator('[data-testid="favorite-button"]');
+    await expect(favoriteButton).toBeVisible();
+    await favoriteButton.click();
+
+    // Check that the star is filled (favorited)
+    const star = favoriteButton.locator("svg");
+    await expect(star).toHaveClass(/fill-\[#6c55dc\]/);
+  });
+
+  test("Remove app from favorite", async ({ po }) => {
+    await po.setUp({ autoApprove: true });
+
+    // Create a test app
+    await po.sendPrompt("create a test app");
+    await po.goToAppsTab();
+
+    // Get the app name from the UI
+    const appItems = await po.page.getByTestId(/^app-list-item-/).all();
+    expect(appItems.length).toBeGreaterThan(0);
+    const firstAppItem = appItems[0];
+    const testId = await firstAppItem.getAttribute("data-testid");
+    const appName = testId!.replace("app-list-item-", "");
+
+    // Get the app item
+    const appItem = po.page.locator(`[data-testid="app-list-item-${appName}"]`);
+
+    // First, add to favorite
+    const favoriteButton = appItem
+      .locator("xpath=..")
+      .locator('[data-testid="favorite-button"]');
+    await favoriteButton.click();
+
+    // Check that the star is filled (favorited)
+    const star = favoriteButton.locator("svg");
+    await expect(star).toHaveClass(/fill-\[#6c55dc\]/);
+
+    // Now, remove from favorite
+    const unfavoriteButton = appItem
+      .locator("xpath=..")
+      .locator('[data-testid="favorite-button"]');
+    await expect(unfavoriteButton).toBeVisible();
+    await unfavoriteButton.click();
+
+    // Check that the star is not filled (unfavorited)
+    await expect(star).not.toHaveClass(/fill-\[#6c55dc\]/);
+  });
+});

src/components/AppList.tsx

 import { useNavigate } from "@tanstack/react-router";
-import { formatDistanceToNow } from "date-fns";
 import { PlusCircle, Search } from "lucide-react";
 import { useAtom, useSetAtom } from "jotai";
 import { selectedAppIdAtom } from "@/atoms/appAtoms";
@@ -8,19 +7,21 @@ import {
   SidebarGroupContent,
   SidebarGroupLabel,
   SidebarMenu,
-  SidebarMenuItem,
 } from "@/components/ui/sidebar";
 import { Button } from "@/components/ui/button";
 import { selectedChatIdAtom } from "@/atoms/chatAtoms";
 import { useLoadApps } from "@/hooks/useLoadApps";
 import { useMemo, useState } from "react";
 import { AppSearchDialog } from "./AppSearchDialog";
-
+import { useAddAppToFavorite } from "@/hooks/useAddAppToFavorite";
+import { AppItem } from "./appItem";
 export function AppList({ show }: { show?: boolean }) {
   const navigate = useNavigate();
   const [selectedAppId, setSelectedAppId] = useAtom(selectedAppIdAtom);
   const setSelectedChatId = useSetAtom(selectedChatIdAtom);
   const { apps, loading, error } = useLoadApps();
+  const { toggleFavorite, isLoading: isFavoriteLoading } =
+    useAddAppToFavorite();
   // search dialog state
   const [isSearchDialogOpen, setIsSearchDialogOpen] = useState(false);
 
@@ -35,6 +36,17 @@ export function AppList({ show }: { show?: boolean }) {
       })),
     [apps],
   );
+
+  const favoriteApps = useMemo(
+    () => apps.filter((app) => app.isFavorite),
+    [apps],
+  );
+
+  const nonFavoriteApps = useMemo(
+    () => apps.filter((app) => !app.isFavorite),
+    [apps],
+  );
+
   if (!show) {
     return null;
   }
@@ -54,6 +66,11 @@ export function AppList({ show }: { show?: boolean }) {
     // We'll eventually need a create app workflow
   };
 
+  const handleToggleFavorite = (appId: number, e: React.MouseEvent) => {
+    e.stopPropagation();
+    toggleFavorite(appId);
+  };
+
   return (
     <>
       <SidebarGroup
@@ -95,28 +112,27 @@ export function AppList({ show }: { show?: boolean }) {
               </div>
             ) : (
               <SidebarMenu className="space-y-1" data-testid="app-list">
-                {apps.map((app) => (
-                  <SidebarMenuItem key={app.id} className="mb-1">
-                    <Button
-                      variant="ghost"
-                      onClick={() => handleAppClick(app.id)}
-                      className={`justify-start w-full text-left py-3 hover:bg-sidebar-accent/80 ${
-                        selectedAppId === app.id
-                          ? "bg-sidebar-accent text-sidebar-accent-foreground"
-                          : ""
-                      }`}
-                      data-testid={`app-list-item-${app.name}`}
-                    >
-                      <div className="flex flex-col w-full">
-                        <span className="truncate">{app.name}</span>
-                        <span className="text-xs text-gray-500">
-                          {formatDistanceToNow(new Date(app.createdAt), {
-                            addSuffix: true,
-                          })}
-                        </span>
-                      </div>
-                    </Button>
-                  </SidebarMenuItem>
+                <SidebarGroupLabel>Favorite apps</SidebarGroupLabel>
+                {favoriteApps.map((app) => (
+                  <AppItem
+                    key={app.id}
+                    app={app}
+                    handleAppClick={handleAppClick}
+                    selectedAppId={selectedAppId}
+                    handleToggleFavorite={handleToggleFavorite}
+                    isFavoriteLoading={isFavoriteLoading}
+                  />
+                ))}
+                <SidebarGroupLabel>Other apps</SidebarGroupLabel>
+                {nonFavoriteApps.map((app) => (
+                  <AppItem
+                    key={app.id}
+                    app={app}
+                    handleAppClick={handleAppClick}
+                    selectedAppId={selectedAppId}
+                    handleToggleFavorite={handleToggleFavorite}
+                    isFavoriteLoading={isFavoriteLoading}
+                  />
                 ))}
               </SidebarMenu>
             )}

src/components/appItem.tsx

+import { formatDistanceToNow } from "date-fns";
+import { Star } from "lucide-react";
+import { SidebarMenuItem } from "@/components/ui/sidebar";
+import { Button } from "@/components/ui/button";
+import { App } from "@/ipc/ipc_types";
+
+type AppItemProps = {
+  app: App;
+  handleAppClick: (id: number) => void;
+  selectedAppId: number | null;
+  handleToggleFavorite: (appId: number, e: React.MouseEvent) => void;
+  isFavoriteLoading: boolean;
+};
+
+export function AppItem({
+  app,
+  handleAppClick,
+  selectedAppId,
+  handleToggleFavorite,
+  isFavoriteLoading,
+}: AppItemProps) {
+  return (
+    <SidebarMenuItem className="mb-1 relative ">
+      <div className="flex w-[200px] items-center">
+        <Button
+          variant="ghost"
+          onClick={() => handleAppClick(app.id)}
+          className={`justify-start w-full text-left py-3 hover:bg-sidebar-accent/80 ${
+            selectedAppId === app.id
+              ? "bg-sidebar-accent text-sidebar-accent-foreground"
+              : ""
+          }`}
+          data-testid={`app-list-item-${app.name}`}
+        >
+          <div className="flex flex-col w-4/5">
+            <span className="truncate">{app.name}</span>
+            <span className="text-xs text-gray-500">
+              {formatDistanceToNow(new Date(app.createdAt), {
+                addSuffix: true,
+              })}
+            </span>
+          </div>
+        </Button>
+        <Button
+          variant="ghost"
+          size="sm"
+          onClick={(e) => handleToggleFavorite(app.id, e)}
+          disabled={isFavoriteLoading}
+          className="absolute top-1 right-1 p-1 mx-1 h-6 w-6 z-10"
+          key={app.id}
+          data-testid="favorite-button"
+        >
+          <Star
+            size={12}
+            className={
+              app.isFavorite
+                ? "fill-[#6c55dc] text-[#6c55dc]"
+                : selectedAppId === app.id
+                  ? "hover:fill-black hover:text-black"
+                  : "hover:fill-[#6c55dc] hover:stroke-[#6c55dc] hover:text-[#6c55dc]"
+            }
+          />
+        </Button>
+      </div>
+    </SidebarMenuItem>
+  );
+}

src/db/schema.ts

@@ -39,6 +39,9 @@ export const apps = sqliteTable("apps", {
   installCommand: text("install_command"),
   startCommand: text("start_command"),
   chatContext: text("chat_context", { mode: "json" }),
+  isFavorite: integer("is_favorite", { mode: "boolean" })
+    .notNull()
+    .default(sql`0`),
 });
 
 export const chats = sqliteTable("chats", {

src/hooks/useAddAppToFavorite.ts

+import { useMutation } from "@tanstack/react-query";
+import { IpcClient } from "@/ipc/ipc_client";
+import { showError, showSuccess } from "@/lib/toast";
+import { useAtom } from "jotai";
+import { appsListAtom } from "@/atoms/appAtoms";
+
+export function useAddAppToFavorite() {
+  const [_, setApps] = useAtom(appsListAtom);
+
+  const mutation = useMutation<boolean, Error, number>({
+    mutationFn: async (appId: number): Promise<boolean> => {
+      const result = await IpcClient.getInstance().addAppToFavorite(appId);
+      return result.isFavorite;
+    },
+    onSuccess: (newIsFavorite, appId) => {
+      setApps((currentApps) =>
+        currentApps.map((app) =>
+          app.id === appId ? { ...app, isFavorite: newIsFavorite } : app,
+        ),
+      );
+      showSuccess("App favorite status updated");
+    },
+    onError: (error) => {
+      showError(error.message || "Failed to update favorite status");
+    },
+  });
+
+  return {
+    toggleFavorite: mutation.mutate,
+    toggleFavoriteAsync: mutation.mutateAsync,
+    isLoading: mutation.isPending,
+    error: mutation.error,
+    isError: mutation.isError,
+    isSuccess: mutation.isSuccess,
+  };
+}

src/ipc/handlers/app_handlers.ts

@@ -1075,6 +1075,53 @@ export function registerAppHandlers() {
     },
   );
 
+  ipcMain.handle(
+    "add-to-favorite",
+    async (
+      _,
+      { appId }: { appId: number },
+    ): Promise<{ isFavorite: boolean }> => {
+      return withLock(appId, async () => {
+        try {
+          // Fetch the current isFavorite value
+          const result = await db
+            .select({ isFavorite: apps.isFavorite })
+            .from(apps)
+            .where(eq(apps.id, appId))
+            .limit(1);
+
+          if (result.length === 0) {
+            throw new Error(`App with ID ${appId} not found.`);
+          }
+
+          const currentIsFavorite = result[0].isFavorite;
+
+          // Toggle the isFavorite value
+          const updated = await db
+            .update(apps)
+            .set({ isFavorite: !currentIsFavorite })
+            .where(eq(apps.id, appId))
+            .returning({ isFavorite: apps.isFavorite });
+
+          if (updated.length === 0) {
+            throw new Error(
+              `Failed to update favorite status for app ID ${appId}.`,
+            );
+          }
+
+          // Return the updated isFavorite value
+          return { isFavorite: updated[0].isFavorite };
+        } catch (error: any) {
+          logger.error(
+            `Error in add-to-favorite handler for app ID ${appId}:`,
+            error,
+          );
+          throw new Error(`Failed to toggle favorite status: ${error.message}`);
+        }
+      });
+    },
+  );
+
   ipcMain.handle(
     "rename-app",
     async (

src/ipc/ipc_client.ts

@@ -274,6 +274,20 @@ export class IpcClient {
     return this.ipcRenderer.invoke("get-app", appId);
   }
 
+  public async addAppToFavorite(
+    appId: number,
+  ): Promise<{ isFavorite: boolean }> {
+    try {
+      const result = await this.ipcRenderer.invoke("add-to-favorite", {
+        appId,
+      });
+      return result;
+    } catch (error) {
+      showError(error);
+      throw error;
+    }
+  }
+
   public async getAppEnvVars(
     params: GetAppEnvVarsParams,
   ): Promise<{ key: string; value: string }[]> {

src/ipc/ipc_types.ts

@@ -99,6 +99,7 @@ export interface App {
   vercelDeploymentUrl: string | null;
   installCommand: string | null;
   startCommand: string | null;
+  isFavorite: boolean;
 }
 
 export interface Version {

src/preload.ts

@@ -127,6 +127,8 @@ const validInvokeChannels = [
   "prompts:create",
   "prompts:update",
   "prompts:delete",
+  // adding app to favorite
+  "add-to-favorite",
   // Test-only channels
   // These should ALWAYS be guarded with IS_TEST_BUILD in the main process.
   // We can't detect with IS_TEST_BUILD in the preload script because