Remove the Electron version

src/main/App.tsx

@@ -1,6 +1,5 @@
 import { BrowserRouter, Routes, Route, useNavigate, useLocation, matchRoutes, Navigate, type RouteObject } from "react-router-dom";
 import { AnimatePresence, motion } from "motion/react";
-import { ElectronTitleBar } from "./Electron";
 import { useUserStore } from "./state/user";
 import { lazy, useEffect, useRef, useState } from "react";
 import { parseProfileLink } from "./core/profileLinks";
@@ -133,7 +132,6 @@ export default function App() {
     
     return authReady && (
         <BrowserRouter>
-            <ElectronTitleBar />
             <AlertDialogProvider />
             <div id="main-wrapper">
                 <AnimatedRoutes />

src/main/Electron.tsx

@@ -1,11 +0,0 @@
-import { PRODUCT_NAME } from "./core/config";
-import { isElectron } from "./core/electron/electron";
-
-export function ElectronTitleBar() {
-    return isElectron && (
-        <div id="electron-title-bar">
-            {window.electronInterface.platform == "darwin" && <div className="macos-padding"></div>}
-            <div id="window-title">{PRODUCT_NAME}</div>
-        </div>
-    )
-}

src/main/core/electron/electron.scss

@@ -1,41 +0,0 @@
-@use "../../css/material" as *;
-
-#electron-title-bar {
-    display: none;
-}
-
-html.electron {
-    #electron-title-bar {
-        display: flex;
-        flex-direction: row;
-        gap: 8px;
-        min-height: 40px;
-        background-color: $color-dark-surface-container;
-        width: 100%;
-        -webkit-app-region: drag;
-        user-select: none;
-        z-index: 10;
-        transition: background-color 0.5s ease;
-        flex-shrink: 0;
-
-        &.color-surface {
-            background-color: $color-dark-surface;
-        }
-    }
-
-    #window-title {
-        flex: 1;
-        display: flex;
-        align-items: center;
-        font-weight: 500;
-    }
-
-    #main-wrapper {
-        flex: 1;
-        min-height: 0;
-    }
-
-    &.platform-darwin .macos-padding {
-        width: 80px;
-    }
-}

src/main/core/electron/electron.ts

@@ -1,17 +0,0 @@
-/**
- * @fileoverview Electron-specific code
- * @description This module initializes Electron-specific functionality.
- * @author denis0001-dev
- * @version 1.0.0
- */
-
-import "./electron.scss";
-
-export const isElectron = import.meta.env.VITE_ELECTRON && window.electronInterface != undefined;
-
-if (isElectron) {
-    console.log("Running in Electron");
-    document.documentElement.classList.add("electron", `platform-${window.electronInterface.platform}`);
-} else {
-    console.log("Running in normal browser");
-}

src/main/core/init.ts

@@ -7,7 +7,8 @@
 
 import { PRODUCT_NAME } from "./config";
 import { enableMapSet } from "immer";
-import type { Platform } from "../../electron/electron.d";
+
+type Platform = "win32" | "darwin" | "linux";
 
 function detectPlatform(): Platform {
     const userAgent = navigator.userAgent.toLowerCase();

src/main/core/push-notifications/push-notifications.ts

@@ -1,9 +1,5 @@
 import api from "@/core/api";
-import { isElectron } from "@/core/electron/electron";
-import { websocket } from "@/core/websocket";
-import type { NewMessageWebSocketMessage, WebSocketMessage } from "@/core/types";
 import serviceWorker from "./service-worker?worker&url";
-import logo from "@/images/logo.svg";
 
 export interface PushSubscriptionData {
     endpoint: string;
@@ -26,8 +22,6 @@ export interface NotificationPayload {
 let isInitialized = false;
 let registration: ServiceWorkerRegistration | null = null;
 let subscription: PushSubscription | null = null;
-let isElectronReceiverRunning = false;
-let messageListener: ((event: MessageEvent) => void) | null = null;
 
 // Helper functions
 function urlBase64ToUint8Array(base64String: string): Uint8Array {
@@ -97,35 +91,6 @@ async function sendSubscriptionToServer(token: string): Promise<boolean> {
     }
 }
 
-async function showMessageNotification(message: any): Promise<void> {
-    try {
-        await showNotification({
-            title: `New message from ${message.username}`,
-            body: message.content.length > 100
-                ? message.content.substring(0, 100) + "..."
-                : message.content,
-            icon: message.profile_picture || logo,
-            tag: `message_${message.id}`,
-            data: {
-                type: "public_message",
-                message_id: message.id,
-                sender_id: message.user_id,
-                sender_username: message.username
-            }
-        });
-    } catch (error) {
-        console.error("Failed to show message notification:", error);
-    }
-}
-
-async function handleWebSocketMessage(response: WebSocketMessage<any>): Promise<void> {
-    // Handle notifications for new messages
-    if (response.type === "newMessage" && response.data) {
-        const newResponse = response as NewMessageWebSocketMessage;
-        await showMessageNotification(newResponse.data);
-    }
-}
-
 // Public API functions
 export async function initialize(): Promise<boolean> {
     if (isInitialized) {
@@ -133,32 +98,24 @@ export async function initialize(): Promise<boolean> {
     }
 
     try {
-        if (isElectron) {
-            // For Electron, we just need to request permission
-            const permission = await window.electronInterface.notifications.requestPermission();
-            isInitialized = permission === "granted";
+        if (!("serviceWorker" in navigator) || !("PushManager" in window)) {
+            console.log("Push messaging is not supported");
+            return false;
+        }
+
+        try {
+            registration = await navigator.serviceWorker.register(serviceWorker, { type: "module" });
+            console.log("Service Worker registered successfully");
+
+            const permission = await Notification.requestPermission();
+            if (permission === "granted") {
+                await subscribeToWebPush();
+                isInitialized = true;
+            }
             return isInitialized;
-        } else {
-            // For web browsers, initialize service worker and push manager
-            if (!("serviceWorker" in navigator) || !("PushManager" in window)) {
-                console.log("Push messaging is not supported");
-                return false;
-            }
-
-            try {
-                registration = await navigator.serviceWorker.register(serviceWorker, { type: "module" });
-                console.log("Service Worker registered successfully");
-
-                const permission = await Notification.requestPermission();
-                if (permission === "granted") {
-                    await subscribeToWebPush();
-                    isInitialized = true;
-                }
-                return isInitialized;
-            } catch (error) {
-                console.error("Service Worker registration failed:", error);
-                return false;
-            }
+        } catch (error) {
+            console.error("Service Worker registration failed:", error);
+            return false;
         }
     } catch (error) {
         console.error("Failed to initialize notification service:", error);
@@ -171,11 +128,6 @@ export async function subscribe(token: string): Promise<boolean> {
         return false;
     }
 
-    if (isElectron) {
-        // In Electron, we don't need server-side subscription
-        return true;
-    }
-
     // If subscription doesn't exist, try to get it from the push manager or create a new one
     if (!subscription && registration) {
         try {
@@ -194,32 +146,12 @@ export async function subscribe(token: string): Promise<boolean> {
     return await sendSubscriptionToServer(token);
 }
 
-export async function showNotification(payload: NotificationPayload): Promise<boolean> {
-    if (isElectron) {
-        try {
-            return await window.electronInterface.notifications.show({
-                title: payload.title,
-                body: payload.body,
-                icon: payload.icon,
-                tag: payload.tag
-            });
-        } catch (error) {
-            console.error("Failed to show Electron notification:", error);
-            return false;
-        }
-    }
-
-    // For web browsers, notifications are handled by the service worker
-    // when push messages are received from the server
+export async function showNotification(_payload: NotificationPayload): Promise<boolean> {
+    // Notifications are handled by the service worker when push messages are received from the server
     return false;
 }
 
 export async function unsubscribe(): Promise<boolean> {
-    if (isElectron) {
-        // In Electron, we don't need to unsubscribe from server
-        return true;
-    }
-
     if (!subscription) {
         return true;
     }
@@ -235,43 +167,5 @@ export async function unsubscribe(): Promise<boolean> {
 }
 
 export function isSupported(): boolean {
-    if (isElectron) {
-        return true; // Electron always supports notifications
-    }
     return "serviceWorker" in navigator && "PushManager" in window;
 }
-
-// Electron-specific functions
-export async function startElectronReceiver(): Promise<void> {
-    if (!isElectron || isElectronReceiverRunning) {
-        return;
-    }
-
-    isElectronReceiverRunning = true;
-
-    // Add our own message listener to the existing WebSocket
-    messageListener = (event: MessageEvent) => {
-        try {
-            const response: WebSocketMessage<any> = JSON.parse(event.data);
-            handleWebSocketMessage(response);
-        } catch (error) {
-            console.error('Failed to parse WebSocket message:', error);
-        }
-    };
-
-    websocket.addEventListener('message', messageListener);
-}
-
-export function stopElectronReceiver(): void {
-    if (!isElectron) {
-        return;
-    }
-
-    isElectronReceiverRunning = false;
-
-    // Remove our message listener
-    if (messageListener) {
-        websocket.removeEventListener('message', messageListener);
-        messageListener = null;
-    }
-}

src/main/main.tsx

@@ -9,7 +9,6 @@ import './css/style.scss';
 
 import "./utils/material";
 import "./core/init";
-import "./core/electron/electron";
 import { createRoot } from 'react-dom/client';
 import App from './App';
 import { StrictMode } from 'react';

src/main/pages/auth/LoginForm.tsx

@@ -7,8 +7,7 @@ import { useUserStore } from "@/state/user";
 import { MaterialButton } from "@/utils/material";
 import api from "@/core/api";
 import { AuthTextField, type AuthTextFieldHandle } from "./AuthTextField";
-import { initialize, isSupported, startElectronReceiver, subscribe } from "@/core/push-notifications/push-notifications";
-import { isElectron } from "@/core/electron/electron";
+import { initialize, isSupported, subscribe } from "@/core/push-notifications/push-notifications";
 import type { Alert, AlertType } from "./Auth";
 import { AuthHeader, AlertsContainer } from "./Auth";
 import styles from "./auth.module.scss";
@@ -115,11 +114,6 @@ export function LoginForm({ onSwitchMode }: LoginFormProps) {
                         const initialized = await initialize();
                         if (initialized) {
                             await subscribe(data.token);
-
-                            if (isElectron) {
-                                await startElectronReceiver();
-                            }
-
                             console.log("Notifications enabled");
                         } else {
                             console.log("Notification permission denied");

src/main/pages/chat/ui/left/settings/NotificationsPanel.tsx

@@ -2,7 +2,6 @@ import { useState, useRef } from "react";
 import { MaterialList, MaterialListItem, MaterialSwitch, type MDUISwitch } from "@/utils/material";
 import { useUserStore } from "@/state/user";
 import { initialize, subscribe, unsubscribe, isSupported } from "@/core/push-notifications/push-notifications";
-import { isElectron } from "@/core/electron/electron";
 import api from "@/core/api";
 import styles from "@/pages/chat/css/settings-dialog.module.scss";
 
@@ -23,12 +22,7 @@ export function NotificationsPanel() {
 
         setChecking(true);
         try {
-            let permission: string;
-            if (isElectron) {
-                permission = await window.electronInterface.notifications.requestPermission();
-            } else {
-                permission = Notification.permission;
-            }
+            const permission = Notification.permission;
             console.log("checkPushStatus", permission);
             setPushEnabled(permission === "granted");
         } catch (error) {

src/main/state/user.ts

@@ -2,8 +2,7 @@ import { create } from "zustand";
 import type { User } from "@/core/types";
 import api from "@/core/api";
 import { API_BASE_URL } from "@/core/config";
-import { initialize, subscribe, startElectronReceiver, isSupported } from "@/core/push-notifications/push-notifications";
-import { isElectron } from "@/core/electron/electron";
+import { initialize, subscribe, isSupported } from "@/core/push-notifications/push-notifications";
 import { onlineStatusManager } from "@/core/onlineStatusManager";
 import { typingManager } from "@/core/typingManager";
 import type { UserState } from "./types";
@@ -126,10 +125,6 @@ export const useUserStore = create<UserStore>((set) => ({
                             const initialized = await initialize();
                             if (initialized) {
                                 await subscribe(token);
-
-                                if (isElectron) {
-                                    await startElectronReceiver();
-                                }
                             }
                         }
                     } catch (e) {